PyTorch 2.0 チュートリアル : 画像と動画 : DCGAN チュートリアル (翻訳/解説)
翻訳 : (株)クラスキャット セールスインフォメーション
作成日時 : 05/04/2023 (2.0.0)
* 本ページは、PyTorch 2.0 Tutorials の以下のページを翻訳した上で適宜、補足説明したものです：
- Image and Video : DCGAN Tutorial
* サンプルコードの動作確認はしておりますが、必要な場合には適宜、追加改変しています。
* ご自由にリンクを張って頂いてかまいませんが、sales-info@classcat.com までご一報いただけると嬉しいです。
- 人工知能研究開発支援
- 人工知能研修サービス(経営者層向けオンサイト研修)
- テクニカルコンサルティングサービス
- 実証実験(プロトタイプ構築)
- アプリケーションへの実装
- 人工知能研修サービス
- PoC(概念実証)を失敗させないための支援
- お住まいの地域に関係なく Web ブラウザからご参加頂けます。事前登録 が必要ですのでご注意ください。
◆ お問合せ : 本件に関するお問い合わせ先は下記までお願いいたします。
- 株式会社クラスキャット セールス・マーケティング本部 セールス・インフォメーション
- sales-info@classcat.com ; Website: www.classcat.com ; ClassCatJP
>PyTorch 2.0 チュートリアル : 画像と動画 : DCGAN チュートリアル
イントロダクション
このチュートリアルはサンプルを通して DCGAN へのイントロダクションを与えます。多くの実際のセレブ (= celebrities, 有名人) の写真を見せた後で新しいセレブを生成するために敵対的生成ネットワーク (GAN, Generative Adversarial Network) を訓練します。ここでのコードの殆どは pytorch/examples の dcgan 実装からのもので、そしてこのドキュメントは実装の徹底的な説明を与えてこのモデルがどのようにそして何故動作するのかを明らかにします。しかし心配しないでください、GAN の事前知識は必要ありません、しかし内部で実際に何が起きているかについて納得するために初心者はある程度の時間を費やす必要があるかもしれません。また、時間 (節約) のために一つ、または 2 つの GPU を持つことが役立つでしょう。最初から始めましょう。
敵対的生成ネットワーク
What is a GAN?
GAN は訓練データの分布を捕捉することを深層学習モデルに教えるためのフレームワークですのでその同じ分布から新しいデータを生成できます。GAN は 2014 年に Ian Goodfellow により創案されてペーパー Generative Adversarial Nets で最初に説明されました。それらは 2 つの別個のモデル、generator と discriminator から成ります。generator のジョブは訓練画像のように見える ‘fake’ 画像を生むことです。discriminator のジョブは画像を見てそれが real 訓練画像か (generator からの) fake 画像かを出力することです。訓練の間、generator はより良い fake を生成することにより絶えず discriminator を出し抜こうとします、その一方で discriminator はより良い探偵になり real と fake 画像を正しく分類するために動作しています。このゲームの均衡は generator が訓練データに直接由来するかのように見える完全な fake を生成しているとき、そして discriminator は generator 出力が real か fake か常に 50% の信頼度で推測する状態にされることです。
今は、discriminator から始める、チュートリアルを通して使用される幾つかの記法を定義しましょう。$x$ を画像を表わすデータとしましょう。\(D(x)\) は discriminator ネットワークで、これは \(x\) が generator ではなく訓練データに由来する (スカラー) 確率を出力します。ここでは、画像を扱っていますから \(D(x)\) への入力は CHW サイズ 3x64x64 の画像です。直感的には、\(x\) が訓練データに由来するときは \(D(x)\) は HIGH で、\(x\) が generator 由来であるときは LOW です。\(D(x)\) は伝統的な二値分類器として考えることもできます。
generator の記法については、\(z\) を標準正規分布からサンプリングされた潜在空間ベクトルとしましょう。\(G(z)\) は generator 関数を表します、これは潜在ベクトル \(z\) をデータ空間にマップします。\(G\) の目標は訓練データが由来する分布 (\(p_{data}\)) を推定することですからそれはその推定された分布 (\(p_g\)) からの fake サンプルを生成できます。
従って、\(D(G(z))\) は generator \(G\) の出力が real 画像である確率 (スカラー) です。Goodfellow のペーパー で記述されているように、\(D\) と \(G\) は minimax ゲームをプレーしていてそこでは \(D\) はそれが real と fake を正しく分類する確率 (\(logD(x)\)) を最大化することを試み、そして \(G\) は \(D\) がその出力が fake であると予測する確率 (\(log(1-D(G(x)))\)) を最小化しようとします。ペーパーから、GAN 損失関数は :
\[
\underset{G}{\text{min}} \underset{D}{\text{max}}V(D,G) = \mathbb{E}_{x\sim p_{data}(x)}\big[logD(x)\big] + \mathbb{E}_{z\sim p_{z}(z)}\big[log(1-D(G(x)))\big]
\]
理論的には、この minimax ゲームへの解は \(p_g = p_{data}\) であるところで、そしてdiscriminator は入力が real か fake かランダムに推測します。けれども、GAN の収束理論は依然として活発に研究されていて現実にはモデルは常にこのポイントまで訓練が進むわけではありません。
What is a DCGAN?
DCGAN は上で記述された GAN の直接的な拡張です、それが discriminator と generator でそれぞれ畳込みと転置畳込み (= convolutional-transpose) 層を明示的に使用することを除いてです。それは Radford et. al. によりペーパー Unsupervised Representation Learning With Deep Convolutional Generative Adversarial Networks で最初に説明されました。discriminator は strided 畳込み 層、 バッチ正規化 層そして LeakyReLU 活性から成ります。入力は 3x64x64 入力画像で出力は real データ分布からの入力であるスカラー確率です。generator は 転置畳込み 層、バッチ正規化層そして ReLU 活性から成ります。入力は潜在ベクトル $z$、これは標準正規分布からドローされます、そして出力は 3x64x64 RGB 画像です。strided 転置畳込み層は潜在ベクトルに画像と同じ shape を持つボリュームへと変換されることを可能にします。このペーパーでは、optimizer をどのようにセットアップするか、損失関数をどのように計算するか、そしてモデル重みをどのように初期化するかについて著者はまた幾つかの tips を与えています、その総てが以下のセクションで説明されます。
from __future__ import print_function
#%matplotlib inline
import argparse
import os
import random
import torch
import torch.nn as nn
import torch.nn.parallel
import torch.backends.cudnn as cudnn
import torch.optim as optim
import torch.utils.data
import torchvision.datasets as dset
import torchvision.transforms as transforms
import torchvision.utils as vutils
import numpy as np
import matplotlib.pyplot as plt
import matplotlib.animation as animation
from IPython.display import HTML
# Set random seed for reproducibility
manualSeed = 999
#manualSeed = random.randint(1, 10000) # use if you want new results
print("Random Seed: ", manualSeed)
random.seed(manualSeed)
torch.manual_seed(manualSeed)
Random Seed: 999 <torch._C.Generator object at 0x7fc956e30030>
入力
実行のための幾つかの入力を定義しましょう :
- dataroot – データセット・フォルダのルートへのパス。次のセクションでデータセットについて更に話します。
- workers – DataLoader でデータをロードするためのワーカー・スレッドの数
- batch_size – 訓練で使用されるバッチサイズ。DCGAN ペーパーは 128 のバッチサイズを使用しています。
- image_size – 訓練のために使用される画像の空間サイズ。この実装は 64×64 をデフォルトとします。他のサイズが望まれる場合、D と G の構造は変更されなければなりません。より詳細は こちら を見てください。
- nc – 入力画像のカラーチャネルの数。カラー画像に対してはこれは 3 です。
- nz – 潜在ベクトルの長さ。
- ngf – generator を通して運ばれる特徴マップの深さに関連します。
- ndf – discriminator を通して伝播される特徴マップの深さを設定します。
- num_epochs – 実行する訓練エポックの数。より長い間の訓練は多分より良い結果につながるでしょうがまた遥かに長くかかります。
- lr – 訓練のための学習率。DCGAN ペーパーで記述されているように、この数字は 0.0002 であるべきです。
- beta1 – Adam optimizer のための beta1 ハイパーパラメータ。ペーパーで記述されているように、この数は 0.5 であるべきです。
- ngpu – 利用可能な GPU の数。これが 0 であれば、コードは CPU モードで動作します。この数が 0 より大きい場合にはそれはその数の GPU 上で動作します。
# Root directory for dataset
dataroot = "data/celeba"
# Number of workers for dataloader
workers = 2
# Batch size during training
batch_size = 128
# Spatial size of training images. All images will be resized to this
# size using a transformer.
image_size = 64
# Number of channels in the training images. For color images this is 3
nc = 3
# Size of z latent vector (i.e. size of generator input)
nz = 100
# Size of feature maps in generator
ngf = 64
# Size of feature maps in discriminator
ndf = 64
# Number of training epochs
num_epochs = 5
# Learning rate for optimizers
lr = 0.0002
# Beta1 hyperparameter for Adam optimizers
beta1 = 0.5
# Number of GPUs available. Use 0 for CPU mode.
ngpu = 1
データ
このチュートリアルでは Celeb-A Faces データセット を使用します、これはリンクされたサイトか Google Drive でダウンロードできます。データセットは img_align_celeba.zip という名前のファイルとしてダウンロードされます。ひとたびダウンロードされたら、celeba という名前のディレクトリを作成して zip ファイルをそのディレクトリに解凍します。それからこの notebook のための datroot 入力を (ちょうど作成した) celeba ディレクトリに設定してください。結果としてのディレクトリ構造は以下のようになるはずです :
/path/to/celeba
-> img_align_celeba
-> 188242.jpg
-> 173822.jpg
-> 284702.jpg
-> 537394.jpg
...
これは重要なステップです、何故ならばデータセットの root フォルダにサブディレクトリがあることを要求する ImageFolder dataset クラスを使用していくからです。今は、データセットを作成して、dataloader を作成して、その上で動作するデバイスを設定してそして最後に訓練データの幾つかを可視化します。
# We can use an image folder dataset the way we have it setup.
# Create the dataset
dataset = dset.ImageFolder(root=dataroot,
transform=transforms.Compose([
transforms.Resize(image_size),
transforms.CenterCrop(image_size),
transforms.ToTensor(),
transforms.Normalize((0.5, 0.5, 0.5), (0.5, 0.5, 0.5)),
]))
# Create the dataloader
dataloader = torch.utils.data.DataLoader(dataset, batch_size=batch_size,
shuffle=True, num_workers=workers)
# Decide which device we want to run on
device = torch.device("cuda:0" if (torch.cuda.is_available() and ngpu > 0) else "cpu")
# Plot some training images
real_batch = next(iter(dataloader))
plt.figure(figsize=(8,8))
plt.axis("off")
plt.title("Training Images")
plt.imshow(np.transpose(vutils.make_grid(real_batch[0].to(device)[:64], padding=2, normalize=True).cpu(),(1,2,0)))
実装
入力パラメータが設定されてデータセットが準備された今、実装に入ることができます。重み初期化ストラテジーから始めて、そして generator、discriminator、損失関数そして訓練ループについて詳細に語ります。
重み初期化
DCGAN ペーパーから、著者は総てのモデル重みは mean=0, stdev=0.02 を持つ正規分布からランダムに初期化されることを指定しています。weights_init 関数は入力として初期化されたモデルを取りそして総ての畳込み、転置畳込みそしてバッチ正規化層をこの規準を満たすように再初期化します。この関数は初期化後直ちにモデルに適用されます。
# custom weights initialization called on ``netG`` and ``netD``
def weights_init(m):
classname = m.__class__.__name__
if classname.find('Conv') != -1:
nn.init.normal_(m.weight.data, 0.0, 0.02)
elif classname.find('BatchNorm') != -1:
nn.init.normal_(m.weight.data, 1.0, 0.02)
nn.init.constant_(m.bias.data, 0)
Generator
generator $G$ は潜在空間ベクトル ($z$) をデータ空間にマップするように設計されています。私達のデータは画像ですので、$z$ をデータ空間に変換することは究極的には訓練画像と同じサイズ (i.e. 3x64x64) を持つ RGB 画像を作成することを意味します。実際には、これは一連の strided 2 次元転置畳込み層を通して達成されます、各々は 2d バッチ正規化層と relu 活性と組み合わされています。generator の出力はそれを [-1, 1] の入力データ範囲に戻すために tanh 関数を通して供給されます。転置畳込み層の後のバッチ正規化関数の存在は注目すべきです、何故ならばこれは DCGAN ペーパーの重要な寄与であるからです。これらの層は訓練の間勾配のフローに役立ちます。DCGAN ペーパーからの generator の画像は下で示されます。
入力セクションで設定した入力 (nz, ngf と nc) がコードの generator アーキテクチャにどのように影響するかに注意してください。nz は z 入力ベクトルの長さで、ngf は generator を通して伝播される特徴マップのサイズに関係し、そして nc は出力画像のチャネル数です (RGB 画像のためには 3 に設定)。下は generator のためのコードです。
# Generator Code
class Generator(nn.Module):
def __init__(self, ngpu):
super(Generator, self).__init__()
self.ngpu = ngpu
self.main = nn.Sequential(
# input is Z, going into a convolution
nn.ConvTranspose2d( nz, ngf * 8, 4, 1, 0, bias=False),
nn.BatchNorm2d(ngf * 8),
nn.ReLU(True),
# state size. ``(ngf*8) x 4 x 4``
nn.ConvTranspose2d(ngf * 8, ngf * 4, 4, 2, 1, bias=False),
nn.BatchNorm2d(ngf * 4),
nn.ReLU(True),
# state size. ``(ngf*4) x 8 x 8``
nn.ConvTranspose2d( ngf * 4, ngf * 2, 4, 2, 1, bias=False),
nn.BatchNorm2d(ngf * 2),
nn.ReLU(True),
# state size. ``(ngf*2) x 16 x 16``
nn.ConvTranspose2d( ngf * 2, ngf, 4, 2, 1, bias=False),
nn.BatchNorm2d(ngf),
nn.ReLU(True),
# state size. ``(ngf) x 32 x 32``
nn.ConvTranspose2d( ngf, nc, 4, 2, 1, bias=False),
nn.Tanh()
# state size. ``(nc) x 64 x 64``
)
def forward(self, input):
return self.main(input)
今、generator をインスタンス化して weights_init 関数を適用することができます。generator オブジェクトがどのように構造化されているかを見るためにプリントされたモデルを調べてください。
# Create the generator
netG = Generator(ngpu).to(device)
# Handle multi-GPU if desired
if (device.type == 'cuda') and (ngpu > 1):
netG = nn.DataParallel(netG, list(range(ngpu)))
# Apply the ``weights_init`` function to randomly initialize all weights
# to ``mean=0``, ``stdev=0.02``.
netG.apply(weights_init)
# Print the model
print(netG)
Generator(
(main): Sequential(
(0): ConvTranspose2d(100, 512, kernel_size=(4, 4), stride=(1, 1), bias=False)
(1): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
(2): ReLU(inplace=True)
(3): ConvTranspose2d(512, 256, kernel_size=(4, 4), stride=(2, 2), padding=(1, 1), bias=False)
(4): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
(5): ReLU(inplace=True)
(6): ConvTranspose2d(256, 128, kernel_size=(4, 4), stride=(2, 2), padding=(1, 1), bias=False)
(7): BatchNorm2d(128, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
(8): ReLU(inplace=True)
(9): ConvTranspose2d(128, 64, kernel_size=(4, 4), stride=(2, 2), padding=(1, 1), bias=False)
(10): BatchNorm2d(64, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
(11): ReLU(inplace=True)
(12): ConvTranspose2d(64, 3, kernel_size=(4, 4), stride=(2, 2), padding=(1, 1), bias=False)
(13): Tanh()
)
)
Discriminator
言及したように、discriminator $D$ は二値分類ネットワークで、これは入力として画像を取り入力画像が (fake に対立する) real であるスカラー確率を出力します。ここでは、$D$ は 3x64x64 入力画像を取り、それを Conv2d, BatchNorm2d そして LeakyReLU 層のシリーズを通して処理し、そして Sigmoid 活性化関数を通して最後の確率を出力します。問題のために必要であればこのアーキテクチャはより多くの層により拡張可能ですが、strided 畳込み、BatchNorm と LeakyReLU の使用は意義があります。DCGAN ペーパーはダウンサンプリングにプーリングよりも strided 畳込みを利用することは良い実践であることに言及しています、何故ならばそれはネットワークにそれ自身のプーリング関数を学習させるからです。またバッチ正規化と leaky relu 関数は健全な勾配フローを促進します、これは $G$ と $D$ の両者の学習過程のために重要です。
Discriminator コード
class Discriminator(nn.Module):
def __init__(self, ngpu):
super(Discriminator, self).__init__()
self.ngpu = ngpu
self.main = nn.Sequential(
# input is ``(nc) x 64 x 64``
nn.Conv2d(nc, ndf, 4, 2, 1, bias=False),
nn.LeakyReLU(0.2, inplace=True),
# state size. ``(ndf) x 32 x 32``
nn.Conv2d(ndf, ndf * 2, 4, 2, 1, bias=False),
nn.BatchNorm2d(ndf * 2),
nn.LeakyReLU(0.2, inplace=True),
# state size. ``(ndf*2) x 16 x 16``
nn.Conv2d(ndf * 2, ndf * 4, 4, 2, 1, bias=False),
nn.BatchNorm2d(ndf * 4),
nn.LeakyReLU(0.2, inplace=True),
# state size. ``(ndf*4) x 8 x 8``
nn.Conv2d(ndf * 4, ndf * 8, 4, 2, 1, bias=False),
nn.BatchNorm2d(ndf * 8),
nn.LeakyReLU(0.2, inplace=True),
# state size. ``(ndf*8) x 4 x 4``
nn.Conv2d(ndf * 8, 1, 4, 1, 0, bias=False),
nn.Sigmoid()
)
def forward(self, input):
return self.main(input)
さて、generator の場合と同様に、discriminator を作成し、weights_init 関数を適用しそしてモデルの構造をプリントすることができます。
# Create the Discriminator
netD = Discriminator(ngpu).to(device)
# Handle multi-GPU if desired
if (device.type == 'cuda') and (ngpu > 1):
netD = nn.DataParallel(netD, list(range(ngpu)))
# Apply the ``weights_init`` function to randomly initialize all weights
# like this: ``to mean=0, stdev=0.2``.
netD.apply(weights_init)
# Print the model
print(netD)
Discriminator(
(main): Sequential(
(0): Conv2d(3, 64, kernel_size=(4, 4), stride=(2, 2), padding=(1, 1), bias=False)
(1): LeakyReLU(negative_slope=0.2, inplace=True)
(2): Conv2d(64, 128, kernel_size=(4, 4), stride=(2, 2), padding=(1, 1), bias=False)
(3): BatchNorm2d(128, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
(4): LeakyReLU(negative_slope=0.2, inplace=True)
(5): Conv2d(128, 256, kernel_size=(4, 4), stride=(2, 2), padding=(1, 1), bias=False)
(6): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
(7): LeakyReLU(negative_slope=0.2, inplace=True)
(8): Conv2d(256, 512, kernel_size=(4, 4), stride=(2, 2), padding=(1, 1), bias=False)
(9): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
(10): LeakyReLU(negative_slope=0.2, inplace=True)
(11): Conv2d(512, 1, kernel_size=(4, 4), stride=(1, 1), bias=False)
(12): Sigmoid()
)
)
損失関数と Optimizer
$D$ と $G$ のセットアップで、それらが損失関数と optimizer を通してどのように学習するかを指定できます。私達は二値交差エントロピー損失 (BCELoss) 関数を使用します、これは PyTorch で次のように定義されています :
\[
\ell(x, y) = L = \{l_1,\dots,l_N\}^\top, \quad l_n = – \left[ y_n \cdot \log x_n + (1 – y_n) \cdot \log (1 – x_n) \right]
\]
この関数が目的関数の両者の log 成分 ((i.e. \(log(D(x))\) と \(log(1-D(G(z)))\))) の計算をどのように提供するかに注意してください。$y$ 入力で BCE 等式のどの部分を使用するかを指定できます。これは間もなく取り上げる訓練ループで成されますが、単に $y$ (i.e. GT ラベル) を変更することによりどの成分を計算することを望むかをどのように選択できるかを理解することは重要です。
次に、私達の real ラベルを 1 としてそして fake ラベルを 0 として定義します。これらのラベルは \(D\) と \(G\) の損失を計算するときに使用されて、そしてこれはまた元の GAN ペーパーで使用された慣習です。最後に、2 つの個別の optimizer をセットアップします、一つは $D$ のためで一つは $G$ のためです。DCGAN ペーパーで指定されているように、両者は学習率 0.0002 と Beta1 = 0.5 を持つ Adam optimizer です。generator の学習進捗を追跡するために、ガウス分布からドローされた潜在ベクトルの固定バッチを生成します (i.e. fixed_noise) 。訓練ループでは、この fixed_noise を $G$ に定期的に入力します、そして反復に渡りノイズから形成される画像を見ます。
# Initialize the ``BCELoss`` function
criterion = nn.BCELoss()
# Create batch of latent vectors that we will use to visualize
# the progression of the generator
fixed_noise = torch.randn(64, nz, 1, 1, device=device)
# Establish convention for real and fake labels during training
real_label = 1.
fake_label = 0.
# Setup Adam optimizers for both G and D
optimizerD = optim.Adam(netD.parameters(), lr=lr, betas=(beta1, 0.999))
optimizerG = optim.Adam(netG.parameters(), lr=lr, betas=(beta1, 0.999))
訓練
最後に、GAN フレームワークの総てのパートを定義した今、それを訓練できます。GAN を訓練することは幾分芸術形式であることに留意してください、というのは正しくないハイパーパラメータ設定は何が間違っていたか殆ど説明を持たないで崩壊モードに繋がるでしょう。ここでは、Goodfellow のペーパーから Algorithm 1 に密接に従います、その一方で ganhacks で示されるベストプラクティスの幾つかを守っています。すなわち、“construct different mini-batches for real and fake (画像)” を行ない、そしてまた \(logD(G(z))\) を最大化するために G の目的関数を調整します。訓練は 2 つの主要パートに分割されます。Part 1 は Discriminator を更新してそして Part 2 は Generator を更新します。
Part 1 – Discriminator を訓練する
思い出してください、discriminator を訓練するゴールは与えられた入力を real か fake として正しく分類する確率を最大化することです。Goodfellow の言葉では、“update the discriminator by ascending its stochastic gradient (その確率的勾配を登ることにより discriminator を更新する)” ことを望みます。実際には、\(log(D(x)) + log(1-D(G(z)))\) を最大化することを望みます。ganhacks からの separate したミニバッチ提案によって、これを 2 つのステップで計算します。最初に、訓練セットから real サンプルのバッチを構築して、\(D\) を通して forward パスして、損失 \(log(D(x))\)) を計算して、それから backward パスで勾配を計算します。2 番目に、現在の generator で fake サンプルのバッチを構築して、\(D\) を通してこのバッチを forward パスして 、損失 (\(log(1-D(G(z)))\)) を計算し、そして backward パスで勾配を累積します。今、all-real と all-fake の両者のバッチから累積された勾配で、Discriminator の optimizer のステップを呼び出します。
Part 2 – Generator を訓練する
元のペーパーで述べられているように、より良い fake を生成する努力において \(log(1-D(G(z)))\) を最小化することにより Generator を訓練することを望みます。言及したように、特に学習過程の早期では、これは十分な勾配を提供しないことが Goodfellow により示されました。その処置として、代わりに \(log(D(G(z)))\) を最大化することを望みます。コードではこれを以下により達成します : Part 1 からの Generator 出力を Discriminator で分類し、real ラベルを GT として使用して G の損失を計算し、backward パスで G の勾配を計算し、そして最後に optimizer ステップで G のパラメータを更新します。損失関数のために real ラベルを GT ラベルとして使用することは直感に反するかもしれませんが、これは BCELoss の (\(log(1-x)\) 部ではなく) \(log(x)\) 部を使用することを可能にし、これは正確に私達が望むものです。
最後に、幾つかの統計的レポーティングを行ないそして各エポックの最後に fixed_noise バッチを generator を通してプッシュして G の訓練の進捗を視覚的に追跡します。レポートされる訓練統計情報は :
- Loss_D – 総ての real と総ての fake バッチのための損失の総計として計算された discriminator 損失 \(log(D(x)) + log(D(G(z)))\)) 。
- Loss_G – \(log(D(G(z)))\) として計算される generator 損失
- D(x) – 総ての real バッチに対する discriminator の (バッチに渡る) 平均出力。これは 1 近くから始まるはずで、それから理論的には G がより良くなるとき 0.5 に収束します。Think about why this is.
- D(G(z)) – 総ての fake バッチ対する平均 discriminator 出力。最初の数は D が更新される前で 2 番目の数は D が更新される後です。これらの数は 0 近くで始まり G がより良くなるとき 0.5 に収束します。Think about why this is.
Note: このステップは少し時間がかかるかもしれません、幾つのエポックを実行するかそしてデータセットから幾つのデータを除去したか否かに依存して。
# Training Loop
# Lists to keep track of progress
img_list = []
G_losses = []
D_losses = []
iters = 0
print("Starting Training Loop...")
# For each epoch
for epoch in range(num_epochs):
# For each batch in the dataloader
for i, data in enumerate(dataloader, 0):
############################
# (1) Update D network: maximize log(D(x)) + log(1 - D(G(z)))
###########################
## Train with all-real batch
netD.zero_grad()
# Format batch
real_cpu = data[0].to(device)
b_size = real_cpu.size(0)
label = torch.full((b_size,), real_label, dtype=torch.float, device=device)
# Forward pass real batch through D
output = netD(real_cpu).view(-1)
# Calculate loss on all-real batch
errD_real = criterion(output, label)
# Calculate gradients for D in backward pass
errD_real.backward()
D_x = output.mean().item()
## Train with all-fake batch
# Generate batch of latent vectors
noise = torch.randn(b_size, nz, 1, 1, device=device)
# Generate fake image batch with G
fake = netG(noise)
label.fill_(fake_label)
# Classify all fake batch with D
output = netD(fake.detach()).view(-1)
# Calculate D's loss on the all-fake batch
errD_fake = criterion(output, label)
# Calculate the gradients for this batch, accumulated (summed) with previous gradients
errD_fake.backward()
D_G_z1 = output.mean().item()
# Compute error of D as sum over the fake and the real batches
errD = errD_real + errD_fake
# Update D
optimizerD.step()
############################
# (2) Update G network: maximize log(D(G(z)))
###########################
netG.zero_grad()
label.fill_(real_label) # fake labels are real for generator cost
# Since we just updated D, perform another forward pass of all-fake batch through D
output = netD(fake).view(-1)
# Calculate G's loss based on this output
errG = criterion(output, label)
# Calculate gradients for G
errG.backward()
D_G_z2 = output.mean().item()
# Update G
optimizerG.step()
# Output training stats
if i % 50 == 0:
print('[%d/%d][%d/%d]\tLoss_D: %.4f\tLoss_G: %.4f\tD(x): %.4f\tD(G(z)): %.4f / %.4f'
% (epoch, num_epochs, i, len(dataloader),
errD.item(), errG.item(), D_x, D_G_z1, D_G_z2))
# Save Losses for plotting later
G_losses.append(errG.item())
D_losses.append(errD.item())
# Check how the generator is doing by saving G's output on fixed_noise
if (iters % 500 == 0) or ((epoch == num_epochs-1) and (i == len(dataloader)-1)):
with torch.no_grad():
fake = netG(fixed_noise).detach().cpu()
img_list.append(vutils.make_grid(fake, padding=2, normalize=True))
iters += 1
Starting Training Loop... [0/5][0/1583] Loss_D: 1.6264 Loss_G: 5.5240 D(x): 0.5733 D(G(z)): 0.5501 / 0.0065 [0/5][50/1583] Loss_D: 0.1969 Loss_G: 9.8650 D(x): 0.9115 D(G(z)): 0.0013 / 0.0001 [0/5][100/1583] Loss_D: 0.4402 Loss_G: 10.3478 D(x): 0.8891 D(G(z)): 0.1948 / 0.0002 [0/5][150/1583] Loss_D: 0.9483 Loss_G: 1.9371 D(x): 0.5225 D(G(z)): 0.0427 / 0.1975 [0/5][200/1583] Loss_D: 0.3248 Loss_G: 3.6517 D(x): 0.9280 D(G(z)): 0.1572 / 0.0503 [0/5][250/1583] Loss_D: 0.4453 Loss_G: 4.3366 D(x): 0.8077 D(G(z)): 0.0910 / 0.0249 [0/5][300/1583] Loss_D: 0.6748 Loss_G: 8.1313 D(x): 0.9587 D(G(z)): 0.3915 / 0.0019 [0/5][350/1583] Loss_D: 1.0900 Loss_G: 8.2799 D(x): 0.9302 D(G(z)): 0.5196 / 0.0018 [0/5][400/1583] Loss_D: 0.4655 Loss_G: 3.5656 D(x): 0.7648 D(G(z)): 0.1014 / 0.0471 [0/5][450/1583] Loss_D: 0.4458 Loss_G: 4.3234 D(x): 0.7488 D(G(z)): 0.0723 / 0.0298 [0/5][500/1583] Loss_D: 0.5246 Loss_G: 4.3491 D(x): 0.7937 D(G(z)): 0.1979 / 0.0261 [0/5][550/1583] Loss_D: 0.6154 Loss_G: 3.0322 D(x): 0.6949 D(G(z)): 0.1026 / 0.0799 [0/5][600/1583] Loss_D: 0.6051 Loss_G: 6.2902 D(x): 0.9071 D(G(z)): 0.3221 / 0.0049 [0/5][650/1583] Loss_D: 0.3337 Loss_G: 4.5171 D(x): 0.8292 D(G(z)): 0.0869 / 0.0260 [0/5][700/1583] Loss_D: 0.3207 Loss_G: 4.2894 D(x): 0.9337 D(G(z)): 0.1935 / 0.0247 [0/5][750/1583] Loss_D: 0.4183 Loss_G: 3.8737 D(x): 0.7864 D(G(z)): 0.0781 / 0.0291 [0/5][800/1583] Loss_D: 0.2027 Loss_G: 5.3742 D(x): 0.8745 D(G(z)): 0.0460 / 0.0089 [0/5][850/1583] Loss_D: 0.7215 Loss_G: 3.1348 D(x): 0.6134 D(G(z)): 0.0378 / 0.0681 [0/5][900/1583] Loss_D: 0.4447 Loss_G: 2.8612 D(x): 0.8183 D(G(z)): 0.1644 / 0.0761 [0/5][950/1583] Loss_D: 0.4870 Loss_G: 5.3041 D(x): 0.8981 D(G(z)): 0.2614 / 0.0132 [0/5][1000/1583] Loss_D: 0.4619 Loss_G: 6.4841 D(x): 0.9648 D(G(z)): 0.3082 / 0.0028 [0/5][1050/1583] Loss_D: 0.5799 Loss_G: 3.1496 D(x): 0.7367 D(G(z)): 0.1217 / 0.0799 [0/5][1100/1583] Loss_D: 0.5269 Loss_G: 4.5594 D(x): 0.7200 D(G(z)): 0.0541 / 0.0354 [0/5][1150/1583] Loss_D: 0.4984 Loss_G: 4.0545 D(x): 0.7080 D(G(z)): 0.0408 / 0.0354 [0/5][1200/1583] Loss_D: 1.1084 Loss_G: 7.5179 D(x): 0.9878 D(G(z)): 0.5587 / 0.0023 [0/5][1250/1583] Loss_D: 0.4398 Loss_G: 4.2938 D(x): 0.8890 D(G(z)): 0.2389 / 0.0212 [0/5][1300/1583] Loss_D: 0.3008 Loss_G: 3.6703 D(x): 0.9442 D(G(z)): 0.1851 / 0.0449 [0/5][1350/1583] Loss_D: 0.7389 Loss_G: 6.2268 D(x): 0.8521 D(G(z)): 0.3225 / 0.0066 [0/5][1400/1583] Loss_D: 0.6734 Loss_G: 2.0107 D(x): 0.6619 D(G(z)): 0.0975 / 0.2144 [0/5][1450/1583] Loss_D: 0.2965 Loss_G: 4.4287 D(x): 0.9122 D(G(z)): 0.1595 / 0.0218 [0/5][1500/1583] Loss_D: 2.6570 Loss_G: 2.0084 D(x): 0.1475 D(G(z)): 0.0015 / 0.2269 [0/5][1550/1583] Loss_D: 0.4746 Loss_G: 3.0976 D(x): 0.8948 D(G(z)): 0.2322 / 0.0840 [1/5][0/1583] Loss_D: 0.8343 Loss_G: 6.4535 D(x): 0.9796 D(G(z)): 0.4853 / 0.0033 [1/5][50/1583] Loss_D: 0.7130 Loss_G: 1.5342 D(x): 0.6157 D(G(z)): 0.1021 / 0.2726 [1/5][100/1583] Loss_D: 0.7088 Loss_G: 2.4053 D(x): 0.5963 D(G(z)): 0.0182 / 0.1384 [1/5][150/1583] Loss_D: 0.4013 Loss_G: 4.3034 D(x): 0.8834 D(G(z)): 0.2096 / 0.0216 [1/5][200/1583] Loss_D: 1.8104 Loss_G: 10.7326 D(x): 0.9779 D(G(z)): 0.7524 / 0.0001 [1/5][250/1583] Loss_D: 0.3521 Loss_G: 3.4950 D(x): 0.7770 D(G(z)): 0.0458 / 0.0507 [1/5][300/1583] Loss_D: 1.2789 Loss_G: 9.3881 D(x): 0.9818 D(G(z)): 0.6221 / 0.0003 [1/5][350/1583] Loss_D: 0.4540 Loss_G: 4.2427 D(x): 0.8475 D(G(z)): 0.2154 / 0.0222 [1/5][400/1583] Loss_D: 1.2641 Loss_G: 6.8291 D(x): 0.9559 D(G(z)): 0.6282 / 0.0018 [1/5][450/1583] Loss_D: 0.2860 Loss_G: 3.4288 D(x): 0.8451 D(G(z)): 0.0836 / 0.0512 [1/5][500/1583] Loss_D: 0.2893 Loss_G: 4.0283 D(x): 0.8491 D(G(z)): 0.0890 / 0.0359 [1/5][550/1583] Loss_D: 1.9697 Loss_G: 4.3970 D(x): 0.9925 D(G(z)): 0.7727 / 0.0401 [1/5][600/1583] Loss_D: 0.4840 Loss_G: 3.6203 D(x): 0.6993 D(G(z)): 0.0370 / 0.0411 [1/5][650/1583] Loss_D: 1.4469 Loss_G: 8.5441 D(x): 0.9929 D(G(z)): 0.6932 / 0.0004 [1/5][700/1583] Loss_D: 0.5413 Loss_G: 4.0344 D(x): 0.8934 D(G(z)): 0.3030 / 0.0292 [1/5][750/1583] Loss_D: 1.3910 Loss_G: 1.4990 D(x): 0.3619 D(G(z)): 0.0050 / 0.3383 [1/5][800/1583] Loss_D: 0.5120 Loss_G: 4.3385 D(x): 0.7845 D(G(z)): 0.1899 / 0.0212 [1/5][850/1583] Loss_D: 0.2827 Loss_G: 3.0828 D(x): 0.8687 D(G(z)): 0.1032 / 0.0730 [1/5][900/1583] Loss_D: 0.4158 Loss_G: 3.0761 D(x): 0.8301 D(G(z)): 0.1592 / 0.0666 [1/5][950/1583] Loss_D: 0.8908 Loss_G: 5.4469 D(x): 0.8817 D(G(z)): 0.4854 / 0.0078 [1/5][1000/1583] Loss_D: 0.7732 Loss_G: 1.7362 D(x): 0.5379 D(G(z)): 0.0337 / 0.2463 [1/5][1050/1583] Loss_D: 0.5204 Loss_G: 2.5452 D(x): 0.7302 D(G(z)): 0.1080 / 0.1130 [1/5][1100/1583] Loss_D: 0.5674 Loss_G: 3.2838 D(x): 0.6438 D(G(z)): 0.0221 / 0.0687 [1/5][1150/1583] Loss_D: 0.3031 Loss_G: 2.8207 D(x): 0.8499 D(G(z)): 0.1127 / 0.0849 [1/5][1200/1583] Loss_D: 0.5268 Loss_G: 5.4339 D(x): 0.9526 D(G(z)): 0.3466 / 0.0071 [1/5][1250/1583] Loss_D: 0.9241 Loss_G: 4.5309 D(x): 0.9200 D(G(z)): 0.4887 / 0.0218 [1/5][1300/1583] Loss_D: 0.4466 Loss_G: 2.9076 D(x): 0.8265 D(G(z)): 0.1886 / 0.0784 [1/5][1350/1583] Loss_D: 1.0181 Loss_G: 1.4873 D(x): 0.4532 D(G(z)): 0.0178 / 0.2848 [1/5][1400/1583] Loss_D: 0.4303 Loss_G: 2.9303 D(x): 0.8316 D(G(z)): 0.1813 / 0.0724 [1/5][1450/1583] Loss_D: 0.4128 Loss_G: 4.3629 D(x): 0.9142 D(G(z)): 0.2513 / 0.0180 [1/5][1500/1583] Loss_D: 0.3778 Loss_G: 2.3704 D(x): 0.8516 D(G(z)): 0.1667 / 0.1350 [1/5][1550/1583] Loss_D: 0.4985 Loss_G: 2.3265 D(x): 0.7201 D(G(z)): 0.1019 / 0.1293 [2/5][0/1583] Loss_D: 0.5574 Loss_G: 3.0106 D(x): 0.7757 D(G(z)): 0.2207 / 0.0714 [2/5][50/1583] Loss_D: 1.7797 Loss_G: 5.5895 D(x): 0.9731 D(G(z)): 0.7511 / 0.0074 [2/5][100/1583] Loss_D: 0.5581 Loss_G: 4.7044 D(x): 0.9083 D(G(z)): 0.3208 / 0.0168 [2/5][150/1583] Loss_D: 0.9671 Loss_G: 4.5630 D(x): 0.9337 D(G(z)): 0.5077 / 0.0228 [2/5][200/1583] Loss_D: 0.4312 Loss_G: 1.9553 D(x): 0.7280 D(G(z)): 0.0672 / 0.1831 [2/5][250/1583] Loss_D: 0.4174 Loss_G: 3.6087 D(x): 0.9303 D(G(z)): 0.2601 / 0.0406 [2/5][300/1583] Loss_D: 1.1886 Loss_G: 5.1787 D(x): 0.9588 D(G(z)): 0.6033 / 0.0149 [2/5][350/1583] Loss_D: 0.4676 Loss_G: 1.9149 D(x): 0.7520 D(G(z)): 0.1241 / 0.1803 [2/5][400/1583] Loss_D: 0.4543 Loss_G: 2.7550 D(x): 0.7946 D(G(z)): 0.1622 / 0.0866 [2/5][450/1583] Loss_D: 0.8602 Loss_G: 4.1559 D(x): 0.9290 D(G(z)): 0.4980 / 0.0229 [2/5][500/1583] Loss_D: 0.5614 Loss_G: 3.3417 D(x): 0.8240 D(G(z)): 0.2591 / 0.0529 [2/5][550/1583] Loss_D: 0.8570 Loss_G: 1.6342 D(x): 0.5498 D(G(z)): 0.0982 / 0.2507 [2/5][600/1583] Loss_D: 0.6855 Loss_G: 1.8578 D(x): 0.6310 D(G(z)): 0.1183 / 0.2210 [2/5][650/1583] Loss_D: 0.6927 Loss_G: 0.8718 D(x): 0.5848 D(G(z)): 0.0706 / 0.4597 [2/5][700/1583] Loss_D: 0.5249 Loss_G: 2.1395 D(x): 0.7349 D(G(z)): 0.1503 / 0.1506 [2/5][750/1583] Loss_D: 1.0627 Loss_G: 3.4513 D(x): 0.8341 D(G(z)): 0.4632 / 0.0625 [2/5][800/1583] Loss_D: 0.6381 Loss_G: 2.1959 D(x): 0.6404 D(G(z)): 0.1035 / 0.1449 [2/5][850/1583] Loss_D: 0.6205 Loss_G: 1.8882 D(x): 0.6625 D(G(z)): 0.1458 / 0.2056 [2/5][900/1583] Loss_D: 0.5240 Loss_G: 3.0652 D(x): 0.8554 D(G(z)): 0.2760 / 0.0632 [2/5][950/1583] Loss_D: 0.6033 Loss_G: 2.6260 D(x): 0.7652 D(G(z)): 0.2390 / 0.0962 [2/5][1000/1583] Loss_D: 0.6342 Loss_G: 1.3933 D(x): 0.6760 D(G(z)): 0.1558 / 0.3070 [2/5][1050/1583] Loss_D: 0.6830 Loss_G: 2.1769 D(x): 0.7128 D(G(z)): 0.2426 / 0.1453 [2/5][1100/1583] Loss_D: 1.1958 Loss_G: 4.5771 D(x): 0.9402 D(G(z)): 0.6082 / 0.0175 [2/5][1150/1583] Loss_D: 0.7257 Loss_G: 2.9859 D(x): 0.8070 D(G(z)): 0.3427 / 0.0683 [2/5][1200/1583] Loss_D: 0.3839 Loss_G: 2.9582 D(x): 0.8879 D(G(z)): 0.2105 / 0.0671 [2/5][1250/1583] Loss_D: 0.5124 Loss_G: 2.3166 D(x): 0.7879 D(G(z)): 0.2069 / 0.1265 [2/5][1300/1583] Loss_D: 0.9391 Loss_G: 4.4988 D(x): 0.9246 D(G(z)): 0.5177 / 0.0171 [2/5][1350/1583] Loss_D: 0.5598 Loss_G: 2.0913 D(x): 0.7680 D(G(z)): 0.2183 / 0.1521 [2/5][1400/1583] Loss_D: 0.8174 Loss_G: 1.0646 D(x): 0.5682 D(G(z)): 0.1286 / 0.4006 [2/5][1450/1583] Loss_D: 1.2810 Loss_G: 5.6100 D(x): 0.9305 D(G(z)): 0.6372 / 0.0084 [2/5][1500/1583] Loss_D: 1.0972 Loss_G: 4.0057 D(x): 0.9477 D(G(z)): 0.6008 / 0.0294 [2/5][1550/1583] Loss_D: 0.8585 Loss_G: 3.6638 D(x): 0.9296 D(G(z)): 0.4973 / 0.0366 [3/5][0/1583] Loss_D: 0.4601 Loss_G: 2.5439 D(x): 0.7354 D(G(z)): 0.1002 / 0.1109 [3/5][50/1583] Loss_D: 0.8146 Loss_G: 1.0526 D(x): 0.5394 D(G(z)): 0.0956 / 0.3953 [3/5][100/1583] Loss_D: 0.6388 Loss_G: 3.4166 D(x): 0.8669 D(G(z)): 0.3579 / 0.0444 [3/5][150/1583] Loss_D: 0.9253 Loss_G: 4.1738 D(x): 0.8980 D(G(z)): 0.4918 / 0.0239 [3/5][200/1583] Loss_D: 0.8986 Loss_G: 1.2640 D(x): 0.5101 D(G(z)): 0.1209 / 0.3326 [3/5][250/1583] Loss_D: 0.5121 Loss_G: 2.9467 D(x): 0.7850 D(G(z)): 0.2003 / 0.0714 [3/5][300/1583] Loss_D: 0.4860 Loss_G: 1.8992 D(x): 0.8010 D(G(z)): 0.1984 / 0.1826 [3/5][350/1583] Loss_D: 0.6147 Loss_G: 2.0065 D(x): 0.7277 D(G(z)): 0.2118 / 0.1652 [3/5][400/1583] Loss_D: 0.4669 Loss_G: 2.8764 D(x): 0.8450 D(G(z)): 0.2305 / 0.0726 [3/5][450/1583] Loss_D: 1.0257 Loss_G: 3.7308 D(x): 0.8806 D(G(z)): 0.5287 / 0.0367 [3/5][500/1583] Loss_D: 0.9548 Loss_G: 1.2733 D(x): 0.4506 D(G(z)): 0.0309 / 0.3325 [3/5][550/1583] Loss_D: 0.6259 Loss_G: 1.6133 D(x): 0.7066 D(G(z)): 0.1827 / 0.2467 [3/5][600/1583] Loss_D: 1.1150 Loss_G: 4.3309 D(x): 0.7507 D(G(z)): 0.4868 / 0.0224 [3/5][650/1583] Loss_D: 0.5183 Loss_G: 2.4935 D(x): 0.7578 D(G(z)): 0.1706 / 0.1131 [3/5][700/1583] Loss_D: 0.5210 Loss_G: 3.2087 D(x): 0.8424 D(G(z)): 0.2623 / 0.0525 [3/5][750/1583] Loss_D: 0.5013 Loss_G: 2.4980 D(x): 0.7886 D(G(z)): 0.1889 / 0.1102 [3/5][800/1583] Loss_D: 0.7707 Loss_G: 1.3504 D(x): 0.5426 D(G(z)): 0.0645 / 0.3070 [3/5][850/1583] Loss_D: 0.6616 Loss_G: 3.2082 D(x): 0.8906 D(G(z)): 0.3853 / 0.0526 [3/5][900/1583] Loss_D: 0.6653 Loss_G: 1.7121 D(x): 0.5934 D(G(z)): 0.0666 / 0.2255 [3/5][950/1583] Loss_D: 0.4443 Loss_G: 2.6310 D(x): 0.7740 D(G(z)): 0.1397 / 0.0952 [3/5][1000/1583] Loss_D: 1.9384 Loss_G: 6.6349 D(x): 0.9713 D(G(z)): 0.8042 / 0.0024 [3/5][1050/1583] Loss_D: 0.7155 Loss_G: 1.1952 D(x): 0.6006 D(G(z)): 0.1279 / 0.3521 [3/5][1100/1583] Loss_D: 0.5547 Loss_G: 1.7528 D(x): 0.7036 D(G(z)): 0.1279 / 0.2104 [3/5][1150/1583] Loss_D: 0.7495 Loss_G: 1.8234 D(x): 0.5650 D(G(z)): 0.0695 / 0.2096 [3/5][1200/1583] Loss_D: 0.9382 Loss_G: 1.1311 D(x): 0.4660 D(G(z)): 0.0544 / 0.3916 [3/5][1250/1583] Loss_D: 0.9815 Loss_G: 4.3096 D(x): 0.9001 D(G(z)): 0.5338 / 0.0185 [3/5][1300/1583] Loss_D: 0.5546 Loss_G: 2.1798 D(x): 0.7168 D(G(z)): 0.1521 / 0.1436 [3/5][1350/1583] Loss_D: 0.4568 Loss_G: 1.9960 D(x): 0.7862 D(G(z)): 0.1688 / 0.1644 [3/5][1400/1583] Loss_D: 0.7990 Loss_G: 1.2198 D(x): 0.6010 D(G(z)): 0.1685 / 0.3419 [3/5][1450/1583] Loss_D: 0.8600 Loss_G: 1.3928 D(x): 0.5436 D(G(z)): 0.0814 / 0.3018 [3/5][1500/1583] Loss_D: 0.6615 Loss_G: 3.1099 D(x): 0.8173 D(G(z)): 0.3315 / 0.0597 [3/5][1550/1583] Loss_D: 0.5849 Loss_G: 2.0715 D(x): 0.7577 D(G(z)): 0.2321 / 0.1538 [4/5][0/1583] Loss_D: 0.4824 Loss_G: 2.3323 D(x): 0.7607 D(G(z)): 0.1478 / 0.1235 [4/5][50/1583] Loss_D: 0.7867 Loss_G: 1.6463 D(x): 0.5697 D(G(z)): 0.1301 / 0.2575 [4/5][100/1583] Loss_D: 1.0994 Loss_G: 0.6561 D(x): 0.4191 D(G(z)): 0.0606 / 0.5827 [4/5][150/1583] Loss_D: 0.5518 Loss_G: 2.3903 D(x): 0.7925 D(G(z)): 0.2368 / 0.1089 [4/5][200/1583] Loss_D: 0.8786 Loss_G: 1.0323 D(x): 0.5288 D(G(z)): 0.1131 / 0.4051 [4/5][250/1583] Loss_D: 0.5423 Loss_G: 2.1004 D(x): 0.7568 D(G(z)): 0.1902 / 0.1623 [4/5][300/1583] Loss_D: 0.8884 Loss_G: 2.6847 D(x): 0.7599 D(G(z)): 0.3955 / 0.0914 [4/5][350/1583] Loss_D: 0.5422 Loss_G: 2.2859 D(x): 0.7184 D(G(z)): 0.1490 / 0.1301 [4/5][400/1583] Loss_D: 0.5024 Loss_G: 2.8434 D(x): 0.8325 D(G(z)): 0.2445 / 0.0758 [4/5][450/1583] Loss_D: 0.4153 Loss_G: 2.5243 D(x): 0.8481 D(G(z)): 0.1955 / 0.1054 [4/5][500/1583] Loss_D: 0.7905 Loss_G: 1.2818 D(x): 0.5281 D(G(z)): 0.0496 / 0.3474 [4/5][550/1583] Loss_D: 1.4365 Loss_G: 5.8192 D(x): 0.9547 D(G(z)): 0.6836 / 0.0050 [4/5][600/1583] Loss_D: 0.5373 Loss_G: 2.4633 D(x): 0.7952 D(G(z)): 0.2310 / 0.1058 [4/5][650/1583] Loss_D: 0.4865 Loss_G: 1.7770 D(x): 0.7445 D(G(z)): 0.1354 / 0.2078 [4/5][700/1583] Loss_D: 1.6425 Loss_G: 3.9188 D(x): 0.8259 D(G(z)): 0.7045 / 0.0352 [4/5][750/1583] Loss_D: 0.5953 Loss_G: 2.0157 D(x): 0.7091 D(G(z)): 0.1762 / 0.1728 [4/5][800/1583] Loss_D: 0.4252 Loss_G: 3.0718 D(x): 0.9007 D(G(z)): 0.2481 / 0.0576 [4/5][850/1583] Loss_D: 0.6085 Loss_G: 3.1218 D(x): 0.8299 D(G(z)): 0.2978 / 0.0580 [4/5][900/1583] Loss_D: 0.5573 Loss_G: 3.6405 D(x): 0.8936 D(G(z)): 0.3319 / 0.0345 [4/5][950/1583] Loss_D: 0.4922 Loss_G: 2.5892 D(x): 0.7996 D(G(z)): 0.2059 / 0.0942 [4/5][1000/1583] Loss_D: 1.0065 Loss_G: 3.1784 D(x): 0.8774 D(G(z)): 0.5317 / 0.0659 [4/5][1050/1583] Loss_D: 0.5327 Loss_G: 2.7912 D(x): 0.8278 D(G(z)): 0.2576 / 0.0797 [4/5][1100/1583] Loss_D: 0.6789 Loss_G: 3.7784 D(x): 0.9254 D(G(z)): 0.4058 / 0.0371 [4/5][1150/1583] Loss_D: 0.6457 Loss_G: 2.6761 D(x): 0.7905 D(G(z)): 0.2998 / 0.0881 [4/5][1200/1583] Loss_D: 1.2529 Loss_G: 1.2431 D(x): 0.3732 D(G(z)): 0.0263 / 0.3504 [4/5][1250/1583] Loss_D: 0.5481 Loss_G: 1.8862 D(x): 0.6741 D(G(z)): 0.0965 / 0.1921 [4/5][1300/1583] Loss_D: 2.7151 Loss_G: 5.1481 D(x): 0.9750 D(G(z)): 0.8919 / 0.0104 [4/5][1350/1583] Loss_D: 0.8860 Loss_G: 4.4477 D(x): 0.9027 D(G(z)): 0.4881 / 0.0169 [4/5][1400/1583] Loss_D: 0.7343 Loss_G: 3.9222 D(x): 0.9005 D(G(z)): 0.4267 / 0.0283 [4/5][1450/1583] Loss_D: 0.5581 Loss_G: 2.9027 D(x): 0.8745 D(G(z)): 0.3094 / 0.0765 [4/5][1500/1583] Loss_D: 0.6991 Loss_G: 2.8595 D(x): 0.7452 D(G(z)): 0.2859 / 0.0765 [4/5][1550/1583] Loss_D: 0.5642 Loss_G: 1.9129 D(x): 0.6953 D(G(z)): 0.1427 / 0.1844
結果
最後に、私達がどのように行なったかを確認しましょう。ここでは、3 つの異なる結果を見ます。最初に、D と G の損失が訓練の間にどのように変わったかを見ます。2 番目に、総てのエポックについて fixed_noise バッチ上の G の出力を可視化します。そして 3 番目に、G からの fake データのバッチの次に real データのバッチを見ます。
損失 versus 訓練反復
下は D & G の損失 vs 訓練反復のプロットです。
plt.figure(figsize=(10,5))
plt.title("Generator and Discriminator Loss During Training")
plt.plot(G_losses,label="G")
plt.plot(D_losses,label="D")
plt.xlabel("iterations")
plt.ylabel("Loss")
plt.legend()
plt.show()
G の進捗の可視化
訓練の総てのエポック後に fixed_noise バッチ上の generator の出力をどのようにセーブしたかを思い出してください。今、G の訓練進捗をアニメーションで可視化できます。アニメーションを開始するには play ボタンを押してください。
#%%capture
fig = plt.figure(figsize=(8,8))
plt.axis("off")
ims = [[plt.imshow(np.transpose(i,(1,2,0)), animated=True)] for i in img_list]
ani = animation.ArtistAnimation(fig, ims, interval=1000, repeat_delay=1000, blit=True)
HTML(ani.to_jshtml())
Real 画像 vs. Fake 画像
最後に、幾つかの real 画像と fake 画像を並べて見てみましょう。
# Grab a batch of real images from the dataloader
real_batch = next(iter(dataloader))
# Plot the real images
plt.figure(figsize=(15,15))
plt.subplot(1,2,1)
plt.axis("off")
plt.title("Real Images")
plt.imshow(np.transpose(vutils.make_grid(real_batch[0].to(device)[:64], padding=5, normalize=True).cpu(),(1,2,0)))
# Plot the fake images from the last epoch
plt.subplot(1,2,2)
plt.axis("off")
plt.title("Fake Images")
plt.imshow(np.transpose(img_list[-1],(1,2,0)))
plt.show()
plt.show()
WHERE TO GO NEXT
旅の最後に到達しましたが、ここから行ける幾つかの場所があります。貴方は以下ができるでしょう :
- より長く訓練して結果がどのように良くなるかを見ます。
- 異なるデータセットを取るためにモデルを変更します、多分画像のサイズとモデル・アーキテクチャを変更します。
- ここ で幾つかの他のクールな GAN プロジェクトを調べます。
- 音楽 を生成する GAN を作成します。
以上