DCGAN 教程 ¶
项目地址：https://pytorch.apachecn.org/2.0/tutorials/beginner/dcgan_faces_tutorial
原始地址：https://pytorch.org/tutorials/beginner/dcgan_faces_tutorial.html
作者 : Nathan Inkawhich
简介 ¶
本教程将通过示例介绍 DCGAN。我们将训练生成对抗网络 (GAN)，在向其展示许多真实名人的照片后生成新的名人。这里的大部分代码来自 pytorch/examples 中的 DCGAN 实现，并且这个文档将给出实现和棚的彻底解释深入了解该模型如何以及为何发挥作用。但不用’担心，不需要事先了解 GAN，但可能需要初学者花一些时间来推理幕后实际发生的情况。此外，为了节省时间拥有一个或两个 GPU 会有所帮助。让从头开始吧。
生成对抗网络 ¶
什么是 GAN？ ¶
GAN 是一个框架，用于教授深度学习模型以捕获训练数据分布，以便我们可以从同一分布生成新数据。 GAN 由 Ian Goodfellow 于 2014 年发明，并首先在论文 生成对抗网络中进行了描述。它们由两个不同的模型组成： 一个 generator 和 一个 discriminator 。生成器的工作是生成看起来像训练图像的 ‘fake’ 图像。鉴别器的工作是查看图像并输出它是真实的训练图像还是来自生成器的假图像。在训练过程中，生成器不断尝试通过生成越来越好的假图像来智胜鉴别器，而鉴别器则致力于成为更好的侦探并正确分类真实图像和假图像。这个游戏的平衡是当生成器生成完美的赝品，看起来好像它们直接来自训练数据，并且鉴别器总是以50%的置信度猜测生成器输出是真的还是假的。
现在，让我们定义一些在整个教程中使用的符号，从鉴别器开始。令 \(x\) 为表示图像的数据。\(D(x)\) 是输出(标量)的判别器网络, \(x\) 来自训练数据而不是生成器的概率。在这里，由于我们处理的是图像，\(D(x)\) 的输入是 CHW 大小为 3x64x64 的图像。直观地说，当 \(x\) 来自训练数据时，\(D(x)\) 应该为高，而当时为低\(x\)来自生成器。\(D(x)\)也可以被视为传统的二元分类器。
对于生成器’s 表示法，令\(z\)是从标准正态分布采样的潜在空间向量。\(G (z)\)表示将潜在向量\(z\)映射到数据空间的生成器函数。目标 \(G\) 是估计训练数据来自 (\(p_{data}\)) 的分布，以便生成假样本来自估计的分布 (\(p_g\))。
因此，\(D(G(z))\)是生成器的输出\(G\)\ 的概率(标量) n 是真实图像。如 Goodfellow’s paper 中所述，\(D \)和\(G\)玩一个极小极大游戏，其中\(D\)尝试最大化概率它正确地分类了真品和假品(\(logD(x)\))，并且\(G\)尝试最小化概率\(D\)将预测其输出是假的 (\(log(1-D(G(z)))\)).论文中，GAN 损失函数为[\underset{G}{\text{min}} \underset{D}{\text{max}}V(D,G) = \mathbb{E}{ x\sim p(x)}\big[logD(x)\big] + \mathbb{E}{z\sim p( z)}\big[log(1-D(G(z)))\big]]
理论上，这个极小极大游戏的解是\ n \(p_g = p_{data}\)，判别器随机猜测输入是真的还是假的。然而，GAN 的收敛理论仍在积极研究中，而现实模型并不总是 训练到这一点。
什么是 DCGAN？ ¶
DCGAN 是上述 GAN 的直接扩展，不同之处在于它分别在判别器和生成器中显式使用卷积层和卷积转置层。它首先由 Radford 等人描述。论文中的 al. 使用深度卷积生成对抗网络进行无监督表示学习。判别器由 strided 卷积 层、batch norm 层，和 LeakyReLU 激活。输入是 3x64x64 输入图像，输出是输入来自真实数据分布的标量概率。生成器由 卷积转置 层、批标准化层和 ReLU 激活。输入是一个潜在向量，\(z\)，它是从标准正态分布中提取的，输出是 3x64x64 RGB 图像。跨步卷积转置层允许将潜在向量转换为与图像形状相同的体积。在本文中，作者还提供了一些有关如何设置优化器、如何计算损失函数以及如何初始化模型权重的提示，所有这些都将在接下来的部分中进行解释。
#%matplotlib inline
import argparse
import os
import random
import torch
import torch.nn as nn
import torch.nn.parallel
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)
torch.use_deterministic_algorithms(True) # Needed for reproducible results
输出：
输入 ¶
让我们定义运行的一些输入:
* dataroot
- 数据集文件夹根目录的路径。我们将在下一节中详细讨论数据集。
* workers
- 用于使用
DataLoader
加载数据的工作线程数。
* batch_size
- 训练中使用的批量大小。 DCGAN 论文\使用的批量大小为 128。
* image_size
- 用于训练的图像的空间大小。
此实现默认为 64x64。如果需要其他尺寸，则必须更改 D 和 G 的结构。请参阅
此处
了解更多
详细信息。
* nc
- 输入图像中的颜色通道数。对于彩色图像，此值为 3。
* nz
- 潜在向量的长度。
* ngf
- 与通过生成器
生成的特征图的深度相关。
* ndf
- 设置通过鉴别器传播的特征图的深度。
* num_epochs
- 要运行的训练周期数。训练时间越长可能会得到更好的结果，但也会花费更长的时间。
* lr
- 训练的学习率。正如 DCGAN 论文中所述，
这个数字应该是 0.0002。
* beta1
- Adam 优化器的 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数据集，可以在链接处下载站点，或在 GoogleDrive 中。数据集将下载为名为 img_align_celeba 的文件.zip.下载后，创建一个名为“celeba”的目录，并将 zip 文件解压到该目录中。然后，将此笔记本的
dataroot 输入设置为您刚刚创建的 celeba 目录。生成的目录结构应为：
这是重要的一步，因为我们将使用 ImageFolder 数据集类，它要求数据集根文件夹中有子目录。现在，我们可以创建数据集，创建数据加载器，设置要运行的设备，最后可视化一些训练数据。
# 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)))
实现 ¶
设置好输入参数并准备好数据集后，我们现在就可以开始实施了。我们将从权重初始化 策略开始，然后详细讨论生成器、判别器、损失函数 和训练循环。
权重初始化 ¶
在 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)
生成器 ¶
生成器 \(G\) 旨在将潜在空间向量( \(z\) ) 映射到数据-空间。由于我们的数据是图像，因此将 \(z\) 转换为数据空间意味着最终创建一个与训练图像大小相同的 RGB 图像(即 3x64x64)。在实践中，这是通过一系列跨步二维卷积转置层来实现的，每个转置层都与二维批归一化层和 relu 激活配对。生成器的输出通过 tanh 函数返回到输入数据范围 \([-1,1]\) 。值得注意的是，在卷积转置层之后存在批标准化函数，因为这是 DCGAN 论文的关键贡献。这些层有助于训练期间梯度的流动。下面显示了DCGAN 论文中的生成器图像。
请注意，我们在输入部分中设置的输入(nz、 ngf 和 nc )如何影响代码中的生成器架构。 nz\ n 是 z 输入向量的长度， ngf
与通过生成器传播的特征映射的大小有关， nc 是通道数输出图像(对于 RGB 图像设置为 3)。下面是生成器的代码。
# 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)
现在，我们可以实例化生成器并应用 weights_init 函数。查看打印的模型以了解生成器对象的结构。
# 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()
)
)
鉴别器 ¶
如前所述，判别器 \(D\) 是一个二元分类网络，它将图像作为输入并输出输入图像为真实图像的标量概率(如反对假货)。这里， \(D\) 采用 3x64x64 输入图像，通过一系列 Conv2d、BatchNorm2d 和 LeakyReLU 层对其进行处理，并通过 Sigmoid 激活函数输出最终概率。如果问题需要，可以使用更多层扩展此架构，但使用跨步卷积、BatchNorm 和 LeakyReLU 具有重要意义。 DCGAN 论文提到，使用跨步卷积而不是池化来下采样是一种很好的做法，因为它可以让网络学习其自己的池化函数。批归一化和泄漏 ReLU 函数还促进健康的梯度流，这对于 \(G\) 和 \(D\) 的学习过程至关重要.
鉴别器代码
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)
现在，与生成器一样，我们可以创建鉴别器，应用 weights_init 函数，并打印模型’s 结构。
# 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()
)
)
损失函数和优化器 ¶
通过 \(D\) 和 \(G\) 设置，我们可以指定它们如何通过损失函数和优化器学习。我们将使用二元交叉熵损失( BCELoss )\ nfunction 在 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(D(x))\) 和 \ n \(log(1-D(G(z)))\) )。我们可以指定 BCE 方程的哪一部分与 \(y\) 输入一起使用。这是在即将到来的训练循环中完成的，但重要的是要了解我们如何通过更改 \(y\) (即 GT 标签)。
接下来，我们将真实标签定义为 1，假标签定义为 0。这些标签将在计算 \(D\) 和 \ 的损失时使用\(G\) ，这也是原始 GAN 论文中使用的约定。最后，我们设置了两个单独的优化器，一个用于 \(D\) ，一个用于 \(G\) 。正如 DCGAN 论文中所指定的，两者都是 Adam 优化器，学习率为 0.0002，Beta1 = 0.5。为了跟踪生成器 xe2x80x99 的学习进度，我们将生成一批固定的潜在向量，这些向量是从高斯分布(即 xc2xa0fixed_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’s论文中的算法1，\在遵守ganhacks中显示的一些最佳实践的同时。也就是说，我们将“构建不同的小批量，用于真实和fake”图像，并调整 G’s 目标函数以最大化 \(log(D(G(z)))\) 。培训分为两个主要部分。第 1 部分更新鉴别器，第 2 部分更新生成器。
第 1 部分 - 训练鉴别器
回想一下，训练鉴别器的目标是最大化将给定输入正确分类为真或假的概率。按照 Goodfellow 的说法，我们希望通过升序随机梯度 xe2x80x9d 来更新判别器。实际上，我们希望最大化 \(log(D(x)) + log(1-D(G(z)))\) 。由于来自 ganhacks 的单独小批量建议，我们将分两步进行计算。首先，我们从训练集中构建一批真实样本，向前传递 \(D\) ，计算损失( \(log(D (x))\) )，然后计算向后传递中的梯度。其次，我们将使用当前生成器构造一批假样本，将这批样本前向传递 \(D\) ，计算损失 ( \(log (1-D(G(z)))\) ),和 累积 通过向后传递的梯度。现在，利用从全真批次和全假批次累积的梯度，我们调用判别器’s 优化器的一个步骤。
第 2 部分 - 训练生成器
正如原始论文中所述，我们希望通过最小化 \(log(1-D(G(z)))\) 来训练生成器，以努力生成更好的赝品。如前所述，Goodfellow 表明这不能提供足够的梯度，尤其是在学习过程的早期。作为解决方案，我们希望最大化 \(log(D(G(z)))\) 。在代码中，我们通过以下方式完成
：使用判别器对第 1 部分的生成器输出进行分类，计算 G\xe2\x80\x99s 损失 使用真实标签作为 GT ，计算G\xe2\x80\ x99s 向后传递梯度，最后使用优化器步骤更新 G\xe2\x80\x99s 参数。使用真实标签作为损失函数的 GT 标签似乎违反直觉，但这允许我们使用 \(log(x)\) 部分 BCELoss (而不是 \(log(1-x)\) 部分)这正是我们想要的。
最后，我们将做一些统计报告，在每个时期结束时，我们将通过生成器推送固定的噪声批次，以直观地跟踪 G’s 训练的进度。报告的训练统计数据 为：
- Loss_D
- 判别器损失计算为所有真实批次和所有假批次的损失总和 ( \(log(D(x)) + log(1 - D (G(z)))\) ).
- Loss_G
- 发电机损失计算为 \(log(D(G(z)) )\)
- D(x)
- 所有真实批次的判别器的平均输出(跨批次)。这应该开始接近 1，然后理论上当 G 变得更好时收敛到 0.5。想想为什么会这样。
- D(G(z))
- 所有假批次的平均鉴别器输出。第一个数字在 D 更新之前，第二个数字在 D 之后已更新。这些数字应该从 0 附近开始，并随着 G 变得更好而收敛到 0.5。想一想这是为什么。
注意： 此步骤可能需要一段时间，具体取决于您运行的轮数以及是否从数据集中删除了一些数据。
# 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.4640 Loss_G: 6.9360 D(x): 0.7143 D(G(z)): 0.5877 / 0.0017
[0/5][50/1583] Loss_D: 0.0174 Loss_G: 23.7368 D(x): 0.9881 D(G(z)): 0.0000 / 0.0000
[0/5][100/1583] Loss_D: 0.5983 Loss_G: 9.9471 D(x): 0.9715 D(G(z)): 0.3122 / 0.0003
[0/5][150/1583] Loss_D: 0.4940 Loss_G: 5.6772 D(x): 0.7028 D(G(z)): 0.0241 / 0.0091
[0/5][200/1583] Loss_D: 0.5931 Loss_G: 7.1186 D(x): 0.9423 D(G(z)): 0.3016 / 0.0018
[0/5][250/1583] Loss_D: 0.3846 Loss_G: 3.2697 D(x): 0.7663 D(G(z)): 0.0573 / 0.0739
[0/5][300/1583] Loss_D: 1.3306 Loss_G: 8.3204 D(x): 0.8768 D(G(z)): 0.6353 / 0.0009
[0/5][350/1583] Loss_D: 0.6451 Loss_G: 6.0499 D(x): 0.9025 D(G(z)): 0.3673 / 0.0060
[0/5][400/1583] Loss_D: 0.4211 Loss_G: 3.7316 D(x): 0.8407 D(G(z)): 0.1586 / 0.0392
[0/5][450/1583] Loss_D: 0.6569 Loss_G: 2.4818 D(x): 0.6437 D(G(z)): 0.0858 / 0.1129
[0/5][500/1583] Loss_D: 1.2208 Loss_G: 2.9943 D(x): 0.4179 D(G(z)): 0.0109 / 0.1133
[0/5][550/1583] Loss_D: 0.3400 Loss_G: 4.7669 D(x): 0.9135 D(G(z)): 0.1922 / 0.0145
[0/5][600/1583] Loss_D: 0.5756 Loss_G: 4.8500 D(x): 0.9189 D(G(z)): 0.3193 / 0.0187
[0/5][650/1583] Loss_D: 0.2470 Loss_G: 4.1606 D(x): 0.9460 D(G(z)): 0.1545 / 0.0250
[0/5][700/1583] Loss_D: 0.3887 Loss_G: 4.1884 D(x): 0.8518 D(G(z)): 0.1562 / 0.0297
[0/5][750/1583] Loss_D: 0.5353 Loss_G: 4.1742 D(x): 0.8034 D(G(z)): 0.1958 / 0.0302
[0/5][800/1583] Loss_D: 0.3213 Loss_G: 5.8919 D(x): 0.9076 D(G(z)): 0.1572 / 0.0065
[0/5][850/1583] Loss_D: 0.8850 Loss_G: 7.4333 D(x): 0.9258 D(G(z)): 0.4449 / 0.0017
[0/5][900/1583] Loss_D: 1.2624 Loss_G: 10.0392 D(x): 0.9896 D(G(z)): 0.6361 / 0.0002
[0/5][950/1583] Loss_D: 0.8802 Loss_G: 6.9221 D(x): 0.5527 D(G(z)): 0.0039 / 0.0045
[0/5][1000/1583] Loss_D: 0.5799 Loss_G: 3.1800 D(x): 0.7062 D(G(z)): 0.0762 / 0.0884
[0/5][1050/1583] Loss_D: 0.9647 Loss_G: 6.6894 D(x): 0.9429 D(G(z)): 0.5270 / 0.0035
[0/5][1100/1583] Loss_D: 0.5624 Loss_G: 3.6715 D(x): 0.7944 D(G(z)): 0.2069 / 0.0445
[0/5][1150/1583] Loss_D: 0.6205 Loss_G: 4.8995 D(x): 0.8634 D(G(z)): 0.3046 / 0.0169
[0/5][1200/1583] Loss_D: 0.2569 Loss_G: 4.2945 D(x): 0.9455 D(G(z)): 0.1528 / 0.0255
[0/5][1250/1583] Loss_D: 0.4921 Loss_G: 3.2500 D(x): 0.8152 D(G(z)): 0.1892 / 0.0753
[0/5][1300/1583] Loss_D: 0.4068 Loss_G: 3.7702 D(x): 0.8153 D(G(z)): 0.1335 / 0.0472
[0/5][1350/1583] Loss_D: 1.1704 Loss_G: 7.3408 D(x): 0.9443 D(G(z)): 0.5863 / 0.0022
[0/5][1400/1583] Loss_D: 0.6111 Loss_G: 2.2676 D(x): 0.6714 D(G(z)): 0.0793 / 0.1510
[0/5][1450/1583] Loss_D: 0.7817 Loss_G: 4.0744 D(x): 0.7915 D(G(z)): 0.3573 / 0.0242
[0/5][1500/1583] Loss_D: 0.7177 Loss_G: 1.9253 D(x): 0.5770 D(G(z)): 0.0257 / 0.1909
[0/5][1550/1583] Loss_D: 0.4518 Loss_G: 2.8314 D(x): 0.7991 D(G(z)): 0.1479 / 0.0885
[1/5][0/1583] Loss_D: 0.4267 Loss_G: 4.5150 D(x): 0.8976 D(G(z)): 0.2401 / 0.0196
[1/5][50/1583] Loss_D: 0.5106 Loss_G: 2.7800 D(x): 0.7073 D(G(z)): 0.0663 / 0.0932
[1/5][100/1583] Loss_D: 0.6300 Loss_G: 1.8648 D(x): 0.6557 D(G(z)): 0.0756 / 0.2118
[1/5][150/1583] Loss_D: 1.1727 Loss_G: 5.1536 D(x): 0.8397 D(G(z)): 0.5261 / 0.0125
[1/5][200/1583] Loss_D: 0.4675 Loss_G: 2.9615 D(x): 0.7645 D(G(z)): 0.1400 / 0.0780
[1/5][250/1583] Loss_D: 0.7938 Loss_G: 3.1614 D(x): 0.6958 D(G(z)): 0.2248 / 0.0678
[1/5][300/1583] Loss_D: 0.9869 Loss_G: 5.9243 D(x): 0.9619 D(G(z)): 0.5349 / 0.0063
[1/5][350/1583] Loss_D: 0.5178 Loss_G: 3.0236 D(x): 0.7795 D(G(z)): 0.1769 / 0.0700
[1/5][400/1583] Loss_D: 1.4509 Loss_G: 2.7187 D(x): 0.3278 D(G(z)): 0.0133 / 0.1273
[1/5][450/1583] Loss_D: 0.5530 Loss_G: 4.8110 D(x): 0.9151 D(G(z)): 0.3237 / 0.0160
[1/5][500/1583] Loss_D: 0.4621 Loss_G: 4.1158 D(x): 0.8720 D(G(z)): 0.2278 / 0.0293
[1/5][550/1583] Loss_D: 0.4987 Loss_G: 4.0199 D(x): 0.8533 D(G(z)): 0.2367 / 0.0287
[1/5][600/1583] Loss_D: 1.0630 Loss_G: 4.6502 D(x): 0.9145 D(G(z)): 0.5018 / 0.0218
[1/5][650/1583] Loss_D: 0.6081 Loss_G: 4.3172 D(x): 0.8670 D(G(z)): 0.3312 / 0.0221
[1/5][700/1583] Loss_D: 0.4703 Loss_G: 2.4900 D(x): 0.7538 D(G(z)): 0.1245 / 0.1188
[1/5][750/1583] Loss_D: 0.4827 Loss_G: 2.2941 D(x): 0.7372 D(G(z)): 0.1105 / 0.1300
[1/5][800/1583] Loss_D: 0.4013 Loss_G: 3.8850 D(x): 0.8895 D(G(z)): 0.2179 / 0.0324
[1/5][850/1583] Loss_D: 0.7245 Loss_G: 1.9088 D(x): 0.6100 D(G(z)): 0.0950 / 0.1898
[1/5][900/1583] Loss_D: 0.8372 Loss_G: 1.2346 D(x): 0.5232 D(G(z)): 0.0332 / 0.3633
[1/5][950/1583] Loss_D: 0.5561 Loss_G: 3.2048 D(x): 0.7660 D(G(z)): 0.2035 / 0.0594
[1/5][1000/1583] Loss_D: 0.6859 Loss_G: 1.6347 D(x): 0.5764 D(G(z)): 0.0435 / 0.2540
[1/5][1050/1583] Loss_D: 0.6785 Loss_G: 4.3244 D(x): 0.9066 D(G(z)): 0.3835 / 0.0203
[1/5][1100/1583] Loss_D: 0.4835 Loss_G: 2.4080 D(x): 0.7428 D(G(z)): 0.1073 / 0.1147
[1/5][1150/1583] Loss_D: 0.5507 Loss_G: 2.5400 D(x): 0.7857 D(G(z)): 0.2182 / 0.1092
[1/5][1200/1583] Loss_D: 0.6054 Loss_G: 3.4802 D(x): 0.8263 D(G(z)): 0.2934 / 0.0441
[1/5][1250/1583] Loss_D: 0.4788 Loss_G: 2.3533 D(x): 0.7872 D(G(z)): 0.1698 / 0.1327
[1/5][1300/1583] Loss_D: 0.5314 Loss_G: 2.7018 D(x): 0.8273 D(G(z)): 0.2423 / 0.0921
[1/5][1350/1583] Loss_D: 0.8579 Loss_G: 4.6214 D(x): 0.9623 D(G(z)): 0.5089 / 0.0159
[1/5][1400/1583] Loss_D: 0.4919 Loss_G: 2.7656 D(x): 0.8122 D(G(z)): 0.2147 / 0.0864
[1/5][1450/1583] Loss_D: 0.4461 Loss_G: 3.0576 D(x): 0.8042 D(G(z)): 0.1798 / 0.0619
[1/5][1500/1583] Loss_D: 0.7182 Loss_G: 3.7270 D(x): 0.8553 D(G(z)): 0.3713 / 0.0382
[1/5][1550/1583] Loss_D: 0.6378 Loss_G: 3.7489 D(x): 0.8757 D(G(z)): 0.3523 / 0.0317
[2/5][0/1583] Loss_D: 0.3965 Loss_G: 2.6262 D(x): 0.7941 D(G(z)): 0.1247 / 0.0963
[2/5][50/1583] Loss_D: 0.6504 Loss_G: 3.9890 D(x): 0.9267 D(G(z)): 0.3865 / 0.0275
[2/5][100/1583] Loss_D: 0.6523 Loss_G: 3.8724 D(x): 0.8707 D(G(z)): 0.3613 / 0.0299
[2/5][150/1583] Loss_D: 0.7685 Loss_G: 3.9059 D(x): 0.9361 D(G(z)): 0.4534 / 0.0278
[2/5][200/1583] Loss_D: 0.6587 Loss_G: 1.9218 D(x): 0.6469 D(G(z)): 0.1291 / 0.1888
[2/5][250/1583] Loss_D: 0.6971 Loss_G: 2.2256 D(x): 0.6208 D(G(z)): 0.1226 / 0.1465
[2/5][300/1583] Loss_D: 0.5797 Loss_G: 2.4846 D(x): 0.7762 D(G(z)): 0.2434 / 0.1098
[2/5][350/1583] Loss_D: 0.4674 Loss_G: 1.8800 D(x): 0.8045 D(G(z)): 0.1903 / 0.1877
[2/5][400/1583] Loss_D: 0.6462 Loss_G: 1.9510 D(x): 0.7018 D(G(z)): 0.1935 / 0.1792
[2/5][450/1583] Loss_D: 0.9817 Loss_G: 4.2519 D(x): 0.9421 D(G(z)): 0.5381 / 0.0233
[2/5][500/1583] Loss_D: 0.7721 Loss_G: 1.0928 D(x): 0.5402 D(G(z)): 0.0316 / 0.3927
[2/5][550/1583] Loss_D: 0.6037 Loss_G: 2.6914 D(x): 0.7719 D(G(z)): 0.2504 / 0.0896
[2/5][600/1583] Loss_D: 1.4213 Loss_G: 5.4727 D(x): 0.9408 D(G(z)): 0.6792 / 0.0064
[2/5][650/1583] Loss_D: 0.7246 Loss_G: 1.7030 D(x): 0.6716 D(G(z)): 0.2184 / 0.2246
[2/5][700/1583] Loss_D: 0.6642 Loss_G: 3.3809 D(x): 0.8554 D(G(z)): 0.3438 / 0.0591
[2/5][750/1583] Loss_D: 0.6649 Loss_G: 2.0197 D(x): 0.7169 D(G(z)): 0.2333 / 0.1565
[2/5][800/1583] Loss_D: 0.4594 Loss_G: 2.6623 D(x): 0.8150 D(G(z)): 0.1930 / 0.0944
[2/5][850/1583] Loss_D: 1.1957 Loss_G: 3.1871 D(x): 0.7790 D(G(z)): 0.5576 / 0.0568
[2/5][900/1583] Loss_D: 0.6657 Loss_G: 1.5311 D(x): 0.7092 D(G(z)): 0.2122 / 0.2558
[2/5][950/1583] Loss_D: 0.6795 Loss_G: 1.4149 D(x): 0.6134 D(G(z)): 0.1195 / 0.2937
[2/5][1000/1583] Loss_D: 0.5995 Loss_G: 2.1744 D(x): 0.7325 D(G(z)): 0.2054 / 0.1484
[2/5][1050/1583] Loss_D: 0.6706 Loss_G: 1.6705 D(x): 0.6425 D(G(z)): 0.1414 / 0.2310
[2/5][1100/1583] Loss_D: 1.2840 Loss_G: 4.4620 D(x): 0.9736 D(G(z)): 0.6601 / 0.0225
[2/5][1150/1583] Loss_D: 0.7568 Loss_G: 3.1238 D(x): 0.8153 D(G(z)): 0.3717 / 0.0581
[2/5][1200/1583] Loss_D: 0.6331 Loss_G: 1.9048 D(x): 0.6799 D(G(z)): 0.1604 / 0.1814
[2/5][1250/1583] Loss_D: 0.5802 Loss_G: 2.4358 D(x): 0.7561 D(G(z)): 0.2194 / 0.1095
[2/5][1300/1583] Loss_D: 0.9613 Loss_G: 2.3290 D(x): 0.7463 D(G(z)): 0.3952 / 0.1349
[2/5][1350/1583] Loss_D: 0.5367 Loss_G: 1.7398 D(x): 0.7580 D(G(z)): 0.1898 / 0.2216
[2/5][1400/1583] Loss_D: 0.7762 Loss_G: 3.6246 D(x): 0.9006 D(G(z)): 0.4378 / 0.0364
[2/5][1450/1583] Loss_D: 0.7183 Loss_G: 4.0442 D(x): 0.8602 D(G(z)): 0.3857 / 0.0254
[2/5][1500/1583] Loss_D: 0.5416 Loss_G: 2.0642 D(x): 0.7393 D(G(z)): 0.1758 / 0.1532
[2/5][1550/1583] Loss_D: 0.5295 Loss_G: 1.7855 D(x): 0.6768 D(G(z)): 0.0886 / 0.2154
[3/5][0/1583] Loss_D: 0.8635 Loss_G: 1.7508 D(x): 0.4918 D(G(z)): 0.0280 / 0.2154
[3/5][50/1583] Loss_D: 0.8697 Loss_G: 0.7859 D(x): 0.5216 D(G(z)): 0.1124 / 0.4941
[3/5][100/1583] Loss_D: 0.8607 Loss_G: 4.5255 D(x): 0.9197 D(G(z)): 0.4973 / 0.0157
[3/5][150/1583] Loss_D: 0.4805 Loss_G: 2.3071 D(x): 0.7743 D(G(z)): 0.1742 / 0.1291
[3/5][200/1583] Loss_D: 0.4925 Loss_G: 2.6018 D(x): 0.7907 D(G(z)): 0.1970 / 0.0948
[3/5][250/1583] Loss_D: 0.7870 Loss_G: 3.3529 D(x): 0.8408 D(G(z)): 0.4050 / 0.0469
[3/5][300/1583] Loss_D: 0.5479 Loss_G: 1.7376 D(x): 0.7216 D(G(z)): 0.1592 / 0.2227
[3/5][350/1583] Loss_D: 0.8117 Loss_G: 3.4145 D(x): 0.9076 D(G(z)): 0.4685 / 0.0437
[3/5][400/1583] Loss_D: 0.4210 Loss_G: 2.3880 D(x): 0.7543 D(G(z)): 0.1047 / 0.1217
[3/5][450/1583] Loss_D: 1.5745 Loss_G: 0.2366 D(x): 0.2747 D(G(z)): 0.0361 / 0.8096
[3/5][500/1583] Loss_D: 0.7196 Loss_G: 2.1319 D(x): 0.7332 D(G(z)): 0.2935 / 0.1403
[3/5][550/1583] Loss_D: 0.5697 Loss_G: 2.6649 D(x): 0.8816 D(G(z)): 0.3210 / 0.0917
[3/5][600/1583] Loss_D: 0.7779 Loss_G: 1.2727 D(x): 0.5540 D(G(z)): 0.0855 / 0.3412
[3/5][650/1583] Loss_D: 0.4090 Loss_G: 2.6893 D(x): 0.8334 D(G(z)): 0.1835 / 0.0855
[3/5][700/1583] Loss_D: 0.8108 Loss_G: 3.8991 D(x): 0.9241 D(G(z)): 0.4716 / 0.0281
[3/5][750/1583] Loss_D: 0.9907 Loss_G: 4.7885 D(x): 0.9111 D(G(z)): 0.5402 / 0.0123
[3/5][800/1583] Loss_D: 0.4725 Loss_G: 2.3347 D(x): 0.7577 D(G(z)): 0.1400 / 0.1222
[3/5][850/1583] Loss_D: 1.5580 Loss_G: 4.9586 D(x): 0.8954 D(G(z)): 0.7085 / 0.0132
[3/5][900/1583] Loss_D: 0.5785 Loss_G: 1.6395 D(x): 0.6581 D(G(z)): 0.1003 / 0.2411
[3/5][950/1583] Loss_D: 0.6592 Loss_G: 1.0890 D(x): 0.5893 D(G(z)): 0.0451 / 0.3809
[3/5][1000/1583] Loss_D: 0.7280 Loss_G: 3.5368 D(x): 0.8898 D(G(z)): 0.4176 / 0.0409
[3/5][1050/1583] Loss_D: 0.7088 Loss_G: 3.4301 D(x): 0.8558 D(G(z)): 0.3845 / 0.0457
[3/5][1100/1583] Loss_D: 0.5651 Loss_G: 2.1150 D(x): 0.7602 D(G(z)): 0.2127 / 0.1532
[3/5][1150/1583] Loss_D: 0.5412 Loss_G: 1.7790 D(x): 0.6602 D(G(z)): 0.0801 / 0.2088
[3/5][1200/1583] Loss_D: 1.2277 Loss_G: 1.1464 D(x): 0.4864 D(G(z)): 0.2915 / 0.3665
[3/5][1250/1583] Loss_D: 0.7148 Loss_G: 1.3957 D(x): 0.5948 D(G(z)): 0.1076 / 0.2876
[3/5][1300/1583] Loss_D: 1.0675 Loss_G: 1.3018 D(x): 0.4056 D(G(z)): 0.0310 / 0.3355
[3/5][1350/1583] Loss_D: 0.8064 Loss_G: 0.7482 D(x): 0.5846 D(G(z)): 0.1453 / 0.5147
[3/5][1400/1583] Loss_D: 0.6032 Loss_G: 3.0601 D(x): 0.8474 D(G(z)): 0.3189 / 0.0590
[3/5][1450/1583] Loss_D: 0.5329 Loss_G: 2.8172 D(x): 0.8234 D(G(z)): 0.2567 / 0.0795
[3/5][1500/1583] Loss_D: 0.9292 Loss_G: 3.5544 D(x): 0.8686 D(G(z)): 0.4887 / 0.0410
[3/5][1550/1583] Loss_D: 0.5929 Loss_G: 2.9118 D(x): 0.8614 D(G(z)): 0.3239 / 0.0702
[4/5][0/1583] Loss_D: 0.5564 Loss_G: 2.7516 D(x): 0.8716 D(G(z)): 0.3145 / 0.0799
[4/5][50/1583] Loss_D: 1.0485 Loss_G: 0.6751 D(x): 0.4332 D(G(z)): 0.0675 / 0.5568
[4/5][100/1583] Loss_D: 0.6753 Loss_G: 1.4046 D(x): 0.6028 D(G(z)): 0.0882 / 0.2901
[4/5][150/1583] Loss_D: 0.5946 Loss_G: 1.7618 D(x): 0.6862 D(G(z)): 0.1488 / 0.2016
[4/5][200/1583] Loss_D: 0.4866 Loss_G: 2.2638 D(x): 0.7628 D(G(z)): 0.1633 / 0.1321
[4/5][250/1583] Loss_D: 0.7493 Loss_G: 1.0999 D(x): 0.5541 D(G(z)): 0.0659 / 0.3787
[4/5][300/1583] Loss_D: 1.0886 Loss_G: 4.6532 D(x): 0.9370 D(G(z)): 0.5811 / 0.0149
[4/5][350/1583] Loss_D: 0.6106 Loss_G: 1.9212 D(x): 0.6594 D(G(z)): 0.1322 / 0.1825
[4/5][400/1583] Loss_D: 0.5226 Loss_G: 2.9611 D(x): 0.8178 D(G(z)): 0.2378 / 0.0731
[4/5][450/1583] Loss_D: 1.0068 Loss_G: 1.3267 D(x): 0.4310 D(G(z)): 0.0375 / 0.3179
[4/5][500/1583] Loss_D: 3.1088 Loss_G: 0.1269 D(x): 0.0706 D(G(z)): 0.0061 / 0.8897
[4/5][550/1583] Loss_D: 1.7889 Loss_G: 0.4800 D(x): 0.2175 D(G(z)): 0.0143 / 0.6479
[4/5][600/1583] Loss_D: 0.6732 Loss_G: 3.5685 D(x): 0.8775 D(G(z)): 0.3879 / 0.0362
[4/5][650/1583] Loss_D: 0.5169 Loss_G: 2.1943 D(x): 0.7222 D(G(z)): 0.1349 / 0.1416
[4/5][700/1583] Loss_D: 0.4567 Loss_G: 2.4442 D(x): 0.7666 D(G(z)): 0.1410 / 0.1204
[4/5][750/1583] Loss_D: 0.5972 Loss_G: 2.2992 D(x): 0.6286 D(G(z)): 0.0670 / 0.1283
[4/5][800/1583] Loss_D: 0.5461 Loss_G: 1.9777 D(x): 0.7013 D(G(z)): 0.1318 / 0.1795
[4/5][850/1583] Loss_D: 0.6317 Loss_G: 2.2345 D(x): 0.6962 D(G(z)): 0.1854 / 0.1385
[4/5][900/1583] Loss_D: 0.6034 Loss_G: 3.2300 D(x): 0.8781 D(G(z)): 0.3448 / 0.0517
[4/5][950/1583] Loss_D: 0.6371 Loss_G: 2.7755 D(x): 0.8595 D(G(z)): 0.3357 / 0.0826
[4/5][1000/1583] Loss_D: 0.6077 Loss_G: 3.3958 D(x): 0.9026 D(G(z)): 0.3604 / 0.0458
[4/5][1050/1583] Loss_D: 0.5057 Loss_G: 3.2545 D(x): 0.8705 D(G(z)): 0.2691 / 0.0546
[4/5][1100/1583] Loss_D: 0.4552 Loss_G: 2.0632 D(x): 0.7887 D(G(z)): 0.1704 / 0.1524
[4/5][1150/1583] Loss_D: 0.9933 Loss_G: 1.0264 D(x): 0.4507 D(G(z)): 0.0636 / 0.4182
[4/5][1200/1583] Loss_D: 0.5037 Loss_G: 1.9940 D(x): 0.6967 D(G(z)): 0.0959 / 0.1698
[4/5][1250/1583] Loss_D: 0.4760 Loss_G: 2.5973 D(x): 0.8192 D(G(z)): 0.2164 / 0.0945
[4/5][1300/1583] Loss_D: 1.0137 Loss_G: 3.8782 D(x): 0.9330 D(G(z)): 0.5405 / 0.0309
[4/5][1350/1583] Loss_D: 0.9084 Loss_G: 3.1406 D(x): 0.7540 D(G(z)): 0.3980 / 0.0648
[4/5][1400/1583] Loss_D: 0.6724 Loss_G: 4.1269 D(x): 0.9536 D(G(z)): 0.4234 / 0.0236
[4/5][1450/1583] Loss_D: 0.6452 Loss_G: 3.5163 D(x): 0.8730 D(G(z)): 0.3555 / 0.0412
[4/5][1500/1583] Loss_D: 0.8843 Loss_G: 1.4950 D(x): 0.5314 D(G(z)): 0.1035 / 0.2835
[4/5][1550/1583] Loss_D: 2.3345 Loss_G: 1.0675 D(x): 0.1448 D(G(z)): 0.0228 / 0.4177
结果 ¶
最后，让我们看看我们做得如何。在这里，我们将查看三个不同的结果。首先，我们将看到 D 和 G’s 损失在训练期间如何变化。其次，我们将可视化每个时期固定 _noise batch 上的 G’s 输出。第三，我们将查看一批真实数据以及来自 G 的一批假数据。
损失与训练迭代
下面是 D & G’s 损失与训练迭代的关系图。
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’s 进展的可视化
请记住我们如何在每个训练周期之后将生成器’s 的输出保存在固定_noise 批次上。现在，我们可以用动画可视化 G 的训练进度。按播放按钮开始动画。
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())
function isInternetExplorer() { ua = navigator.userAgent; / MSIE 用于检测旧浏览器，Trident 用于检测新浏览器/ return ua.indexOf("MSIE ") > - 1 || ua.indexOf("Trident/") > -1; }
/ 定义动画类 / function Animation(frames, img_id, slider_id, Interval ,loop_select_id){ this.img_id = img_id; this.slider_id = slider_id; this.loop_select_id =循环_select_id; this.interval = 间隔; this.current_frame = 0; this.direction = 0; this.timer = null; this.frames = new Array(frames.length);
for (var i=0; i<frames.length; i++) { this.frames[i] = new Image(); this.frames[i ].src =frames[i]; } var slider = document.getElementById(this.slider_id); slider.max = this.frames.length - 1; if (isInternetExplorer() ) { //从 oninput 切换到 onchange，因为 IE <= 11 不符合 //W3C 规范。它忽略 oninput，而 onchange 的行为 //与 oninput 类似。相比之下，Microsoft Edge 行为正确。 slider.setAttribute('onchange', slider.getAttribute('oninput')); slider.setAttribute('oninput', null); } this.set_frame(this.current_frame); }
Animation.prototype.get_loop_state = function(){ var button_group = document[ this.loop_select_id].state; for (var i = 0; i < 按钮_group.length; i++) { var button = 按钮_group[i]; if (button.checked) { return button.value; } } return undefined; }
Animation.prototype.set_frame = function(frame){ this.current _frame =frame; document.getElementById(this.img_id).src = this.frames[this.current_frame].src; document.getElementById(this.slider_id) ).value = this.current_frame; }
Animation.prototype.next_frame = function() { this.set_frame(Math.min(this.frames. length - 1, this.current_frame + 1)); }
Animation.prototype.previous_frame = function() { this.set_frame(Math.max( 0, this.current_frame - 1)); }
Animation.prototype.first_frame = function() { this.set_frame(0); }
Animation.prototype.last_frame = function() { this.set_frame(this.frames.length - 1); }
Animation.prototype.slower = function() { this.interval /= 0.7; if(this.direction > 0){this.play_animation();} else if(this.direction < 0){this. verse_animation();} }
Animation.prototype.faster = function() { this.interval *= 0.7; if(this.direction > 0){this.play_animation();} else if(this.direction < 0){this.reverse_animation();} }
Animation.prototype.anim_step_forward = function() { this.current_frame += 1; if(this.current_frame < this.frames.length){ this.set_frame(this.current\ _frame); }else{ var Loop_state = this.get_loop_state(); if(loop_state == "loop"){ this.first\ _frame(); }else if(loop_state == "reflect"){ this.last_frame(); this.reverse_animation(); }else{ this.pause_animation(); this.last_frame(); } } }
Animation.prototype.anim_step_reverse = function() { this.current_frame -= 1; if(this.current_frame >= 0){ this.set_frame(this.current_frame); }else{ var Loop_state = this.get_loop_state(); if(loop_state == "loop"){ this.last_frame(); }else if(loop_state == "reflect"){ this.first_frame(); this.play_animation(); }else{ this.pause_animation() ; this.first_frame(); } } }
Animation.prototype.pause_animation = function() { this.direction = 0; if (this.timer){ clearInterval(this.timer); this.timer = null; } }
Animation.prototype.play_animation = function() {\ n this.pause_animation(); this.direction = 1; var t = this; if (!this.timer) this.timer = setInterval(function() { t.anim\ _step_forward(); }, this.interval); }
Animation.prototype.reverse_animation = function() { this.pause_animation(); this.direction = -1; var t = this; if (!this.timer) this.timer = setInterval(function() { t.anim_step_reverse();\ n }, this.interval); }
.animation { 显示：内联块； 文本对齐：中心； } input[type=range].anim-slider { 宽度: 374px; 左边距: 自动; 右边距: 自动; } .anim-buttons { 边距: 8px 0px; } .anim-buttons 按钮{ 内边距: 0; 宽度: 36px; } .anim-state 标签 { 右边距: 8px; } .anim-state 输入 { margin: 0;\ n 垂直对齐: 中间; }
一次
循环
反映
/ Instantiate the Animation class. / / The IDs given should match those used in the template above. / (function() { var img_id = "_anim_imgf3d9a3e6c6dc4159bf77d1add7713e04"; var slider_id = "_anim_sliderf3d9a3e6c6dc4159bf77d1add7713e04"; var loop_select_id = "_anim_loop_selectf3d9a3e6c6dc4159bf77d1add7713e04"; var frames = new Array(17);