羊村懒王

这个屌丝很懒，什么也没留下！

热门标签

PyTorch教程之DCGAN_pytorch tutorials dcgan

作者：羊村懒王 | 2024-06-13 06:26:08

踩

pytorch tutorials dcgan

原文连接：DCGAN TUTORIAL

简介

本教程通过例程来介绍 DCGANs 。我们使用名人照片来训练 GAN 网络使其能够生成新的名人。这里使用的大部分代码都来自pytorch/examples，本篇教程会出该实现的详细介绍，并解释此模型为什么有效。不用担心，此教程不需要提前拥有 GAN 的相关知识，但是对第一个接触 GAN网络的人来说需要更多的时间来理解网络中究竟发生了什么。当然，为了节省时间，最好有一个或两个GPU来开始此教程。

Generative Adversarial Networks

什么是GAN

GANs是一种训练深度学习模型学习数据分布规律的框架，我们可以通过学习到的分布来生成新的数据。GANs是由Goodfellow在2014年提出，并且在Generative Adversarial Nets 进行了介绍。GAN 由两个完全不同的模型组成，一个生成器，一个判别器。生成器的作用是产生和训练样本类似的 “假”（fake）图片，判别器的工作是判别图片是来自训练集的真图片(real)还是来自生成器的假图片(fake)。在训练的过程中，生成器不断地使自己生成的假图片更接近真图片以便能够欺骗判别器，而判别器也不断提高自己的识别能力。这场博弈游戏的平衡情况是，当生成器生成的数据和训练数据足够相似，判别器以50%左右的置信度判别样本是真是假。

现在我们来说明在教程中将会用到的一些符号。 $x$ 表示一张图片， $D (x)$ 表示 $x$ 来自训练集的概率，为判别器的输出。判别器的输入为 3x64x64 的图片。易知，当 $x$ 来自训练集时输出概率高，当 $x$ 来自生成器时，输入低。 $D (x)$ 也可视为传统的二元分类器。

对生成器来说，输入 $z$ 为来自标准正太分布的向量， $G (z)$ 使输入 $z$ 映射到样本图像空间，为生成器的输出。

所以， $D (G (z))$ 表示生成器生成图片为真(real)的概率。在 Goodfellow的论文Generative Adversarial Nets中，D和G相互博弈，D 努力提高自己判别图像真假的能力，G 努力降低其生成的图片被识别为假的概率 $(l o g (1 - D (G (Z))))$ ，论文中给出了 GAN 网络的损失函数如下： $\mathop{min} \limits_G\mathop{max} \limits_ D V(G,D) = E_{x∼pdata(x)}[logD(x)]+E_{z∼pz(z)}[log(1−D(G(x)))]$ 理论上来说，此博弈的平衡点为 $P_g = P_data$ ,这时判别器无法分辨输入的真假。然而，由于GAN 网络的收敛问题，实际训练时并不总是训练到这个位置。

什么是DCGAN

DCGAN是在GAN上进行的扩展，唯一的区别就是生成器和判别器分别使用转置卷积层和卷积层。在论文Unsupervised Representation Learning With Deep Convolutional Generative Adversarial Networks中提出。判别器由 strided convolution layers, batch norm layers, 和 LeakyReLU 激活层构成。输入为 3x64x64的图片，输出为此图片来自真样本的概率。判别器由转置卷积层，batch norm layers, 和 ReLU 激活层构成。输入是取样自标准正态分布的随机向量 $z$ ，输出是 3x64x64的RGB图片。在论文中，作者给出了设置优化器的一些窍门，计算损失函数的方法，以及怎样初始化模型的参数，这些我们都会在接下来的部分进行介绍。

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)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25

Out:

Random Seed:  999
1

输入

下面是程序运行中的输入信息：

dataroot - 数据集的根目录，后面数据集部分会有详细讨论
workers - 使用DataLoader 加载数据的线程数
batch_size - 每个batch中的图片数量，论文中为128
image_size - 图片的分辨率，默认为64x64。如果使用了其它尺寸，需要更改判别器与生成器的结构。可参考详细操作
nc - 输入图片的色彩通道，对彩色图片来说为 3
nz - 生成器的输入 $z$ 的维度
ngf - 生成器特征图的深度
ndf - 判别器特征图的深度
num_epochs - 训练的轮数
lr - 训练的 learning rate。论文中取值为0.0002
beta1 - Adam optimizers 的超参beta1。论文中取值为 0.5
ngpu - 使用的gpu个数，若为0表示使用cpu模式。

# 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
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36

数据

此教程中我们使用Celeb-A Faces dataset, 也可以通过百度云盘下载。我们下载其中的 img_align_celeba.zip。下载之后，创建名为 celeba 的文件夹，将压缩文件解压至此文件夹。然后，设置 dataroot 为你刚刚建立的celeba路径。最终的文件结构如下：

/path/to/celeba
    -> img_align_celeba
        -> 188242.jpg
        -> 173822.jpg
        -> 284702.jpg
        -> 537394.jpg
           ...
1
2
3
4
5
6
7

这是一个重要的步骤，因为我们后面用到的 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)),
                           ]))
                       
# creat the dataloader
dataloader = torch.utils.data.DataLoader(dataset, batch_size=batch_size,
	shuffle=True, num_workers=workers)

# device which device we want to run on
divice = 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)))
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24

Out:

部署

在完成数据集的准备与超参设置工作后，我们现在开始网络的部署。我们将逐步介绍权重初始化，生成器，判别器，损失函数，训练过程的实现细节。

权重初始化

在DCGAN的论文中，作者指明所有的权重都以均值为0，标准差为0.2的正态分布随机初始化。weights_init 函数读取一个已初始化的模型并重新初始化卷积层，转置卷积层，batch normalization 层。这个函数在模型初始化之后使用。

# 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)
1
2
3
4
5
6
7
8

生成器

生成器的目的是将输入向量 $z$ 映射到真的数据空间。这儿我们的数据为图片，意味着我们需要将输入向量 $z$ 转换为 3x64x64的RGB图像。实际操作时，我们通过一系列的二维转置卷，每次转置卷积后跟一个二维的batch norm层和一个relu激活层。生成器的输出接入 $t a n h$ 函数以便满足输出范围为 $[- 1, 1]$ 。值得一提的是，每个转置卷积后面跟一个 batch norm 层，是DCGAN论文的一个主要贡献。这些网络层有助于训练时的梯度计算。整个过程如下图所示。

需要注意的是，上面我们设置的参数(nz, ngf, nc)会直接影响到生成器的结构。 nz是输入向量 $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)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31

现在我们可以实例化生成器并调用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.2.
netG.apply(weights_init)

# Print the model
print(netG)
1
2
3
4
5
6
7
8
9
10
11
12
13

out:

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()
  )
)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18

判别器

上面已经提到了，判别器是一个二元分类器（ binary classification）输出图片为真的概率。这儿，D的输入为 3x64x64 的图片，依次通过卷继层，BN层，LeakyReLU层，然后通过sigmoid激活函数输出图片为真的概率，可根据具体的情况改变判别器的具体结构。但是其中使用的 strided卷积层，BN层，LeakyReLUs层是必要的。DCGAN的论文提到，使用strided卷积比池化层具有更好的下采样效果，因为strided卷积让网络学习到了自己的池化函数（而非固定的池化函数）。而且BN层和leaky relu层使得梯度传播更加高效，这对判别器和生成器的学习过程很有帮助。
判别器代码：

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)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27

和上面一样，现在实例化判别器并输出网络结构。

# 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)
1
2
3
4
5
6
7
8
9
10
11
12
13

out:

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()
  )
)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

损失函数及优化器

通过以下的设置，我们可以了解到整个优化的过程。我们使用二元交叉熵损失(BCELoss) ，其定义如下： $l(x,y)=L= \{ l_1,...l_N \}^T , l_n= -[y_n·logx_n+(1-y_n)·log(1-x_n)]$ 观察此函数，就能发现对于正例( $y_n=1$ ) $1-y_n)·log(1-x_n)$ 为0， $y_n·logx_n$ 起作用。反例时加号后面部分起作用，前面为零。
接下来我们定义真图片标签为1，假图片标签为0。这些标签在计算损失函数时会用到，这也是GAN原论文中用到的方法。在DCGAN论文中使用Adam优化器，学习率设置为 0.0002， $B e t a 1 = 0.5$ ,为了追踪生成器的学习过程，我们生成改进后的高斯分布向量(i.e. fixed_noise)。在训练过程中，我们将改进的随机向量输入生成器，经过迭代之后，我们可以看到由噪声生成的图片。

# 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))
1
2
3
4
5
6
7
8
9
10
11
12
13
14

训练

至此，我们完成了GAN网络各个模块的定义，现在我们可以开始进行训练。需要注意的是，GAN的训练需要很细心，超参的一点不正确的设置都可能导致整个模型的崩溃，然而我们却不能解释导致模型崩溃的具体原因。在这里，我们将密切关注Goodfellow论文中的算法，同时遵守 ganhacks 中展示的一些最佳实践。也就是说，我们将为 "real"和"fake"图片使用不一样的mini-batch。同时调整生成器的目标函数使 $l o g D (G (Z))$ 最大。训练可以分为两个主要的部分。1.更新判别器 2.更新生成器

第一部分—更新判别器

前面已经说到，训练判别器的目的是为了提高识别真假图片的正确率。我们通过随机梯度下降法来更新判别器。实际中我们通过最大化 $l o g (D (x)) + l o g (1 - D (G (z)))$ 来训练模型。根据 ganhacks 中的建议，我们的训练分为两个步骤。搜先，我们从真样本中抽取一个batch的图片输入判别器 D ，计算损失 $l o g (D (x))$ ，然后反向传播计算梯度。第二步，我们在假样本（生成的样本）中抽取一个 batch的图片输入判别器D，计算损失 $l o g (1 - D (G (z)))$ ，然后反向传播计算梯度。两个步骤完成之后，把真假样本计算的梯度累积，做一步优化。

第二部分—更新生成器

论文中提到，我们通过最小化 $l o g (1 - D (G (z)))$ 来训练生成器以便能生成更好的假样本。如上所述，Goodfellow表明这不能提供足够的梯度，尤其是在训练的初始阶段，所以我们通过采用最大化 $l o g (D (G (z)))$ 来进行训练。在代码实现中，我们使用第一部分中的判别器来判别生成器的输出，。。。。。。

最后，我们会在每一轮epoch后做一次统计报告，我们会展示输入噪声通过生成器的过程，以便观察生成器训练的轨迹。统计报告包括以下部分：

Loss_D - 判别器损失，包含真样本和假样本 $l o g (D (x)) + l o g (D (G (z)))$
Loss_G - 生成器损失 $l o g (D (G (z)))$
D(x) - 真样本一个batch的平均输出，理论上此值应该首先接近于1，随着训练接近 0.5
D(G(z)) - 假样本一个batch的平均输出，第一个值产生于 D 更新之前，第二个值产生于 D更新之后。理论上此值开始时接近 0 ，随着训练接近 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, 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
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81

out:

Starting Training Loop...
[0/5][0/1583]   Loss_D: 1.7410  Loss_G: 4.7765  D(x): 0.5343    D(G(z)): 0.5771 / 0.0136
[0/5][50/1583]  Loss_D: 0.2913  Loss_G: 27.3206 D(x): 0.8725    D(G(z)): 0.0000 / 0.0000
[0/5][100/1583] Loss_D: 0.8845  Loss_G: 9.8764  D(x): 0.9949    D(G(z)): 0.4462 / 0.0002
.........
.........
.........
[4/5][1150/1583]        Loss_D: 0.5826  Loss_G: 2.2118  D(x): 0.7190    D(G(z)): 0.1875 / 0.1417
[4/5][1200/1583]        Loss_D: 0.7822  Loss_G: 3.6914  D(x): 0.8733    D(G(z)): 0.4308 / 0.0338
[4/5][1250/1583]        Loss_D: 1.4110  Loss_G: 0.3719  D(x): 0.3172    D(G(z)): 0.0488 / 0.7127
[4/5][1300/1583]        Loss_D: 0.6790  Loss_G: 1.2476  D(x): 0.5989    D(G(z)): 0.0965 / 0.3366
[4/5][1350/1583]        Loss_D: 0.8312  Loss_G: 4.2156  D(x): 0.9318    D(G(z)): 0.4816 / 0.0213
[4/5][1400/1583]        Loss_D: 1.5377  Loss_G: 0.3751  D(x): 0.2823    D(G(z)): 0.0394 / 0.7148
[4/5][1450/1583]        Loss_D: 0.6127  Loss_G: 3.6128  D(x): 0.9081    D(G(z)): 0.3650 / 0.0354
[4/5][1500/1583]        Loss_D: 0.6328  Loss_G: 1.9700  D(x): 0.6545    D(G(z)): 0.1332 / 0.1859
[4/5][1550/1583]        Loss_D: 1.2825  Loss_G: 0.8622  D(x): 0.3590    D(G(z)): 0.0437 / 0.4739
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

结果分析

最后，看一下我们是怎么做到的。我们将会看到三个不同的结果。首先，我们看到的是训练过程中D，G损失是怎么变化的。然后我们观察生成器的输出。最后我们将同时观察真图和生成的图。

训练过程的损失变化

下面代码画出训练过程损失函数的变化过程。

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()
1
2
3
4
5
6
7
8

### 生成器输出前面我们保存了生成器的输出，现在我们用动画的形式来观察结果，按下播放键开始动画。

#%%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())
1
2
3
4
5
6
7

真假图片对照

最后我们对比观察真假图片

# 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()
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

附录

完整代码下载：

声明：本文内容由网友自发贡献，不代表【wpsshop博客】立场，版权归原作者所有，本站不承担相应法律责任。如您发现有侵权的内容，请联系我们。转载请注明出处：https://www.wpsshop.cn/w/羊村懒王/article/detail/711232