文献阅读笔记--GAN--Generative Adversarial NetworkGAN的原始论文-组会讲解

Generative Adversarial Network

作者：Ian Goodfellow
时间：2014年
会议：NIPS 2014
论文地址Arxiv：https://arxiv.org/abs/1406.2661

Basic idea of GAN

生成对抗网络

GAN 主要包括了两个部分，即生成器 generator 与判别器 discriminator。

• 生成器主要用来学习真实图像分布从而让自身生成的图像更加真实，以骗过判别器。
• 判别器则需要对接收的图片进行真假判别。

在整个过程中，生成器努力地让生成的图像更加真实，而判别器则努力地去识别出图像的真假，这个过程相当于一个二人博弈。
随着时间的推移，生成器和判别器在不断地进行对抗，最终两个网络达到了一个动态均衡：生成器生成的图像接近于真实图像分布，而判别器识别不出真假图像，对于给定图像的预测为真的概率基本接近 0.5（相当于随机猜测类别）

公式和原理

目标函数和最大最小

目标函数

从他的framework 我们可以得到GAN的基本思路，一个生成器一个判别器，尝试从中找到最优解（平衡点）
然后，自然想到如何把这个思想转变成真正的模型。
论文中通过给出目标函数和训练过程来描述这个事情，文章中给出了目标函数：

思考如何得到目标函数：
首先我们有一些定义

  data→真实数据（groundtruth）
  pdata→真实数据的分布
  z→噪音（输入数据）
  pz→原始噪音的分布
  pg→经过生成器后的数据分布
  G()→生成映射函数
  D()→判别映射函数
G 是生成器，结构为一个多层感知机，参数为 θg，G(z;θg) 为生成映射函数，将噪音 z 映射到新的数据空间。
D 是判别器，也是一个多层感知机，参数为 θd，D(x;θd) 输出为一个标量，表示 x 来自真实数据data而不是生成数据的概率。

$E(.)$ 表示 标签为正类时的期望函数的log 损失函数。
$$E(p\mid y)=\frac{-1}{N}\sum _{i=1}^N\left(y_i\left(\log p_i\right)+\left(1-y_i\right)\left(1-p_i\right)\right)$$

定义最优化问题的方法由两部分组成。首先我们需要定义一个判别器 D 以判别样本是不是从 $P_{\text{data }}(x)$ 分布中 取出来的, 因此有：
$$E_{x\sim p_{\text{data }}(x)}\log (D(x))$$
其中 E 指代取期望。这一项是根据「正类」 \quad (即辨别出 $\mathrm{x}$ 属于真实数据 data $)$ 的对数损失函数而构建的。最 大化这一项相当于令判别器 D 在 $\mathrm{x}$ 服从于 data 的概率密度时能准确地预测 $\mathrm{D}(\mathrm{x})=1$, 即：
$$D(x)=1\text{ when }x\sim p_{\text{data }}(x)$$
另外一项是企图欺骗判别器的生成器 G。该项根据「负类」的对数损失函数而构建, 即：
$$E_{z\sim p_z(z)}\log (1-D(G(z)))$$
（上述概念中涉及一个模型认知问题：整个GAN看来是一个无监督的问题，分开来看，D部分其实是一个二分类有监督问题。)

分别 得到 鉴别器和生成器的最优表达式之后，我们可以定义目标函数为：

对于 D 而言要尽量使公式最大化 (识别能力强)，而对于 G 又想使之最小 (生成的数据接近实际数据) 。整 个训练是一个迭代过程。其实极小极大化博亦可以分开理解，即在给定 G 的情况下先最大化 $V(D,G)$ 而取 D，然后固定 D, 并最小化 $V(D,G)$ 而得到 G。其中, 给定 G, 最大化 $V(D,G)$ 评估了 $P_g$ 和 $P_{\text{data }}$ 之间 的差异或距离。（同时也是训练算法的描述）
$$D_G^{\ast }=\arg \underset{D}{\max }V(D,G)$$
最后，我们可以将最优化问题表达为：
$$G^{\ast }={\mathrm{argmin}}_{G}V\left(G,D_G^{\ast }\right)$$

最大最小的博弈过程

图中，黑色曲线是真实样本的概率分布函数，绿色曲线是虚假样本的概率分布函数，蓝色曲线是判别器D的输出，它的值越大表示这个样本越有可能是真实样本。最下方的平行线是噪声z，它映射到了x。

我们可以看到，一开始， G(z) 和 x 是在同一个特征空间里的，它们分布的差异很大，这时，虽然鉴别真实样本和虚假样本的模型 D 性能也不强，但它很容易就能把两者区分开来，而随着训练的推进，虚假样本的分布逐渐与真实样本重合，D 虽然也在不断更新，但也已经力不从心了。

最后，黑线和绿线最后几乎重合，模型达到了最优状态，这时 D 的输出对于任意样本都是 0.5。

训练方法

模型按照如图所示的步骤训练。首先固定G，单独训练D，为了让D得到充分训练，有的时候要迭代多次。本论文中每一轮迭代D只训练一次。D训练完毕后，固定D，训练G，如此循环。训练的方式是反向传播算法。
可以注意到，在训练过程中，没有任何求出真实样本的分布或是生成样本的分布的过程。

在每一步的训练中：

1. 取 m 个真实数据，使用 G 和 m 组随机数（一般使用服从正态分布的随机数）生成 m 个假数据
2. 根据 max 部分的目标更新 D 的参数，提高 D 的分辨能力
3. 根据 min 部分的目标更新 G 的参数，使 G 生成的数据更有迷惑性

下面, 我们需要证明：该最优化问题有唯一解 $G^{\ast },$ 并且该唯一解满足 $P_G=P_{\text{data }}$ 。

理论部分-全局最优-命题一

命题一：原文如下图

命题一证明解析：

1. 由目标函数得到$ V(D, G)$的表达式，并把期望改写为积分形式。
   （eg：这里是随机变量函数的期望公式，函数为 $\log D(\mathbf{x})$，而 $x$ 服从的分布为 $p_{\text{data }}(\mathbf{x})$ 所以改写为如图形式）
2. 根据测度论中的 Radon-Nikodym 定理进行变换，得到第二个等号。
   （说明：见备注一，备注二，备注三）
3. 在数据给定, G 给定的前提下, $P_{\text{data }}(x)$ 与 $P_G(x)$ 都可以看作是常数，我们可以分别用 $a,b$ 来表示他们，这样我们就可以得到如下的式子:
   
4. 在满足定理结论中的条件处，达到了最小，证明了第一个条件得到了，给定G的时候，鉴别器所满足的条件。

当然 GAN 过程的目标是令 $P_G=P_{\text{data }。}$ 这对最优的 D 意味着什么呢? 我们可以将这一等式代入 $D_{G\ast }$ 的表达式中：
$$D_G^{\ast }=\frac{p_{\text{data }}}{p_{\text{data }}+p_G}=\frac{1}{2}$$
这意味着判别器已经完全困惑了，它完全分辨不出 $P_{\text{data }}$ 和 $P_G$ 的区别, 即判断样本来自 $P_{\text{data }}$ 和 $P_G$ 的概率都为 $\frac{1}{2}$ 。基于这一观点, GAN 作者证明了 G 就是极小极大博亦的解。该定理如下:

理论部分-全局最优-定理1

定理一证明解析：

由定理 if an only if：
可以看到这是一个充分必要条件，故需要进行双向证明。
首先我们先从反向逼近并证明 $C(G)$ 的取值, 然后再利用由反向获得的新知识从正向证明。设 $P_G=P_{\text{data }}$ (反向指预先知道最优 条件并做推导)，我们可以反向推出
$$V\left(G,D_G^{\ast }\right)={\int }_x{p}_{\text{data }}(x)\log \frac{1}{2}+p_G(x)\log \left(1-\frac{1}{2}\right)\mathrm{d}x$$
and
$$V\left(G,D_G^{\ast }\right)=-\log 2{\int }_x{p}_G(x)\mathrm{d}x-\log 2{\int }_x{p}_{\text{data }}(x)\mathrm{d}x=-2\log 2=-\log 4$$
该值是全局最小值的候选, 因为它只有在 $P_G=P_{\text{data }}$ 的时候才出现。

然后，我们现在需要从正向证明这一个值常常为最小值，也就是同时满足「当」和「仅当」的条件。

现在放弃 $P_G=P_{\text{data }}$ 的假设, 对任意一
个 G，我们可以将上一步求出的最优判别器 $D^{\ast }$ 代入到 $C(G)=\max V(G,D)$ 中:
$$C(G)={\int }_x{p}_{\text{data }}(x)\log \left(\frac{p_{\text{data }}(x)}{p_G(x)+p_{\text{data }}(x)}\right)+p_G(x)\log \left(\frac{p_G(x)}{p_G(x)+p_{\text{data }}(x)}\right)\mathrm{d}x$$

（技巧性的一步：因为已知 -log4 为全局最小候选值，所以我们希望构造某个值以使方程式中出现 log2。因此我们可以在每个积分中加上或减去 log2，并乘上概率密度。这是一个十分常见并且不会改变等式的数学证明技巧，因为本质上我们只是在方程加上了 0。）
$$\begin{array}{rl}C(G)& ={\int }_x(\log 2-\log 2)p_{\text{data }}(x)+p_{\text{data }}(x)\log \left(\frac{p_{\text{data }}(x)}{p_G(x)+p_{\text{data }}(x)}\right)\\ & +(\log 2-\log 2)p_G(x)+p_G(x)\log \left(\frac{p_G(x)}{p_G(x)+p_{\text{data }}(x)}\right)\mathrm{d}x\end{array}$$

采用该技巧主要是希望能够构建成含 log2 和 JS 散度的形式, 上式化简后可以得到以下表达式：
$$\begin{array}{c}C(G)=-\log 2{\int }_x{p}_G(x)+p_{\text{data }}(x)\mathrm{d}x\\ +{\int }_x{p}_{\text{data }}(x)\left(\log 2+\log \left(\frac{p_{\text{data }}(x)}{p_G(x)+p_{\text{data }}(x)}\right)\right)\\ +p_G(x)\left(\log 2+\log \left(\frac{p_G(x)}{p_G(x)+p_{\text{data }}(x)}\right)\right)\mathrm{d}x\end{array}$$
因为概率密度的定义, $P_G$ 和 $P_{\text{data }}$ 在它们积分域上的积分等于 1 , 即：
$$-\log 2{\int }_x{p}_G(x)+p_{\text{data }}(x)\mathrm{d}x=-\log 2(1+1)=-2\log 2=-\log 4$$

此外，根据对数的定义, 我们有:
$$\begin{array}{c}\log 2+\log \left(\frac{p_{\text{data }}(x)}{p_G(x)+p_{\text{data }}(x)}\right)=\log \left(2\frac{p_{\text{data }}(x)}{p_G(x)+p_{\text{data }}(x)}\right)\\ =\log \left(\frac{p_{\text{data }}(x)}{\left(p_G(x)+p_{\text{data }}(x)\right)/2}\right)\end{array}$$
因此代入该等式, 我们可以写为：
$$\begin{array}{rl}C(G)=& -\log 4+{\int }_x{p}_{\text{data }}(x)\log \left(\frac{p_{\text{data }}(x)}{\left(p_G(x)+p_{\text{data }}(x)\right)/2}\right)\mathrm{d}x\\ & +{\int }_x{p}_G(x)\log \left(\frac{p_G(x)}{\left(p_G(x)+p_{\text{data }}(x)\right)/2}\right)\mathrm{d}x\end{array}$$
现在, 如果读者阅读了前文的 KL 散度, 那么我们就会发现每一个积分正好就是它。具体来说：
$$C(G)=-\log 4+KL\left(p_{\text{data }}\mid \frac{p_{\text{data }}+p_G}{2}\right)+KL\left(p_G\mid \frac{p_{\text{data }}+p_G}{2}\right)$$

KL散度是非负的, 所以我们马上就能看出来 -log4 为 $C(G)$ 的全局最小值。 如果我们进一步证明只有一个 G 能达到这一个值, 因为 $P_G=P_{\text{data }}$ 将会成为令 $C(G)=-\log 4$ 的

从前文可知 KL 散度是非对称的, 所以 $C(G)$ 中的 $KL\left(P_{\text{data }}\Vert \left(P_{\text{data }}+P_G\right)/2\right)$ 左右两项是不能交换 的, 但如果同时加上另一项 $KL\left(P_{\text{data }}\Vert \left(P_{\text{data }}+P_G\right)/2\right)$, 它们的和就能变成对称项。这两项 KL 散度 的和即可以表示为 JS 散度（Jenson-Shannon divergence ) :
$$\begin{array}{rl}\mathrm{JSD}(P\Vert Q)=\frac{1}{2}D(P\Vert M)& +\frac{1}{2}D(Q\Vert M)\\ M& =\frac{1}{2}(P+Q)\end{array}$$
假设存在两个分布 P 和 Q, 且这两个分布的平均分布 $M=(P+Q)/2,$ 那么这两个分布之间的 JS 散 度为 P 与 M 之间的 KL散度加上 Q 与 M 之间的 KL 散度再除以 2。 JS 散度的取值为 0 到 log2。若两个分布完全没有交集，那么 JS 散度取最大值 log2; 若两个分布完全一 样, 那么 JS 散度取最小值 0。 因此 $C(G)$ 可以根据 JS 散度的定义改写为：
$$C(G)=-\log 4+2\cdot JSD\left(p_{\text{data }}\mid p_G\right)$$
这一散度其实就是 Jenson-Shannon 距离度量的平方。根据它的属性: 当 $P_G=P_{\text{data }}$ 时, $JSD\left(P_{\text{data }}(x)\Vert P_G(x)\right)$ 为 0 。综上所述, 生成分布当且仅当等于真实数据分布式时, 我们可以取得最 优生成器。
(
)

理论部分-算法收敛-命题二

给定足够的训练数据和正确的环境，训练过程将收敛到最优 G

命题2。如果G和D有足够的能力，在算法1的每一步, 让判别器达到给定的最优G，并更新pg以改进标准。。
${\mathbb{E}}_{\mathbf{x}\sim p_{\text{data }}}\left[\log D_G^{\ast }(\mathbf{x})\right]+{\mathbb{E}}_{\mathbf{x}\sim p_g}\left[\log \left(1-D_G^{\ast }(\mathbf{x})\right)\right]$
然后pg收敘到pdata
证明。将V $(\mathrm{G},\mathrm{D})=\mathrm{U}(\mathrm{p}\mathrm{g},\mathrm{D})$ 视为上述准则中pg的函数。 \quad 注意U $\mathrm{U}(\mathrm{p}\mathrm{g},$ D)在pg中是凸的, 凸函数的上项的子导数 包括函数在最大点处的导数。换句话说, 如果 $f(x)={\sup }_{\alpha \in A}{f}_{\alpha }(x)$ 并且 $f_{\alpha }(x)$ 对每个 $\alpha$ 中的x都是凸的, 如果
G.sup ${}_D\bigcup {\left(P_g,D\right)}_{\text{在pg中凸且有唯一全局最优 }}$ $\beta ={\mathrm{argsup}}_{\alpha \in A}{f}_{\alpha }(x)$ 则 $\alpha f_{\beta }(x)\in \alpha f_{\text{。}}$这相当于在给定对应
值的情况下计算pg在最优D处的梯度下降更新, 已在thm1中证明, 因此在pg更新足够小的情况下，pg收敘于 $\mathrm{p}\mathrm{x},$ 得出证明。
在实践中, 对抗网络通过函数G $(z;\theta g)$ 表示有限的pg分布族;而我们优化的是\thetag而不是pg本身。用多层感知器 定义G引入了参数空间中的多个临界点。然而, 多层感知器在实际应用中的优异性能表明, 尽管其缺乏理论保 障，但仍是一种合理的模型。
参考资料

知识补充

极大似然估计

在这里的关键是，引出，生成器生成分布和真实分布差距衡量的思路，但无法计算，所以，GAN解决了这个问题
https://zhuanlan.zhihu.com/p/266677860
我们根本无法算出 生成器的分布
最后包含，生成器的分布是包含一个 G（z）= x的示性函数，而，GAN 正是由这个思路提出了鉴别器的思路，因为鉴别器在鉴别的就是 生成的时候是x（真实的）

https://blog.csdn.net/stalbo/article/details/79283399

KL散度（KL divergence）

这是统计中的一个概念，是衡量两种概率分布的相似程度，其越小，表示两种概率分布越接近。
离散的：

连续的：

GAN中的应用：
我们想要将一个随机高斯噪声z通过一个生成网络G得到一个和真的数据分布 $P_{\text{data }}(x)$ 差不多的生成 分布 $P_G(x;\theta ),$ 其中的参数 $\theta$ 是网络的参数决定的，我们希望找到 $\theta$ 使得 $P_G(x;\theta )$ 和 $P_{\text{data }}(x)$ 尽可能接近。

注意：KL散度不是距离。因此KL散度不具有交换性，所以不能理解为距离的概念，衡量的并不是两分布在空间中的远近，更准确的理解应该是衡量一个分布比另一个分布的信息损失。

JS散度

JS散度用于衡量两种分布之间的差异，它用在生成对抗网络的数学推到上，克服了KL散度不是距离、不对称的缺点

它的定义如下

$$\mathrm{JSD}(\mathrm{p}\Vert \mathrm{q})=\frac{1}{2}\mathrm{D}(\mathrm{p}\Vert \mathrm{m})+\frac{1}{2}\mathrm{D}(\mathrm{q}\Vert \mathrm{m}),\mathrm{m}=\frac{1}{2}(p+q)$$

总结

关于GAN

本质都是，尝试取衡量 真实分布和生成结果的距离或者相似程度，拟合程度。
其实在GAN之前，就已经有Auto-Encoder，VAE这样的方法来使用神经网络做生成式任务了。

GAN的最大的创新就是在于非常精妙地引入了判别器，从样本的维度解决了衡量两个分布差异的问题。

这种生成器和判别器对抗学习的模式，也必将在各种生成式任务中发挥其巨大的威力。

备注

备注一：

在 GAN 原论文中，有一个思想和其它很多方法都不同，即生成器 G 不需要满足可逆条件。Scott Rome 认为这一点非常重要，因为实践中 G 就是不可逆的。而很多证明笔记都忽略了这一点，他们在证明时错误地使用了积分换元公式，而积分换元却又恰好基于 G 的可逆条件。Scott 认为证明只能基于以下等式的成立性：
$$E_{z\sim p_z(z)}\log (1-D(G(z)))=E_{x\sim p_{G(x)}}\log (1-D(x))$$
该等式来源于测度论中的 Radon-Nikodym 定理。。 有一些证明过程使用了积分换元公式, 但进行积分换元就必须计算 $G^{(-1)}$, 而 G 的逆却并没有假定为存 在。并且在神经网络的实践中，它也并不存在。可能这个方法在机器学习和统计学文献中太常见了, 因 此我们忽略了它。
关于，生成器可逆的问题，思考在备注二。
关于R-N定理的通俗理解，见备注三。

备注二：

根据以下几个观点构成备注二：

1. 普通积分还原公式，要求变换的函数 在$[a,b]$闭区间上可导等条件。
2. 神经网络中，通常不是普通的一元、多元函数，而是矩阵函数。
3. 个人认为，矩阵函数想要进行积分还原公式，需要要求系数矩阵可逆。
4. 结合备注一的结论，G实际中基本上都是不可逆的。举个例子来说明这个问题，GAN的最简单形式中，生成器使用的只是一个简单的多层感知机（见代码）。
5. 同时，多层感知机是一个线性层+激活函数
6. 理论上，线性层+单射的激活函数，就可逆。
7. 但实际情况中，神经网络对应的矩阵（本质就是一个矩阵相乘）不是方阵，所以，实际中，这个过程不可逆。
8. 是奇异阵或者是方阵的时候，无解或者多解。这都是不可逆的。
9. 举一个简单的例子帮助理解：一个行向量和一个列向量相乘得到一个值。我们怎么可能在知道这个值和网络参数的时候得到 输入值呢？
10. 故其实，大多数生成器，包括普通的多层感知机都是不可逆。因为这实在是一个太基本的东西，反而很少见人讨论。
    （ack-天天）

备注三：

学习DL中，我们无需懂得在测度论中如何证明R-N定理（多种证明方法）
可以从直觉上明白一个事情。

R-N定理是一个广义的积分换元定理，无视了可逆条件
顺便可以加深一个概念，GAN积分等式中的，
$p_G(x)$和 $p(z)$ 包括 x，z 就是一种测度。
该定理支持了在满足一定条件下，测度之间变换。

理论部分参考资料：

1. GAN - Intuitive Approach to Mathematics
2. https://blog.csdn.net/stalbo/article/details/79283399

代码

import argparse
import os
import numpy as np
import math

import torchvision.transforms as transforms
from torchvision.utils import save_image

from torch.utils.data import DataLoader
from torchvision import datasets
from torch.autograd import Variable

import torch.nn as nn
import torch.nn.functional as F
import torch

os.makedirs("images", exist_ok=True)

parser = argparse.ArgumentParser()
parser.add_argument("--n_epochs", type=int, default=200, help="number of epochs of training")
parser.add_argument("--batch_size", type=int, default=64, help="size of the batches")
parser.add_argument("--lr", type=float, default=0.0002, help="adam: learning rate")
parser.add_argument("--b1", type=float, default=0.5, help="adam: decay of first order momentum of gradient")
parser.add_argument("--b2", type=float, default=0.999, help="adam: decay of first order momentum of gradient")
parser.add_argument("--n_cpu", type=int, default=8, help="number of cpu threads to use during batch generation")
parser.add_argument("--latent_dim", type=int, default=100, help="dimensionality of the latent space")
parser.add_argument("--img_size", type=int, default=28, help="size of each image dimension")
parser.add_argument("--channels", type=int, default=1, help="number of image channels")
parser.add_argument("--sample_interval", type=int, default=400, help="interval betwen image samples")
opt = parser.parse_args()
print(opt)

img_shape = (opt.channels, opt.img_size, opt.img_size)

cuda = True if torch.cuda.is_available() else False


class Generator(nn.Module):
    def __init__(self):
        super(Generator, self).__init__()

        def block(in_feat, out_feat, normalize=True):
            layers = [nn.Linear(in_feat, out_feat)]
            if normalize:
                layers.append(nn.BatchNorm1d(out_feat, 0.8))
            layers.append(nn.LeakyReLU(0.2, inplace=True))
            return layers

        self.model = nn.Sequential(
            *block(opt.latent_dim, 128, normalize=False),
            *block(128, 256),
            *block(256, 512),
            *block(512, 1024),
            nn.Linear(1024, int(np.prod(img_shape))),
            nn.Tanh()
        )

    def forward(self, z):
        img = self.model(z)
        img = img.view(img.size(0), *img_shape)
        return img


class Discriminator(nn.Module):
    def __init__(self):
        super(Discriminator, self).__init__()

        self.model = nn.Sequential(
            nn.Linear(int(np.prod(img_shape)), 512),
            nn.LeakyReLU(0.2, inplace=True),
            nn.Linear(512, 256),
            nn.LeakyReLU(0.2, inplace=True),
            nn.Linear(256, 1),
            nn.Sigmoid(),
        )

    def forward(self, img):
        img_flat = img.view(img.size(0), -1)
        validity = self.model(img_flat)

        return validity


# Loss function
adversarial_loss = torch.nn.BCELoss()

# Initialize generator and discriminator
generator = Generator()
discriminator = Discriminator()

if cuda:
    generator.cuda()
    discriminator.cuda()
    adversarial_loss.cuda()

# Configure data loader
os.makedirs("../../data/mnist", exist_ok=True)
dataloader = torch.utils.data.DataLoader(
    datasets.MNIST(
        "../../data/mnist",
        train=True,
        download=True,
        transform=transforms.Compose(
            [transforms.Resize(opt.img_size), transforms.ToTensor(), transforms.Normalize([0.5], [0.5])]
        ),
    ),
    batch_size=opt.batch_size,
    shuffle=True,
)

# Optimizers
optimizer_G = torch.optim.Adam(generator.parameters(), lr=opt.lr, betas=(opt.b1, opt.b2))
optimizer_D = torch.optim.Adam(discriminator.parameters(), lr=opt.lr, betas=(opt.b1, opt.b2))

Tensor = torch.cuda.FloatTensor if cuda else torch.FloatTensor

# ----------
#  Training
# ----------

for epoch in range(opt.n_epochs):
    for i, (imgs, _) in enumerate(dataloader):

        # Adversarial ground truths
        valid = Variable(Tensor(imgs.size(0), 1).fill_(1.0), requires_grad=False)
        fake = Variable(Tensor(imgs.size(0), 1).fill_(0.0), requires_grad=False)

        # Configure input
        real_imgs = Variable(imgs.type(Tensor))

        # -----------------
        #  Train Generator
        # -----------------

        optimizer_G.zero_grad()

        # Sample noise as generator input
        z = Variable(Tensor(np.random.normal(0, 1, (imgs.shape[0], opt.latent_dim))))

        # Generate a batch of images
        gen_imgs = generator(z)

        # Loss measures generator's ability to fool the discriminator
        g_loss = adversarial_loss(discriminator(gen_imgs), valid)

        g_loss.backward()
        optimizer_G.step()

        # ---------------------
        #  Train Discriminator
        # ---------------------

        optimizer_D.zero_grad()

        # Measure discriminator's ability to classify real from generated samples
        real_loss = adversarial_loss(discriminator(real_imgs), valid)
        fake_loss = adversarial_loss(discriminator(gen_imgs.detach()), fake)
        d_loss = (real_loss + fake_loss) / 2

        d_loss.backward()
        optimizer_D.step()

        print(
            "[Epoch %d/%d] [Batch %d/%d] [D loss: %f] [G loss: %f]"
            % (epoch, opt.n_epochs, i, len(dataloader), d_loss.item(), g_loss.item())
        )

        batches_done = epoch * len(dataloader) + i
        if batches_done % opt.sample_interval == 0:
            save_image(gen_imgs.data[:25], "images/%d.png" % batches_done, nrow=5, normalize=True)

基于MNIST生成的图片

在这个实现中需要注意的一点是，原论文中 G 的训练是希望减小 log(1-D(G(z))，而代码中是使用二值交叉熵BCE(G(z), 1)，即希望提高-log(D(G(x)))，虽然都是希望让 D(G(x)) 趋近于1 ，但数值上还是有细微的不同。

代码部分参考资料

代码参考资料