PyTorch 1.3 Tutorials : 画像 : DCGAN チュートリアル (翻訳/解説)
翻訳 : (株)クラスキャット セールスインフォメーション
作成日時 : 12/22/2019 (1.3.1)
* 本ページは、PyTorch 1.3 Tutorials の以下のページを翻訳した上で適宜、補足説明したものです：
- Image : DCGAN Tutorial
* サンプルコードの動作確認はしておりますが、必要な場合には適宜、追加改変しています。
* ご自由にリンクを張って頂いてかまいませんが、sales-info@classcat.com までご一報いただけると嬉しいです。
画像 : DCGAN チュートリアル
イントロダクション
このチュートリアルはサンプルを通して DCGAN へのイントロダクションを与えます。多くの実際のセレブ (= celebrities, 有名人) の写真を見せた後で新しいセレブを生成するために敵対的生成ネットワーク (GAN, Generative Adversarial Network) を訓練します。ここでのコードの殆どは pytorch/examples の dcgan 実装からのもので、このドキュメントは実装の徹底的な説明を与えてそしてこのモデルがどのようにそして何故動作するのかを明らかにします。しかし心配しないでください、GAN の事前知識は必要ありません、しかし内部で実際に何が起きているかについて納得するために初心者はある程度の時間を費やす必要があるかもしれません。また、時間のためには一つ、または 2 つの GPU を持つことが役立つでしょう。最初から始めましょう。
敵対的生成ネットワーク
What is a GAN?
GAN は訓練データの分布を捕捉することを DL モデルに教えるためのフレームワークですのでその同じ分布から新しいデータを生成できます。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)\) への入力は HWC サイズ 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\) はそれが reals と fakes を正しく分類する確率 (\(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
入力
実行のための幾つかの入力を定義しましょう :
- 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 hyperparam 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
...
これは重要なステップです、何故ならば dataset の root フォルダにサブディレクトリがあることを必要とする ImageFolder dataset クラスを使用していくからです。今は、dataset を作成して、dataloader を作成して、その上で動作する device を設定してそして最後に訓練データの幾つかを可視化します。
# 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.2.
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 ペーパーは downsample に 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
# 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 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 mini-batch 提案によって、これを 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 – Train the Generator
元のペーパーで述べられているように、より良い fake を生成する努力において \(log(1-D(G(z)))\) を最小化することにより Generator を訓練することを望みます。言及したように、特に学習過程の早期では、これは十分な勾配を提供しないことが Goodfellow により示されました。その処置として、代わりに \(log(D(G(z)))\) を最大化することを望みます。コードではこれを次により達成します : Generator 出力を Part 1 から Discriminator で分類し、real ラベルを GT として使用して G の損失を計算し、backward パスで G の勾配を計算し、そして最後に optimizer ステップで G のパラメータを更新します。損失関数のために real ラベルを GT ラベルとして使用することは直感に反するかもしれませんが、これは BCELoss の (\(log(1-x)\) 部ではなく) \(log(x)\) 部を使用することを可能にし、これは正確に私達が望むものです。
最後に、幾つかの統計的レポーティングを行ないそして各エポックの最後に fixed_noise バッチを generator を通してプッシュして G の訓練の進捗を視覚的に追跡します。レポートされる訓練統計情報は :
- Loss_D – 総ての real と総ての fake バッチのための損失 \(log(D(x)) + log(D(G(z)))\)) の総計として計算された discriminator 損失。
- 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, 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
errD_fake.backward()
D_G_z1 = output.mean().item()
# Add the gradients from the all-real and all-fake 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: 2.0937 Loss_G: 5.2060 D(x): 0.5704 D(G(z)): 0.6680 / 0.0090 [0/5][50/1583] Loss_D: 0.2354 Loss_G: 14.5896 D(x): 0.9323 D(G(z)): 0.0000 / 0.0000 [0/5][100/1583] Loss_D: 1.8191 Loss_G: 18.0605 D(x): 0.9343 D(G(z)): 0.6186 / 0.0000 [0/5][150/1583] Loss_D: 1.3428 Loss_G: 9.5927 D(x): 0.9828 D(G(z)): 0.5906 / 0.0020 [0/5][200/1583] Loss_D: 0.4572 Loss_G: 4.3128 D(x): 0.9151 D(G(z)): 0.2590 / 0.0224 [0/5][250/1583] Loss_D: 1.4513 Loss_G: 10.0713 D(x): 0.8617 D(G(z)): 0.6177 / 0.0002 [0/5][300/1583] Loss_D: 1.7934 Loss_G: 10.0471 D(x): 0.9531 D(G(z)): 0.7406 / 0.0002 [0/5][350/1583] Loss_D: 0.9802 Loss_G: 2.9845 D(x): 0.4883 D(G(z)): 0.0130 / 0.0928 [0/5][400/1583] Loss_D: 0.4849 Loss_G: 3.1132 D(x): 0.7723 D(G(z)): 0.1224 / 0.0714 [0/5][450/1583] Loss_D: 0.4086 Loss_G: 5.6327 D(x): 0.7410 D(G(z)): 0.0240 / 0.0137 [0/5][500/1583] Loss_D: 0.3217 Loss_G: 4.3753 D(x): 0.9322 D(G(z)): 0.1937 / 0.0243 [0/5][550/1583] Loss_D: 0.4119 Loss_G: 4.0526 D(x): 0.8541 D(G(z)): 0.1915 / 0.0298 [0/5][600/1583] Loss_D: 0.4154 Loss_G: 4.1986 D(x): 0.8630 D(G(z)): 0.1609 / 0.0292 [0/5][650/1583] Loss_D: 0.6230 Loss_G: 5.6996 D(x): 0.6562 D(G(z)): 0.0116 / 0.0135 [0/5][700/1583] Loss_D: 0.3782 Loss_G: 3.5999 D(x): 0.8321 D(G(z)): 0.1235 / 0.0469 [0/5][750/1583] Loss_D: 0.5535 Loss_G: 2.5096 D(x): 0.6964 D(G(z)): 0.0727 / 0.1307 [0/5][800/1583] Loss_D: 0.3907 Loss_G: 4.5112 D(x): 0.7663 D(G(z)): 0.0604 / 0.0226 [0/5][850/1583] Loss_D: 0.5964 Loss_G: 5.4312 D(x): 0.8840 D(G(z)): 0.2853 / 0.0084 [0/5][900/1583] Loss_D: 0.3589 Loss_G: 4.4249 D(x): 0.8981 D(G(z)): 0.1896 / 0.0199 [0/5][950/1583] Loss_D: 0.6686 Loss_G: 5.3526 D(x): 0.9540 D(G(z)): 0.3742 / 0.0144 [0/5][1000/1583] Loss_D: 0.4968 Loss_G: 3.0280 D(x): 0.7987 D(G(z)): 0.1577 / 0.0903 [0/5][1050/1583] Loss_D: 0.9055 Loss_G: 5.7235 D(x): 0.9254 D(G(z)): 0.4765 / 0.0064 [0/5][1100/1583] Loss_D: 0.2477 Loss_G: 5.0886 D(x): 0.9181 D(G(z)): 0.1287 / 0.0120 [0/5][1150/1583] Loss_D: 0.4230 Loss_G: 3.5775 D(x): 0.8876 D(G(z)): 0.2131 / 0.0510 [0/5][1200/1583] Loss_D: 0.3951 Loss_G: 4.3565 D(x): 0.7997 D(G(z)): 0.1002 / 0.0275 [0/5][1250/1583] Loss_D: 0.5375 Loss_G: 4.4067 D(x): 0.8427 D(G(z)): 0.2572 / 0.0218 [0/5][1300/1583] Loss_D: 0.3981 Loss_G: 4.1545 D(x): 0.8432 D(G(z)): 0.1521 / 0.0257 [0/5][1350/1583] Loss_D: 0.9673 Loss_G: 2.4628 D(x): 0.5382 D(G(z)): 0.0452 / 0.1272 [0/5][1400/1583] Loss_D: 0.6837 Loss_G: 5.6366 D(x): 0.8545 D(G(z)): 0.3344 / 0.0117 [0/5][1450/1583] Loss_D: 0.8938 Loss_G: 5.6230 D(x): 0.8946 D(G(z)): 0.4444 / 0.0081 [0/5][1500/1583] Loss_D: 0.6565 Loss_G: 2.3245 D(x): 0.6297 D(G(z)): 0.0706 / 0.1559 [0/5][1550/1583] Loss_D: 0.8281 Loss_G: 6.0213 D(x): 0.8985 D(G(z)): 0.4553 / 0.0043 [1/5][0/1583] Loss_D: 0.3126 Loss_G: 3.5134 D(x): 0.8087 D(G(z)): 0.0613 / 0.0462 [1/5][50/1583] Loss_D: 0.4575 Loss_G: 4.7494 D(x): 0.9040 D(G(z)): 0.2606 / 0.0131 [1/5][100/1583] Loss_D: 0.6980 Loss_G: 2.4066 D(x): 0.6091 D(G(z)): 0.0558 / 0.1495 [1/5][150/1583] Loss_D: 0.3491 Loss_G: 3.9820 D(x): 0.8252 D(G(z)): 0.1032 / 0.0362 [1/5][200/1583] Loss_D: 0.8087 Loss_G: 2.3740 D(x): 0.5648 D(G(z)): 0.0218 / 0.1659 [1/5][250/1583] Loss_D: 0.6769 Loss_G: 2.6550 D(x): 0.6207 D(G(z)): 0.0265 / 0.1209 [1/5][300/1583] Loss_D: 3.0723 Loss_G: 1.1208 D(x): 0.1797 D(G(z)): 0.0367 / 0.4424 [1/5][350/1583] Loss_D: 0.7301 Loss_G: 2.7347 D(x): 0.5738 D(G(z)): 0.0226 / 0.0987 [1/5][400/1583] Loss_D: 1.1944 Loss_G: 1.8970 D(x): 0.4030 D(G(z)): 0.0186 / 0.2156 [1/5][450/1583] Loss_D: 0.5793 Loss_G: 4.5173 D(x): 0.8761 D(G(z)): 0.3047 / 0.0184 [1/5][500/1583] Loss_D: 0.4559 Loss_G: 4.6038 D(x): 0.8815 D(G(z)): 0.2425 / 0.0185 [1/5][550/1583] Loss_D: 0.6944 Loss_G: 4.8243 D(x): 0.9070 D(G(z)): 0.3913 / 0.0150 [1/5][600/1583] Loss_D: 0.4766 Loss_G: 3.5824 D(x): 0.8195 D(G(z)): 0.1942 / 0.0442 [1/5][650/1583] Loss_D: 0.4396 Loss_G: 3.3372 D(x): 0.8895 D(G(z)): 0.2390 / 0.0552 [1/5][700/1583] Loss_D: 0.4490 Loss_G: 3.5254 D(x): 0.8854 D(G(z)): 0.2430 / 0.0437 [1/5][750/1583] Loss_D: 0.7003 Loss_G: 2.4072 D(x): 0.5762 D(G(z)): 0.0445 / 0.1356 [1/5][800/1583] Loss_D: 0.4952 Loss_G: 3.2122 D(x): 0.7922 D(G(z)): 0.1747 / 0.0585 [1/5][850/1583] Loss_D: 0.5458 Loss_G: 3.4824 D(x): 0.8020 D(G(z)): 0.2221 / 0.0456 [1/5][900/1583] Loss_D: 0.4297 Loss_G: 3.3468 D(x): 0.8568 D(G(z)): 0.2102 / 0.0470 [1/5][950/1583] Loss_D: 1.1169 Loss_G: 1.5015 D(x): 0.4160 D(G(z)): 0.0413 / 0.2887 [1/5][1000/1583] Loss_D: 0.6558 Loss_G: 4.8765 D(x): 0.9525 D(G(z)): 0.4056 / 0.0137 [1/5][1050/1583] Loss_D: 0.5970 Loss_G: 2.8602 D(x): 0.8946 D(G(z)): 0.3159 / 0.0937 [1/5][1100/1583] Loss_D: 0.7941 Loss_G: 5.0715 D(x): 0.9427 D(G(z)): 0.4648 / 0.0124 [1/5][1150/1583] Loss_D: 0.5568 Loss_G: 2.0294 D(x): 0.6940 D(G(z)): 0.1041 / 0.1856 [1/5][1200/1583] Loss_D: 0.5617 Loss_G: 4.5271 D(x): 0.9375 D(G(z)): 0.3562 / 0.0159 [1/5][1250/1583] Loss_D: 0.6380 Loss_G: 2.6142 D(x): 0.8486 D(G(z)): 0.3148 / 0.1122 [1/5][1300/1583] Loss_D: 0.6157 Loss_G: 4.9418 D(x): 0.9364 D(G(z)): 0.3697 / 0.0146 [1/5][1350/1583] Loss_D: 0.6800 Loss_G: 1.6630 D(x): 0.5854 D(G(z)): 0.0524 / 0.2535 [1/5][1400/1583] Loss_D: 0.9312 Loss_G: 4.7317 D(x): 0.9282 D(G(z)): 0.5216 / 0.0144 [1/5][1450/1583] Loss_D: 0.6988 Loss_G: 3.6276 D(x): 0.8831 D(G(z)): 0.3855 / 0.0432 [1/5][1500/1583] Loss_D: 1.1725 Loss_G: 0.9674 D(x): 0.4032 D(G(z)): 0.0305 / 0.4521 [1/5][1550/1583] Loss_D: 0.6974 Loss_G: 4.2804 D(x): 0.8887 D(G(z)): 0.3916 / 0.0219 [2/5][0/1583] Loss_D: 0.8091 Loss_G: 2.0601 D(x): 0.5430 D(G(z)): 0.0378 / 0.1834 [2/5][50/1583] Loss_D: 0.4511 Loss_G: 2.3602 D(x): 0.7356 D(G(z)): 0.0956 / 0.1315 [2/5][100/1583] Loss_D: 2.8442 Loss_G: 4.6620 D(x): 0.9755 D(G(z)): 0.8786 / 0.0205 [2/5][150/1583] Loss_D: 0.5599 Loss_G: 2.1050 D(x): 0.7452 D(G(z)): 0.1773 / 0.1664 [2/5][200/1583] Loss_D: 0.7485 Loss_G: 1.5302 D(x): 0.6386 D(G(z)): 0.1735 / 0.2698 [2/5][250/1583] Loss_D: 0.7308 Loss_G: 2.4993 D(x): 0.7179 D(G(z)): 0.2596 / 0.1161 [2/5][300/1583] Loss_D: 0.5455 Loss_G: 2.7594 D(x): 0.7865 D(G(z)): 0.2174 / 0.0886 [2/5][350/1583] Loss_D: 0.4002 Loss_G: 2.5151 D(x): 0.8065 D(G(z)): 0.1471 / 0.1050 [2/5][400/1583] Loss_D: 0.5015 Loss_G: 3.3958 D(x): 0.8606 D(G(z)): 0.2649 / 0.0475 [2/5][450/1583] Loss_D: 0.5678 Loss_G: 2.6088 D(x): 0.7606 D(G(z)): 0.2123 / 0.0978 [2/5][500/1583] Loss_D: 0.5162 Loss_G: 2.2502 D(x): 0.7542 D(G(z)): 0.1658 / 0.1428 [2/5][550/1583] Loss_D: 0.7837 Loss_G: 3.7200 D(x): 0.8815 D(G(z)): 0.4198 / 0.0358 [2/5][600/1583] Loss_D: 0.6850 Loss_G: 1.4868 D(x): 0.6280 D(G(z)): 0.1376 / 0.2728 [2/5][650/1583] Loss_D: 0.6296 Loss_G: 2.1056 D(x): 0.7699 D(G(z)): 0.2622 / 0.1582 [2/5][700/1583] Loss_D: 0.6244 Loss_G: 1.8466 D(x): 0.6775 D(G(z)): 0.1515 / 0.1999 [2/5][750/1583] Loss_D: 0.5693 Loss_G: 3.0242 D(x): 0.7820 D(G(z)): 0.2296 / 0.0712 [2/5][800/1583] Loss_D: 0.8450 Loss_G: 3.8774 D(x): 0.9296 D(G(z)): 0.4919 / 0.0302 [2/5][850/1583] Loss_D: 0.5877 Loss_G: 1.9120 D(x): 0.7164 D(G(z)): 0.1837 / 0.1772 [2/5][900/1583] Loss_D: 0.6372 Loss_G: 1.7066 D(x): 0.6646 D(G(z)): 0.1355 / 0.2288 [2/5][950/1583] Loss_D: 0.6526 Loss_G: 2.0999 D(x): 0.7736 D(G(z)): 0.2731 / 0.1605 [2/5][1000/1583] Loss_D: 0.8344 Loss_G: 1.2288 D(x): 0.5941 D(G(z)): 0.2026 / 0.3364 [2/5][1050/1583] Loss_D: 0.5371 Loss_G: 2.6055 D(x): 0.7967 D(G(z)): 0.2368 / 0.0941 [2/5][1100/1583] Loss_D: 0.6541 Loss_G: 1.6661 D(x): 0.6423 D(G(z)): 0.1373 / 0.2283 [2/5][1150/1583] Loss_D: 0.7632 Loss_G: 3.4498 D(x): 0.9164 D(G(z)): 0.4492 / 0.0429 [2/5][1200/1583] Loss_D: 0.6147 Loss_G: 3.2717 D(x): 0.8850 D(G(z)): 0.3405 / 0.0505 [2/5][1250/1583] Loss_D: 0.6998 Loss_G: 2.0594 D(x): 0.6001 D(G(z)): 0.1021 / 0.1716 [2/5][1300/1583] Loss_D: 0.5124 Loss_G: 2.6231 D(x): 0.7736 D(G(z)): 0.1888 / 0.0944 [2/5][1350/1583] Loss_D: 0.7433 Loss_G: 1.8323 D(x): 0.6162 D(G(z)): 0.1547 / 0.2066 [2/5][1400/1583] Loss_D: 0.4914 Loss_G: 2.0841 D(x): 0.7500 D(G(z)): 0.1549 / 0.1558 [2/5][1450/1583] Loss_D: 0.7303 Loss_G: 3.5863 D(x): 0.9051 D(G(z)): 0.4177 / 0.0397 [2/5][1500/1583] Loss_D: 1.2392 Loss_G: 4.6925 D(x): 0.9487 D(G(z)): 0.6337 / 0.0149 [2/5][1550/1583] Loss_D: 0.6491 Loss_G: 3.4345 D(x): 0.8959 D(G(z)): 0.3811 / 0.0454 [3/5][0/1583] Loss_D: 0.7433 Loss_G: 1.5907 D(x): 0.5568 D(G(z)): 0.0811 / 0.2453 [3/5][50/1583] Loss_D: 1.8890 Loss_G: 0.8050 D(x): 0.2343 D(G(z)): 0.0523 / 0.5037 [3/5][100/1583] Loss_D: 0.6695 Loss_G: 1.5920 D(x): 0.6385 D(G(z)): 0.1496 / 0.2467 [3/5][150/1583] Loss_D: 0.8294 Loss_G: 3.7907 D(x): 0.9305 D(G(z)): 0.4797 / 0.0355 [3/5][200/1583] Loss_D: 0.6320 Loss_G: 3.2441 D(x): 0.8732 D(G(z)): 0.3522 / 0.0547 [3/5][250/1583] Loss_D: 1.5620 Loss_G: 5.0330 D(x): 0.9584 D(G(z)): 0.7204 / 0.0115 [3/5][300/1583] Loss_D: 0.5205 Loss_G: 2.1821 D(x): 0.7564 D(G(z)): 0.1775 / 0.1430 [3/5][350/1583] Loss_D: 0.6827 Loss_G: 4.0806 D(x): 0.9204 D(G(z)): 0.4066 / 0.0241 [3/5][400/1583] Loss_D: 0.6535 Loss_G: 3.2540 D(x): 0.8737 D(G(z)): 0.3602 / 0.0512 [3/5][450/1583] Loss_D: 0.4179 Loss_G: 2.0370 D(x): 0.7987 D(G(z)): 0.1532 / 0.1610 [3/5][500/1583] Loss_D: 0.7876 Loss_G: 1.6710 D(x): 0.6140 D(G(z)): 0.1777 / 0.2341 [3/5][550/1583] Loss_D: 0.6537 Loss_G: 2.8446 D(x): 0.8373 D(G(z)): 0.3403 / 0.0762 [3/5][600/1583] Loss_D: 0.5744 Loss_G: 2.5059 D(x): 0.6871 D(G(z)): 0.1296 / 0.1190 [3/5][650/1583] Loss_D: 0.5313 Loss_G: 2.3542 D(x): 0.8353 D(G(z)): 0.2652 / 0.1156 [3/5][700/1583] Loss_D: 0.5709 Loss_G: 2.0624 D(x): 0.7650 D(G(z)): 0.2218 / 0.1624 [3/5][750/1583] Loss_D: 0.6957 Loss_G: 2.8644 D(x): 0.8324 D(G(z)): 0.3469 / 0.0788 [3/5][800/1583] Loss_D: 0.5983 Loss_G: 2.3385 D(x): 0.8083 D(G(z)): 0.2870 / 0.1236 [3/5][850/1583] Loss_D: 0.5205 Loss_G: 2.2259 D(x): 0.8009 D(G(z)): 0.2249 / 0.1398 [3/5][900/1583] Loss_D: 0.5135 Loss_G: 2.9768 D(x): 0.8194 D(G(z)): 0.2422 / 0.0701 [3/5][950/1583] Loss_D: 0.5417 Loss_G: 2.9293 D(x): 0.8516 D(G(z)): 0.2890 / 0.0685 [3/5][1000/1583] Loss_D: 0.4449 Loss_G: 2.5006 D(x): 0.7890 D(G(z)): 0.1663 / 0.1028 [3/5][1050/1583] Loss_D: 0.4891 Loss_G: 1.7220 D(x): 0.7058 D(G(z)): 0.1007 / 0.2077 [3/5][1100/1583] Loss_D: 0.5222 Loss_G: 3.1828 D(x): 0.8480 D(G(z)): 0.2728 / 0.0525 [3/5][1150/1583] Loss_D: 0.4837 Loss_G: 2.8659 D(x): 0.8490 D(G(z)): 0.2460 / 0.0721 [3/5][1200/1583] Loss_D: 0.5912 Loss_G: 2.1422 D(x): 0.6806 D(G(z)): 0.1369 / 0.1493 [3/5][1250/1583] Loss_D: 0.8777 Loss_G: 2.7854 D(x): 0.7612 D(G(z)): 0.3911 / 0.0847 [3/5][1300/1583] Loss_D: 0.6691 Loss_G: 1.7333 D(x): 0.6139 D(G(z)): 0.0970 / 0.2232 [3/5][1350/1583] Loss_D: 0.6033 Loss_G: 2.0192 D(x): 0.6706 D(G(z)): 0.1264 / 0.1795 [3/5][1400/1583] Loss_D: 0.7672 Loss_G: 2.5061 D(x): 0.7388 D(G(z)): 0.3203 / 0.1057 [3/5][1450/1583] Loss_D: 0.5788 Loss_G: 3.2566 D(x): 0.8589 D(G(z)): 0.3162 / 0.0500 [3/5][1500/1583] Loss_D: 0.8857 Loss_G: 3.9600 D(x): 0.9182 D(G(z)): 0.5013 / 0.0279 [3/5][1550/1583] Loss_D: 0.4799 Loss_G: 2.1384 D(x): 0.7508 D(G(z)): 0.1419 / 0.1541 [4/5][0/1583] Loss_D: 1.4799 Loss_G: 1.1195 D(x): 0.3357 D(G(z)): 0.0838 / 0.4090 [4/5][50/1583] Loss_D: 0.5256 Loss_G: 1.8619 D(x): 0.7177 D(G(z)): 0.1367 / 0.1897 [4/5][100/1583] Loss_D: 1.0309 Loss_G: 4.0866 D(x): 0.9360 D(G(z)): 0.5563 / 0.0302 [4/5][150/1583] Loss_D: 0.5262 Loss_G: 3.3164 D(x): 0.8651 D(G(z)): 0.2908 / 0.0443 [4/5][200/1583] Loss_D: 0.5910 Loss_G: 1.8559 D(x): 0.6458 D(G(z)): 0.0802 / 0.1947 [4/5][250/1583] Loss_D: 0.5472 Loss_G: 2.8041 D(x): 0.7437 D(G(z)): 0.1804 / 0.0851 [4/5][300/1583] Loss_D: 0.8766 Loss_G: 3.1494 D(x): 0.8522 D(G(z)): 0.4607 / 0.0587 [4/5][350/1583] Loss_D: 0.5264 Loss_G: 2.2852 D(x): 0.7324 D(G(z)): 0.1651 / 0.1214 [4/5][400/1583] Loss_D: 0.7840 Loss_G: 1.4403 D(x): 0.5852 D(G(z)): 0.1404 / 0.2811 [4/5][450/1583] Loss_D: 0.6027 Loss_G: 2.4301 D(x): 0.8683 D(G(z)): 0.3324 / 0.1111 [4/5][500/1583] Loss_D: 0.6525 Loss_G: 1.6745 D(x): 0.6228 D(G(z)): 0.1124 / 0.2321 [4/5][550/1583] Loss_D: 0.3903 Loss_G: 3.1467 D(x): 0.8689 D(G(z)): 0.2011 / 0.0516 [4/5][600/1583] Loss_D: 0.6257 Loss_G: 1.8621 D(x): 0.6275 D(G(z)): 0.0836 / 0.1940 [4/5][650/1583] Loss_D: 0.5174 Loss_G: 2.2434 D(x): 0.7331 D(G(z)): 0.1478 / 0.1396 [4/5][700/1583] Loss_D: 0.8262 Loss_G: 3.6738 D(x): 0.8147 D(G(z)): 0.4132 / 0.0349 [4/5][750/1583] Loss_D: 0.5404 Loss_G: 2.1598 D(x): 0.7543 D(G(z)): 0.1930 / 0.1474 [4/5][800/1583] Loss_D: 1.0577 Loss_G: 0.5657 D(x): 0.4328 D(G(z)): 0.0613 / 0.6088 [4/5][850/1583] Loss_D: 1.4951 Loss_G: 1.2297 D(x): 0.3023 D(G(z)): 0.0303 / 0.3783 [4/5][900/1583] Loss_D: 0.7233 Loss_G: 1.2134 D(x): 0.6103 D(G(z)): 0.1359 / 0.3469 [4/5][950/1583] Loss_D: 0.5529 Loss_G: 2.5464 D(x): 0.8071 D(G(z)): 0.2530 / 0.0972 [4/5][1000/1583] Loss_D: 0.5882 Loss_G: 2.5450 D(x): 0.7301 D(G(z)): 0.1917 / 0.1005 [4/5][1050/1583] Loss_D: 0.8863 Loss_G: 1.2206 D(x): 0.4934 D(G(z)): 0.0770 / 0.3528 [4/5][1100/1583] Loss_D: 0.5955 Loss_G: 3.3918 D(x): 0.8244 D(G(z)): 0.2960 / 0.0425 [4/5][1150/1583] Loss_D: 0.5016 Loss_G: 3.1146 D(x): 0.8369 D(G(z)): 0.2414 / 0.0600 [4/5][1200/1583] Loss_D: 0.5562 Loss_G: 3.1194 D(x): 0.8985 D(G(z)): 0.3302 / 0.0587 [4/5][1250/1583] Loss_D: 0.6959 Loss_G: 1.8193 D(x): 0.6099 D(G(z)): 0.1107 / 0.2036 [4/5][1300/1583] Loss_D: 0.5311 Loss_G: 2.6403 D(x): 0.7856 D(G(z)): 0.2244 / 0.0920 [4/5][1350/1583] Loss_D: 1.6290 Loss_G: 0.4868 D(x): 0.2789 D(G(z)): 0.0414 / 0.6550 [4/5][1400/1583] Loss_D: 0.6422 Loss_G: 4.0195 D(x): 0.9302 D(G(z)): 0.3892 / 0.0247 [4/5][1450/1583] Loss_D: 0.4471 Loss_G: 2.8860 D(x): 0.8546 D(G(z)): 0.2262 / 0.0696 [4/5][1500/1583] Loss_D: 0.6857 Loss_G: 1.2551 D(x): 0.5596 D(G(z)): 0.0405 / 0.3335 [4/5][1550/1583] Loss_D: 0.6666 Loss_G: 4.1584 D(x): 0.9209 D(G(z)): 0.4105 / 0.0226
結果
最後に、私達がどのように行なったかを調べましょう。ここでは、3 つの異なる結果を見ます。最初に、D と G の損失が訓練の間にどのように変わったかを見ます。2 番目に、総てのエポックについて fixed_noise バッチ上の G の出力を可視化します。そして 3 番目に、G からの fake データのバッチの次に real データのバッチを見ます。
損失 versus 訓練反復
下は D & G の損失 versus 訓練反復のプロットです。
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()
WHERE TO GO NEXT
旅の最後に到達しましたが、ここから行ける幾つかの場所があります。貴方は以下ができるでしょう :
- より長く訓練して結果がどのように良くなるかを見ます。
- 異なるデータセットを取るためにモデルを変更します、多分画像のサイズとモデル・アーキテクチャを変更します。
- ここ で幾つかの他のクールな GAN プロジェクトを調べます。
- 音楽 を生成するために GAN を作成します。
以上