PyTorch 1.0 Tutorials : 生成モデル : DCGAN (翻訳/解説)
翻訳 : (株)クラスキャット セールスインフォメーション
作成日時 : 12/21/2018 (1.0.0.dev20181216)
* 本ページは、PyTorch 1.0 Tutorials : Generative : 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 size 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 を与えています、その総てが coming セクションで説明されます。
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 seem 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.2 を持つ正規分布からランダムに初期化されることを指定しています。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)
(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)
(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)
(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)
(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 と LeakyReLUs の使用は意味があります。DCGAN ペーパーは strided 畳込みを利用することは downsample へのプーリングよりも良い実践であることを言及しています、何故ならばそれはネットワークにそれ自身のプーリング関数を学習させるからです。またバッチ正規化と 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)
(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)
(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)
(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)
(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 labels) を変更することによりどの成分を計算することを望むかをどのように選択できるかを理解することは重要です。
次に、私達の 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)))\) を最大化することを望みます。genhacks からの separate mini-batch 提案によって、これを 2 つのステップで計算します。最初に、訓練セットから real サンプルのバッチを構築して、forward パスを通して損失 \(log(D(x))\)) を計算して、それから backward パスで勾配を計算します。2 番目に、現在の generator で fake サンプルのバッチを構築して、forward がこのバッチを \(D\) を通して、損失 (\(log(1-D(G(z)))\)) を計算し、そして backward パスで勾配を累積 (= accumulate) します。今、all-real and 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: 1.7410 Loss_G: 4.7764 D(x): 0.5343 D(G(z)): 0.5771 / 0.0136 [0/5][50/1583] Loss_D: 0.0110 Loss_G: 29.0730 D(x): 0.9921 D(G(z)): 0.0000 / 0.0000 [0/5][100/1583] Loss_D: 0.2691 Loss_G: 11.3166 D(x): 0.8413 D(G(z)): 0.0033 / 0.0008 [0/5][150/1583] Loss_D: 0.6448 Loss_G: 3.7590 D(x): 0.7485 D(G(z)): 0.1961 / 0.0295 [0/5][200/1583] Loss_D: 0.9018 Loss_G: 5.6608 D(x): 0.5523 D(G(z)): 0.0217 / 0.0120 [0/5][250/1583] Loss_D: 0.5531 Loss_G: 5.2389 D(x): 0.8211 D(G(z)): 0.2087 / 0.0083 [0/5][300/1583] Loss_D: 0.5144 Loss_G: 5.1494 D(x): 0.8679 D(G(z)): 0.2385 / 0.0150 [0/5][350/1583] Loss_D: 0.4065 Loss_G: 3.2266 D(x): 0.7876 D(G(z)): 0.0883 / 0.0626 [0/5][400/1583] Loss_D: 0.8670 Loss_G: 2.4115 D(x): 0.5472 D(G(z)): 0.0540 / 0.1429 [0/5][450/1583] Loss_D: 0.3171 Loss_G: 4.3070 D(x): 0.8901 D(G(z)): 0.1353 / 0.0256 [0/5][500/1583] Loss_D: 0.8423 Loss_G: 6.4113 D(x): 0.5746 D(G(z)): 0.0110 / 0.0082 [0/5][550/1583] Loss_D: 0.6403 Loss_G: 2.4626 D(x): 0.6587 D(G(z)): 0.0379 / 0.1775 [0/5][600/1583] Loss_D: 0.5044 Loss_G: 4.0269 D(x): 0.7672 D(G(z)): 0.1176 / 0.0283 [0/5][650/1583] Loss_D: 0.7792 Loss_G: 5.1394 D(x): 0.5825 D(G(z)): 0.0127 / 0.0146 [0/5][700/1583] Loss_D: 0.6592 Loss_G: 2.7273 D(x): 0.6628 D(G(z)): 0.0887 / 0.1133 [0/5][750/1583] Loss_D: 0.4397 Loss_G: 5.6692 D(x): 0.8728 D(G(z)): 0.2178 / 0.0074 [0/5][800/1583] Loss_D: 0.9174 Loss_G: 6.6212 D(x): 0.9658 D(G(z)): 0.4920 / 0.0040 [0/5][850/1583] Loss_D: 0.3673 Loss_G: 4.2762 D(x): 0.8354 D(G(z)): 0.0868 / 0.0232 [0/5][900/1583] Loss_D: 0.4512 Loss_G: 4.6451 D(x): 0.7140 D(G(z)): 0.0304 / 0.0268 [0/5][950/1583] Loss_D: 0.6250 Loss_G: 5.7946 D(x): 0.8777 D(G(z)): 0.3108 / 0.0110 [0/5][1000/1583] Loss_D: 0.4857 Loss_G: 3.6268 D(x): 0.8575 D(G(z)): 0.2278 / 0.0454 [0/5][1050/1583] Loss_D: 0.8415 Loss_G: 7.2168 D(x): 0.9268 D(G(z)): 0.4668 / 0.0018 [0/5][1100/1583] Loss_D: 0.9034 Loss_G: 2.1795 D(x): 0.5360 D(G(z)): 0.0347 / 0.1617 [0/5][1150/1583] Loss_D: 0.3960 Loss_G: 3.5141 D(x): 0.8193 D(G(z)): 0.1303 / 0.0444 [0/5][1200/1583] Loss_D: 0.6166 Loss_G: 3.5159 D(x): 0.7843 D(G(z)): 0.2429 / 0.0463 [0/5][1250/1583] Loss_D: 0.6318 Loss_G: 4.3193 D(x): 0.7409 D(G(z)): 0.1833 / 0.0256 [0/5][1300/1583] Loss_D: 0.5217 Loss_G: 4.0391 D(x): 0.7905 D(G(z)): 0.1693 / 0.0330 [0/5][1350/1583] Loss_D: 1.1310 Loss_G: 8.2079 D(x): 0.8355 D(G(z)): 0.5174 / 0.0009 [0/5][1400/1583] Loss_D: 0.8284 Loss_G: 7.7848 D(x): 0.9725 D(G(z)): 0.4794 / 0.0014 [0/5][1450/1583] Loss_D: 1.7411 Loss_G: 7.4958 D(x): 0.9625 D(G(z)): 0.7125 / 0.0017 [0/5][1500/1583] Loss_D: 0.3849 Loss_G: 3.6374 D(x): 0.8195 D(G(z)): 0.1182 / 0.0462 [0/5][1550/1583] Loss_D: 0.9600 Loss_G: 7.2110 D(x): 0.9658 D(G(z)): 0.5337 / 0.0014 [1/5][0/1583] Loss_D: 0.2518 Loss_G: 4.1840 D(x): 0.8540 D(G(z)): 0.0595 / 0.0254 [1/5][50/1583] Loss_D: 0.3577 Loss_G: 3.8768 D(x): 0.8596 D(G(z)): 0.1537 / 0.0316 [1/5][100/1583] Loss_D: 0.4328 Loss_G: 3.0822 D(x): 0.7834 D(G(z)): 0.0992 / 0.0763 [1/5][150/1583] Loss_D: 0.3725 Loss_G: 3.1920 D(x): 0.8864 D(G(z)): 0.1843 / 0.0733 [1/5][200/1583] Loss_D: 0.8628 Loss_G: 1.9816 D(x): 0.5556 D(G(z)): 0.0435 / 0.2144 [1/5][250/1583] Loss_D: 0.6630 Loss_G: 4.9168 D(x): 0.9054 D(G(z)): 0.3758 / 0.0135 [1/5][300/1583] Loss_D: 0.4174 Loss_G: 3.1888 D(x): 0.7446 D(G(z)): 0.0682 / 0.0641 [1/5][350/1583] Loss_D: 1.1475 Loss_G: 1.6796 D(x): 0.4205 D(G(z)): 0.0183 / 0.2565 [1/5][400/1583] Loss_D: 0.5317 Loss_G: 4.1414 D(x): 0.8712 D(G(z)): 0.2738 / 0.0282 [1/5][450/1583] Loss_D: 0.9507 Loss_G: 6.1139 D(x): 0.8682 D(G(z)): 0.4733 / 0.0040 [1/5][500/1583] Loss_D: 1.0072 Loss_G: 5.5619 D(x): 0.8930 D(G(z)): 0.5125 / 0.0077 [1/5][550/1583] Loss_D: 0.3419 Loss_G: 2.8670 D(x): 0.8919 D(G(z)): 0.1688 / 0.0895 [1/5][600/1583] Loss_D: 0.6169 Loss_G: 3.7120 D(x): 0.8519 D(G(z)): 0.3032 / 0.0412 [1/5][650/1583] Loss_D: 0.3275 Loss_G: 4.3658 D(x): 0.8497 D(G(z)): 0.1199 / 0.0233 [1/5][700/1583] Loss_D: 0.3542 Loss_G: 3.3723 D(x): 0.8665 D(G(z)): 0.1674 / 0.0475 [1/5][750/1583] Loss_D: 0.8363 Loss_G: 5.6487 D(x): 0.9274 D(G(z)): 0.4426 / 0.0081 [1/5][800/1583] Loss_D: 0.3266 Loss_G: 2.6443 D(x): 0.8823 D(G(z)): 0.1588 / 0.0987 [1/5][850/1583] Loss_D: 1.1997 Loss_G: 1.6461 D(x): 0.4474 D(G(z)): 0.0912 / 0.2721 [1/5][900/1583] Loss_D: 0.3618 Loss_G: 2.6012 D(x): 0.8357 D(G(z)): 0.1382 / 0.1088 [1/5][950/1583] Loss_D: 0.6252 Loss_G: 3.6840 D(x): 0.8843 D(G(z)): 0.3487 / 0.0410 [1/5][1000/1583] Loss_D: 0.5877 Loss_G: 1.8763 D(x): 0.6399 D(G(z)): 0.0588 / 0.2022 [1/5][1050/1583] Loss_D: 2.5637 Loss_G: 0.5971 D(x): 0.1583 D(G(z)): 0.0082 / 0.6446 [1/5][1100/1583] Loss_D: 0.9515 Loss_G: 1.9145 D(x): 0.4651 D(G(z)): 0.0321 / 0.2063 [1/5][1150/1583] Loss_D: 0.8497 Loss_G: 4.3713 D(x): 0.7918 D(G(z)): 0.3977 / 0.0256 [1/5][1200/1583] Loss_D: 0.7580 Loss_G: 5.0156 D(x): 0.9559 D(G(z)): 0.4655 / 0.0106 [1/5][1250/1583] Loss_D: 0.3695 Loss_G: 3.6694 D(x): 0.8708 D(G(z)): 0.1839 / 0.0375 [1/5][1300/1583] Loss_D: 0.5765 Loss_G: 3.5503 D(x): 0.8617 D(G(z)): 0.3054 / 0.0431 [1/5][1350/1583] Loss_D: 0.4047 Loss_G: 2.4471 D(x): 0.8285 D(G(z)): 0.1735 / 0.1099 [1/5][1400/1583] Loss_D: 0.5986 Loss_G: 3.3368 D(x): 0.7780 D(G(z)): 0.2441 / 0.0543 [1/5][1450/1583] Loss_D: 0.6106 Loss_G: 2.7762 D(x): 0.7552 D(G(z)): 0.2290 / 0.0884 [1/5][1500/1583] Loss_D: 0.9563 Loss_G: 4.2554 D(x): 0.9374 D(G(z)): 0.5220 / 0.0223 [1/5][1550/1583] Loss_D: 0.5391 Loss_G: 2.4060 D(x): 0.7806 D(G(z)): 0.2013 / 0.1239 [2/5][0/1583] Loss_D: 0.7019 Loss_G: 2.7915 D(x): 0.7471 D(G(z)): 0.2764 / 0.0858 [2/5][50/1583] Loss_D: 0.7316 Loss_G: 1.2261 D(x): 0.5525 D(G(z)): 0.0539 / 0.3509 [2/5][100/1583] Loss_D: 1.8504 Loss_G: 0.6499 D(x): 0.2452 D(G(z)): 0.0428 / 0.5735 [2/5][150/1583] Loss_D: 0.6107 Loss_G: 2.4452 D(x): 0.7348 D(G(z)): 0.2071 / 0.1115 [2/5][200/1583] Loss_D: 0.6909 Loss_G: 3.0348 D(x): 0.8014 D(G(z)): 0.3330 / 0.0634 [2/5][250/1583] Loss_D: 0.7596 Loss_G: 1.0144 D(x): 0.5685 D(G(z)): 0.0664 / 0.4257 [2/5][300/1583] Loss_D: 0.6201 Loss_G: 3.8590 D(x): 0.9254 D(G(z)): 0.3831 / 0.0305 [2/5][350/1583] Loss_D: 0.5193 Loss_G: 2.4657 D(x): 0.7593 D(G(z)): 0.1822 / 0.1089 [2/5][400/1583] Loss_D: 1.6379 Loss_G: 0.3146 D(x): 0.2542 D(G(z)): 0.0130 / 0.7684 [2/5][450/1583] Loss_D: 0.5845 Loss_G: 2.6891 D(x): 0.6261 D(G(z)): 0.0499 / 0.0964 [2/5][500/1583] Loss_D: 0.6987 Loss_G: 2.0094 D(x): 0.5704 D(G(z)): 0.0435 / 0.1814 [2/5][550/1583] Loss_D: 0.5415 Loss_G: 3.5310 D(x): 0.8971 D(G(z)): 0.3276 / 0.0372 [2/5][600/1583] Loss_D: 0.4856 Loss_G: 2.6832 D(x): 0.8754 D(G(z)): 0.2639 / 0.0923 [2/5][650/1583] Loss_D: 0.5898 Loss_G: 3.0553 D(x): 0.8493 D(G(z)): 0.3125 / 0.0630 [2/5][700/1583] Loss_D: 0.6398 Loss_G: 2.7859 D(x): 0.7488 D(G(z)): 0.2521 / 0.0863 [2/5][750/1583] Loss_D: 0.8812 Loss_G: 1.5327 D(x): 0.5550 D(G(z)): 0.1349 / 0.2683 [2/5][800/1583] Loss_D: 0.4119 Loss_G: 3.0007 D(x): 0.8756 D(G(z)): 0.2221 / 0.0658 [2/5][850/1583] Loss_D: 0.9140 Loss_G: 3.7664 D(x): 0.8864 D(G(z)): 0.5006 / 0.0345 [2/5][900/1583] Loss_D: 0.5953 Loss_G: 2.6773 D(x): 0.7129 D(G(z)): 0.1819 / 0.0982 [2/5][950/1583] Loss_D: 0.9189 Loss_G: 4.1876 D(x): 0.9431 D(G(z)): 0.5208 / 0.0294 [2/5][1000/1583] Loss_D: 0.8886 Loss_G: 4.1923 D(x): 0.9401 D(G(z)): 0.5141 / 0.0231 [2/5][1050/1583] Loss_D: 0.9713 Loss_G: 1.3830 D(x): 0.4505 D(G(z)): 0.0411 / 0.3379 [2/5][1100/1583] Loss_D: 0.4030 Loss_G: 3.5259 D(x): 0.9146 D(G(z)): 0.2473 / 0.0391 [2/5][1150/1583] Loss_D: 0.6570 Loss_G: 3.4240 D(x): 0.9190 D(G(z)): 0.3983 / 0.0428 [2/5][1200/1583] Loss_D: 0.5348 Loss_G: 2.7974 D(x): 0.7759 D(G(z)): 0.2103 / 0.0794 [2/5][1250/1583] Loss_D: 1.3462 Loss_G: 6.3865 D(x): 0.9680 D(G(z)): 0.6793 / 0.0041 [2/5][1300/1583] Loss_D: 0.5062 Loss_G: 3.5325 D(x): 0.8559 D(G(z)): 0.2619 / 0.0396 [2/5][1350/1583] Loss_D: 0.5380 Loss_G: 2.5076 D(x): 0.8327 D(G(z)): 0.2679 / 0.1030 [2/5][1400/1583] Loss_D: 2.4783 Loss_G: 4.9395 D(x): 0.9873 D(G(z)): 0.8771 / 0.0124 [2/5][1450/1583] Loss_D: 1.3165 Loss_G: 1.3135 D(x): 0.3465 D(G(z)): 0.0300 / 0.3333 [2/5][1500/1583] Loss_D: 0.5369 Loss_G: 1.7358 D(x): 0.7299 D(G(z)): 0.1632 / 0.2160 [2/5][1550/1583] Loss_D: 0.6551 Loss_G: 2.4520 D(x): 0.7599 D(G(z)): 0.2811 / 0.1031 [3/5][0/1583] Loss_D: 0.5302 Loss_G: 2.4840 D(x): 0.7521 D(G(z)): 0.1851 / 0.1086 [3/5][50/1583] Loss_D: 0.6689 Loss_G: 1.6595 D(x): 0.6547 D(G(z)): 0.1665 / 0.2256 [3/5][100/1583] Loss_D: 1.4652 Loss_G: 5.7589 D(x): 0.9731 D(G(z)): 0.7156 / 0.0055 [3/5][150/1583] Loss_D: 1.1694 Loss_G: 3.5898 D(x): 0.8015 D(G(z)): 0.5530 / 0.0469 [3/5][200/1583] Loss_D: 0.4797 Loss_G: 2.7986 D(x): 0.8388 D(G(z)): 0.2417 / 0.0747 [3/5][250/1583] Loss_D: 1.2413 Loss_G: 0.8465 D(x): 0.4299 D(G(z)): 0.1788 / 0.4755 [3/5][300/1583] Loss_D: 0.5862 Loss_G: 2.1054 D(x): 0.6507 D(G(z)): 0.0876 / 0.1494 [3/5][350/1583] Loss_D: 0.6512 Loss_G: 3.5416 D(x): 0.8962 D(G(z)): 0.3791 / 0.0388 [3/5][400/1583] Loss_D: 0.9218 Loss_G: 4.1735 D(x): 0.9286 D(G(z)): 0.5221 / 0.0221 [3/5][450/1583] Loss_D: 1.3960 Loss_G: 1.0443 D(x): 0.3206 D(G(z)): 0.0806 / 0.4030 [3/5][500/1583] Loss_D: 0.6472 Loss_G: 3.4090 D(x): 0.9329 D(G(z)): 0.3975 / 0.0477 [3/5][550/1583] Loss_D: 0.5923 Loss_G: 3.8375 D(x): 0.9207 D(G(z)): 0.3622 / 0.0281 [3/5][600/1583] Loss_D: 0.8760 Loss_G: 1.1667 D(x): 0.5115 D(G(z)): 0.0827 / 0.3558 [3/5][650/1583] Loss_D: 0.5896 Loss_G: 2.9461 D(x): 0.8486 D(G(z)): 0.3092 / 0.0769 [3/5][700/1583] Loss_D: 0.4034 Loss_G: 3.1982 D(x): 0.8826 D(G(z)): 0.2255 / 0.0520 [3/5][750/1583] Loss_D: 0.6956 Loss_G: 2.0808 D(x): 0.6435 D(G(z)): 0.1724 / 0.1661 [3/5][800/1583] Loss_D: 0.5283 Loss_G: 2.5050 D(x): 0.7743 D(G(z)): 0.2018 / 0.1069 [3/5][850/1583] Loss_D: 0.4740 Loss_G: 2.3121 D(x): 0.7514 D(G(z)): 0.1404 / 0.1243 [3/5][900/1583] Loss_D: 0.6058 Loss_G: 1.1781 D(x): 0.6669 D(G(z)): 0.1310 / 0.3433 [3/5][950/1583] Loss_D: 2.2482 Loss_G: 6.1515 D(x): 0.9819 D(G(z)): 0.8542 / 0.0044 [3/5][1000/1583] Loss_D: 0.5434 Loss_G: 2.4503 D(x): 0.7466 D(G(z)): 0.1878 / 0.1079 [3/5][1050/1583] Loss_D: 2.3381 Loss_G: 6.4762 D(x): 0.9711 D(G(z)): 0.8559 / 0.0034 [3/5][1100/1583] Loss_D: 0.5287 Loss_G: 3.0149 D(x): 0.8721 D(G(z)): 0.2891 / 0.0686 [3/5][1150/1583] Loss_D: 0.5022 Loss_G: 2.4287 D(x): 0.7742 D(G(z)): 0.1918 / 0.1145 [3/5][1200/1583] Loss_D: 0.7414 Loss_G: 3.9821 D(x): 0.9148 D(G(z)): 0.4335 / 0.0260 [3/5][1250/1583] Loss_D: 0.5409 Loss_G: 3.1386 D(x): 0.8754 D(G(z)): 0.3015 / 0.0575 [3/5][1300/1583] Loss_D: 1.6427 Loss_G: 0.6510 D(x): 0.3559 D(G(z)): 0.2987 / 0.5683 [3/5][1350/1583] Loss_D: 0.7018 Loss_G: 2.0446 D(x): 0.7331 D(G(z)): 0.2818 / 0.1602 [3/5][1400/1583] Loss_D: 0.8138 Loss_G: 3.4080 D(x): 0.9069 D(G(z)): 0.4749 / 0.0453 [3/5][1450/1583] Loss_D: 0.5912 Loss_G: 1.8774 D(x): 0.6959 D(G(z)): 0.1564 / 0.1816 [3/5][1500/1583] Loss_D: 0.5367 Loss_G: 3.2584 D(x): 0.8608 D(G(z)): 0.2928 / 0.0505 [3/5][1550/1583] Loss_D: 0.7693 Loss_G: 3.0239 D(x): 0.7563 D(G(z)): 0.3310 / 0.0705 [4/5][0/1583] Loss_D: 0.6952 Loss_G: 2.4476 D(x): 0.7446 D(G(z)): 0.2802 / 0.1083 [4/5][50/1583] Loss_D: 1.4284 Loss_G: 0.4279 D(x): 0.3081 D(G(z)): 0.0288 / 0.6903 [4/5][100/1583] Loss_D: 0.5811 Loss_G: 2.6915 D(x): 0.7891 D(G(z)): 0.2506 / 0.0899 [4/5][150/1583] Loss_D: 0.7287 Loss_G: 2.8782 D(x): 0.9092 D(G(z)): 0.4322 / 0.0763 [4/5][200/1583] Loss_D: 0.5332 Loss_G: 3.2461 D(x): 0.8934 D(G(z)): 0.3145 / 0.0512 [4/5][250/1583] Loss_D: 0.7135 Loss_G: 1.8167 D(x): 0.6349 D(G(z)): 0.1689 / 0.1986 [4/5][300/1583] Loss_D: 2.2007 Loss_G: 0.1039 D(x): 0.1665 D(G(z)): 0.0205 / 0.9102 [4/5][350/1583] Loss_D: 0.4470 Loss_G: 2.9338 D(x): 0.8692 D(G(z)): 0.2353 / 0.0726 [4/5][400/1583] Loss_D: 0.9442 Loss_G: 1.3627 D(x): 0.4642 D(G(z)): 0.0592 / 0.3174 [4/5][450/1583] Loss_D: 0.5739 Loss_G: 2.4657 D(x): 0.8427 D(G(z)): 0.2993 / 0.1092 [4/5][500/1583] Loss_D: 0.4289 Loss_G: 3.7944 D(x): 0.9367 D(G(z)): 0.2849 / 0.0287 [4/5][550/1583] Loss_D: 0.5193 Loss_G: 2.6364 D(x): 0.8504 D(G(z)): 0.2701 / 0.0971 [4/5][600/1583] Loss_D: 0.7456 Loss_G: 2.2069 D(x): 0.6755 D(G(z)): 0.2331 / 0.1450 [4/5][650/1583] Loss_D: 0.6846 Loss_G: 1.6330 D(x): 0.5764 D(G(z)): 0.0644 / 0.2410 [4/5][700/1583] Loss_D: 0.5622 Loss_G: 3.4119 D(x): 0.9035 D(G(z)): 0.3386 / 0.0425 [4/5][750/1583] Loss_D: 0.6915 Loss_G: 1.6471 D(x): 0.7005 D(G(z)): 0.2239 / 0.2320 [4/5][800/1583] Loss_D: 0.4859 Loss_G: 3.1402 D(x): 0.8198 D(G(z)): 0.2178 / 0.0553 [4/5][850/1583] Loss_D: 0.6690 Loss_G: 3.0298 D(x): 0.8272 D(G(z)): 0.3319 / 0.0666 [4/5][900/1583] Loss_D: 0.5096 Loss_G: 1.5814 D(x): 0.7263 D(G(z)): 0.1360 / 0.2495 [4/5][950/1583] Loss_D: 0.9591 Loss_G: 5.0106 D(x): 0.9059 D(G(z)): 0.5209 / 0.0134 [4/5][1000/1583] Loss_D: 0.4626 Loss_G: 2.6274 D(x): 0.8418 D(G(z)): 0.2241 / 0.0909 [4/5][1050/1583] Loss_D: 0.4472 Loss_G: 3.1159 D(x): 0.8859 D(G(z)): 0.2549 / 0.0579 [4/5][1100/1583] Loss_D: 0.5172 Loss_G: 2.9177 D(x): 0.8418 D(G(z)): 0.2672 / 0.0674 [4/5][1150/1583] Loss_D: 0.8143 Loss_G: 4.0803 D(x): 0.9287 D(G(z)): 0.4732 / 0.0256 [4/5][1200/1583] Loss_D: 1.1907 Loss_G: 0.3028 D(x): 0.3789 D(G(z)): 0.0365 / 0.7761 [4/5][1250/1583] Loss_D: 0.4688 Loss_G: 2.2372 D(x): 0.7929 D(G(z)): 0.1814 / 0.1364 [4/5][1300/1583] Loss_D: 0.5055 Loss_G: 3.4458 D(x): 0.9366 D(G(z)): 0.3205 / 0.0423 [4/5][1350/1583] Loss_D: 0.4589 Loss_G: 2.5290 D(x): 0.7692 D(G(z)): 0.1492 / 0.1015 [4/5][1400/1583] Loss_D: 0.6898 Loss_G: 1.7355 D(x): 0.6498 D(G(z)): 0.1712 / 0.2210 [4/5][1450/1583] Loss_D: 1.0059 Loss_G: 4.5177 D(x): 0.9367 D(G(z)): 0.5494 / 0.0178 [4/5][1500/1583] Loss_D: 0.6115 Loss_G: 1.6072 D(x): 0.6410 D(G(z)): 0.1066 / 0.2485 [4/5][1550/1583] Loss_D: 0.6686 Loss_G: 1.9678 D(x): 0.6073 D(G(z)): 0.0854 / 0.1767
結果
最後に、私達がどのように行なったかを調べましょう。ここでは、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 を作成します。
以上