从零手写DCGAN：生成对抗网络的训练稳定与调参实战

有人把GAN比作“让生成器和判别器互相欺骗的博弈游戏”，这句话说对了一半。真正动手从零写一个GAN之后你会发现，它更像是在训练一只极度敏感的共生体——两个网络相互绞着劲成长，任何一边掉链子，另一边立刻用离谱的loss回报你。有很多初学者跑通了MNIST手写数字生成的示例代码，就觉得“哦，原来GAN这么简单”，直到换到自己的数据集上，图像糊成一片、训练崩塌、loss震荡成心电图之后，才意识到自己只是复现了一个玩具，根本没理解GAN的运行机制。

这篇文章就是我实践完整GAN流程的经验总结，从数学直觉到代码结构，从训练稳定性的调试到生成效果的评估，覆盖一个可复现、可扩展的项目全流程。适合三种人：想弄懂GAN原理但被公式劝退的初学者、已经跑通过Demo但想理解训练细节的中级玩家、以及想快速把GAN用在自己数据集上做实验的工程师。我不铺概念、不抄教科书，直接讲我踩过的坑和最后沉淀下来的可落地方法。

1. 发散与对抗：先理解GAN的核心逻辑再动手写代码

在写任何一行代码之前，必须先把GAN的博弈逻辑在脑子里转清楚。这个环节不花时间，后面一定会十倍偿还。

1.1 生成器和判别器到底在干什么

所谓生成对抗网络，核心是一对“互为对手”的神经网络。

生成器（Generator）的输入是一个随机噪声向量（比如100维的服从正态分布的随机数），输出是一张图像（或一段文本、一组数据）。生成器的目标是让输出的图像足够逼真，逼真到让判别器认不出来。

判别器（Discriminator）的输入是一张图像，输出是一个介于0和1之间的置信度分数，代表“这张图是真的概率”。真图（来自训练数据集）得分趋近1，假图（来自生成器）得分趋近0。

我打一个生活化比方：生成器像是一个试图伪造名画的赝品师，判别器像是一个鉴别画的专家。赝品师不断改进手艺，提高骗过专家的概率；专家不断研究赝品的破绽，提高鉴别能力。两人在反复对抗中共同进化——最终的结果是，赝品师的技术高到能做出以假乱真的画，专家的水平也足以精准识别绝大多数破绽。但GAN的终极目标只有一个：拿到那个能骗过专家的赝品师，也就是训练好的生成器。

有意思的是，真正训练时，更新的节奏很微妙。我们并不希望判别器永远赢，因为那样梯度会消失、生成器学不到东西。我们也不希望生成器赢太快，那会导致判别器彻底放弃、生成器输出的全是千篇一律的“欺诈样本”。这种动态平衡，正是GAN最难驾驭的地方。

1.2 损失函数的直觉理解与代码对应

所有GAN算法到了数学层面，都收敛到下面这个极小极大博弈公式：

code复制min(G) max(D) V(D, G) = E[log(D(x))] + E[log(1 - D(G(z)))]

我第一次看到这个公式时头是大的，直到把它拆成两半才理解。

判别器那一半做什么？它希望第一项 log(D(x)) 尽量大（真图判真），同时第二项 log(1 - D(G(z))) 也尽量大（假图判假）。说实话这个“尽量大”很反直觉，因为第二项里带着 1 - D(...)，当 D(G(z)) 趋近0时 log(1-0)=0，看起来不大。实际上优化器最小化的是loss函数，所以我们把判别器的loss写成：

code复制loss_D = -[ log(D(x)) + log(1 - D(G(z))) ]

让这个loss变小，等价于让真图判真概率高、假图判假概率也高。

生成器那一半呢？它不希望自己生成的图像被判别为假，所以它想让 D(G(z)) 尽量接近1。注意生成器不能影响 D(x) 那一项。它的loss可以写成：

code复制loss_G = -log(D(G(z)))

让这个loss变小，等价于让判别器对着生成的图输出高分。

好，有了这个直觉，我们再去看代码，你会发现核心就三行。

python复制# 判别器损失：真图尽量判真，假图尽量判假
d_loss_real = criterion(d_output_real, torch.ones_like(d_output_real))
d_loss_fake = criterion(d_output_fake, torch.zeros_like(d_output_fake))
d_loss = (d_loss_real + d_loss_fake) / 2

# 生成器损失：让假图被判别器认为是真图
g_loss = criterion(d_output_fake, torch.ones_like(d_output_fake))

看到没？生成器那边的标签是硬生生写成1的——这就是“欺骗判别器”的代码形态。

1.3 为什么生成器一定要从噪声向量开始

不少初学者会问：为什么GAN不直接把一张模糊图输入生成器，让它输出高清图？为什么要从一个完全随机、没有任何语义信息的噪声开始？

原因是：我们想让生成器学到的是整个数据分布的“可采样空间”，而不是单纯的映射关系。噪声向量中每一个维度都可以理解为某种“隐变量”——有些维度可能控制发色，有些可能控制姿态、光照方向。从这个连续的低维流形上采样，生成器才能输出多样的结果。

我做的实验里，噪声维度设为100，服从标准正态分布 N(0,1)。如果你把维度降到2，并且在输出时只改变其中一个维度，就能看到生成图像的连续渐变效果——那是非常直观的“流形”演示。实际操作中，100维是个兼顾表达能力和训练稳定性的常用值，再大（比如512）当然也能跑，但会让训练初期的探索空间过大、收敛变慢。

2. 最小可用实现：从零手写一个能跑的DCGAN

这一部分是整篇文章的核心动作。我不推荐你直接调高层的GAN库，因为那会掩盖所有关键细节。手写一遍最基本的DCGAN，比看十篇论文都管用。

2.1 网络结构选型和参数细节

经典DCGAN（Deep Convolutional GAN）最大的贡献，是用卷积替代了全连接层，用批归一化稳定训练，用LeakyReLU解决生成器梯度稀疏问题。我基于它搭建的结构如下：

生成器结构（从100维噪声到64x64x3图像）

python复制class Generator(nn.Module):
    def __init__(self, latent_dim=100, ngf=64):
        super(Generator, self).__init__()
        self.init_linear = nn.Sequential(
            nn.Linear(latent_dim, ngf * 8 * 4 * 4),
            nn.BatchNorm1d(ngf * 8 * 4 * 4),
            nn.ReLU(True)
        )
        self.conv_blocks = nn.Sequential(
            # 输入: ngf*8 x 4 x 4
            nn.ConvTranspose2d(ngf * 8, ngf * 4, 4, 2, 1, bias=False),
            nn.BatchNorm2d(ngf * 4),
            nn.ReLU(True),
            # 8x8 -> 16x16
            nn.ConvTranspose2d(ngf * 4, ngf * 2, 4, 2, 1, bias=False),
            nn.BatchNorm2d(ngf * 2),
            nn.ReLU(True),
            # 16x16 -> 32x32
            nn.ConvTranspose2d(ngf * 2, ngf, 4, 2, 1, bias=False),
            nn.BatchNorm2d(ngf),
            nn.ReLU(True),
            # 32x32 -> 64x64
            nn.ConvTranspose2d(ngf, 3, 4, 2, 1, bias=False),
            nn.Tanh()
        )

    def forward(self, z):
        out = self.init_linear(z)
        out = out.view(out.size(0), -1, 4, 4)
        return self.conv_blocks(out)

两个关键设计点：

• 最后一层用 Tanh，把输出压缩到 [-1, 1]。这意味着训练数据必须预处理到 [-1, 1] 区间，而不是常见的 [0, 1]。很多人图像发灰、细节出不来，就是因为数据范围没对齐激活函数范围。
• 转置卷积参数 kernel=4, stride=2, padding=1 是特征图尺寸翻倍的黄金组合，一路从 4x4 放大到 64x64，没有小数尺寸问题。

判别器结构

python复制class Discriminator(nn.Module):
    def __init__(self, ndf=64):
        super(Discriminator, self).__init__()
        self.conv_blocks = nn.Sequential(
            # 输入: 3 x 64 x 64
            nn.Conv2d(3, ndf, 4, 2, 1, bias=False),
            nn.LeakyReLU(0.2, inplace=True),
            # 32x32
            nn.Conv2d(ndf, ndf * 2, 4, 2, 1, bias=False),
            nn.BatchNorm2d(ndf * 2),
            nn.LeakyReLU(0.2, inplace=True),
            # 16x16
            nn.Conv2d(ndf * 2, ndf * 4, 4, 2, 1, bias=False),
            nn.BatchNorm2d(ndf * 4),
            nn.LeakyReLU(0.2, inplace=True),
            # 8x8
            nn.Conv2d(ndf * 4, ndf * 8, 4, 2, 1, bias=False),
            nn.BatchNorm2d(ndf * 8),
            nn.LeakyReLU(0.2, inplace=True),
            # 4x4
            nn.Conv2d(ndf * 8, 1, 4, 1, 0, bias=False),
            nn.Sigmoid()
        )

    def forward(self, img):
        return self.conv_blocks(img).view(-1)

判别器不加 BatchNorm 在第一层卷积前，这是一个从实践中总结的细节。BatchNorm 会同时洗掉真图和假图的统计特性差异，让判别器过早失去辨别力。后面几层可以加，第一层不要加。

2.2 训练循环的节奏控制与优化器选择

GAN 的优化器选择没有悬念：Adam。但它有两个超参数需要重点调整。

• 学习率：经典DCGAN论文里用了 lr=0.0002，这是基于经验的值。增大到0.001会明显加速早期崩溃。
• betas=(0.5, 0.999)：默认的 0.9 会让梯度一阶矩估计的滑动平均过大，导致震荡剧烈。0.5 是GAN训练社区踩坑后形成的常用值，能有效降低动量惯性，让博弈过程更稳定。

训练循环的核心节奏是这样的：

python复制for epoch in range(num_epochs):
    for i, (real_imgs, _) in enumerate(dataloader):
        # 构造真实图像批量，并归一化到[-1, 1]
        real_imgs = real_imgs.to(device) * 2 - 1
        
        # 训练判别器
        optimizer_D.zero_grad()
        z = torch.randn(batch_size, latent_dim, device=device)
        fake_imgs = generator(z)
        
        d_loss_real = criterion(discriminator(real_imgs), torch.ones_like(real_labels))
        d_loss_fake = criterion(discriminator(fake_imgs.detach()), torch.zeros_like(real_labels))
        d_loss = (d_loss_real + d_loss_fake) / 2
        d_loss.backward()
        optimizer_D.step()
        
        # 训练生成器
        optimizer_G.zero_grad()
        z = torch.randn(batch_size, latent_dim, device=device)
        fake_imgs = generator(z)
        g_loss = criterion(discriminator(fake_imgs), torch.ones_like(real_labels))
        g_loss.backward()
        optimizer_G.step()

注意判别器训练时对 fake_imgs.detach() 的处理。如果这里不切断梯度，那么 d_loss.backward() 会同时更新生成器的参数——这是我们绝对不想要的。交替更新的本质是“冻结对方”，pytorch里用detach实现最干净。

训练比例方面，理论上每个batch应该先训练K次判别器、再训练1次生成器。但实际经验表明，1:1的比例在大多数数据集上都能工作，且更省时间。只有在判别器loss急剧下降、生成器完全无法进步的时候，才需要把比例调成（比如）判别器5次、生成器1次。

2.3 训练过程的监控指标与可视化

很多人训练GAN只看loss曲线，这是一个大坑。GAN的loss值本身没有绝对意义——它是两个博弈方的相对状态。一个优秀的项目必须同时追踪三个维度：

第一，loss曲线。用于判断“是否出现数量级崩溃”，比如 d_loss 突然到0.x以下且持续不回升，说明判别器碾压了生成器。

第二，生成图像的实际质量。每训练一个epoch，固定一组同一噪声向量 z_fixed，生成一批图像并保存。观察每轮的图像变化，比看数字直观得多。

第三，判别器对真实数据和生成数据的“平均输出概率”。D(x) 和 D(G(z)) 都稳定在0.5附近，是训练良好的标志。如果D(x)一直高于0.9，而D(G(z))一直低于0.1，说明判别器过强；反之说明生成器过强。

下面是我常用的一个简单监控代码：

python复制writer.add_scalar('Loss/D', d_loss.item(), epoch * len(dataloader) + i)
writer.add_scalar('Loss/G', g_loss.item(), epoch * len(dataloader) + i)
writer.add_scalar('Prob/D(x)', d_x.mean().item(), epoch * len(dataloader) + i)
writer.add_scalar('Prob/D(G(z))', d_z.mean().item(), epoch * len(dataloader) + i)

每次迭代更新数值、固定噪声向量生成的图像每轮存一次，训练结束后你会得到一组非常好的“渐进演化”存档。

3. 从训练崩溃到高质量输出的调参实战

如果是第一次跑GAN，你大概率会遇到下面这些令人头大的情况。我全部真实经历过，解决方案也是实打实试出来的。

3.1 模式崩溃：生成器只会输出同一张图

症状是：保存的生成图像张张雷同，像换了颜色背景的复制粘贴。原因是生成器找到了一个“安全区域”——某些特定输出能持续骗过当前判别器，于是它躺在舒适区里，不再探索其他模式。

我试过最有效的缓解思路有三个：

• 调低学习率。模式崩溃往往发生在对抗过于激烈时，降低两边的学习率到 lr=0.0001 甚至更低，让双方变化更温和。
• 引入标签平滑（Label Smoothing）。把真实图像的标签从1改成 0.9 左右，避免判别器过度自信，降低它对极端概率的依赖。这能让生成器拿到的梯度更稳健。
• 保存多个epoch的模型，在崩溃发生时回滚到之前质量较好的检查点，重新调整超参后再跑。不要妄想修复一个已经严重崩溃的网络，重来往往更快。

3.2 梯度消失：判别器过于强大

“判别器过强”听起来像好事，但恰恰是GAN训练最头疼的问题。症状是判别器loss长期在0.01以下，生成器的loss没有任何下降趋势，生成的图像在几个epoch内没有丝毫变化。

判别器学得太快，一眼就能分辨真假，导致传给生成器的梯度接近于0。解决办法：

• 在判别器中使用 LeakyReLU 的负斜率从0.2调整到0.3，为负区间提供更多梯度。
• 用 SpectralNorm 替换 BatchNorm2d 做判别器的归一化。谱归一化直接限制了判别器每一层权重的Lipschitz常数，从根上抑制了判别器过度强大的问题。这也是当前最稳定的改良方向。
• 判别器加入Dropout（比如 p=0.3），强迫它不能太“死记硬背”。

3.3 图像模糊：只能生成大色块

如果你生成的图像看起来只是模糊的颜色渐变，细节纹理完全没有，大概率是语义信息在逐层转置卷积中丢失了。我踩过的具体问题和对应的修复：

• 批大小太小。我会用32，改成64之后图像的清晰度肉眼可见提升。原因是大批量带来了更稳定的梯度估计。
• 深层特征图通道数不够。生成器初始通道 ngf 从32提升到64，给网络更多容量去编码纹理信息。
• 数据本身质量不佳。如果输入图像分辨率参差不齐，需要全部中心裁剪后缩放到统一64x64，且保证主体占比足够高。很多数据集里主体只占画面的一小块，生成器学到的是“一张图里有个小小物体”，自然永远出不了大特写。

后来的项目里，我把 ngf=128 重新跑了一遍同样的数据，生成的图像质量上了一个台阶，代价是训练时间长了大概25%。对追求效果的人来说，值得。

4. 完整项目落地：从数据准备到模型评估

拥有训练好的模型只是开始。一个完整项目要能落地，还差数据管线、训练管理、模型评估三个环节。这一章节把我实际项目中的全流程复述一遍。

4.1 数据管线的标准化处理

我在这套GAN流程中，数据管线遵循这样一套“输入标准化”流程：

• 收集原始图像集，统一转成RGB三通道。
• 中心裁剪到正方形（比如用 CenterCrop），保留主体信息，去除包围边界的无关背景。
• Resize到64x64。
• 转为Tensor后做 Normalize(mean=(0.5,0.5,0.5), std=(0.5,0.5,0.5))，像素值映射到[-1,1]。

用PyTorch的DataLoader加载时，设置 batch_size=64，shuffle=True，num_workers=4。一个容易忽略的细节是 drop_last=True——如果最后一个batch的样本数不足，BatchNorm计算统计量会不准，给训练引入噪声。

另外一个经验之谈：对于GAN来说，数据量比数据质量更苛刻。我试过那些只有一两千张的私人数据集，生成的图像纹理始终不行。至少准备上万张同一类型、风格接近、主体清晰的图像，“同质性高”比“数量巨多”更重要。风格混杂的数据集会让生成器试图平均所有风格，最终输出一个“四不像”。

4.2 训练配置与显存优化的平衡方案

训练GAN对显存的要求不是特别高，但也不是集显能跑动的。我的实践配置：

• 图像分辨率64x64，batch_size=64时，显存占用大约6-7GB。用 batch_size=32 可以把需求压到4GB以下。
• 想要生成128x128的高分辨率图像，需要考虑增大模型容量，同时把 batch_size 降到16或32来平衡显存。
• 开启 torch.backends.cudnn.benchmark = True，因为输入尺寸固定，这让卷积算子自动选择最快的实现算法。

同步说一下训练时长预期。RTX级别的主流消费级显卡，跑完一个完整数据集（比如几万张图）的DCGAN，大约需要1-3小时。如果训练超过24小时loss仍然剧烈震荡，停止。GAN训练不是越久越好，很多模型在中间某个checkpoint就已经达到最佳效果，后面的epoch反而会因为判别器过度拟合而倒退。

4.3 三种实用的模型评估方法

评估GAN的输出质量是另一个难点。loss不能反映真实生成质量，我常用下面三个指标去综合判断。

肉眼评估（最直接但主观）：固定一组噪声向量，观察生成图像在不同epoch的演化。如果相邻epoch的图像差异过大、纹理忽真忽假，说明训练不稳定；如果差异很小，说明收敛良好。

FID（Fréchet Inception Distance）：将生成图像和真实图像分别输入Inception V3网络，提取特征层输出，计算两个特征分布之间的距离。FID越低，代表生成图像分布与真实图像分布越接近。这是目前学术与工业界最常用的指标。

Mode Score / 多样性评估：简单做法是生成一批图像，计算两两之间的平均像素差异度。如果差异度接近0，说明发生了模式崩溃，模型只是在输出同一图像。这个方法虽然粗糙，但胜在快速、不需要额外网络。

我一般是在每个epoch结束时保存一份模型，然后用测试集计算一次FID，记录曲线。等训练全部结束，挑选FID最低的epoch作为最终模型。这比“训练到最后一步”科学得多。

5. 常见问题与排查技巧实录

最后把我整个实践中遇到的实际问题整理成一个排查速查表，方便大家直接对照。

再分享一个我个人反复用的调试技巧：训练前先用小batch（比如8个样本）跑20步，确认前向传播和loss backward都没有报错。然后正常训练，但前20个epoch里只观察固定噪声向量的输出。注意，前5个epoch图像一定是噪声般的纹理，不能因为前期效果差就立刻终止，给训练一个“从混沌走向结构”的过程。

另一个值得强调的经验是：永远保留两个或者更多实验版本。GAN实验的复现性比普通深度学习差，同样的代码和超参在不同显卡驱动、不同CUDA版本下结果会不一样。我把每次实验的配置文件、log、checkpoint、样本图都归档到一个按时间戳命名的目录，三个月后回头看，才能知道当初某次成功是改了什么参数换来的。

6. 结语：GAN项目的价值不在“生成”本身

我做完这个项目之后最大的感受是：GAN给我带来的提升不在于“我能生成图像”这个结果，而在于训练它逼着我把最优化的底层逻辑、数据分布、博弈均衡这些概念从纸面变成了肌肉记忆。任何一个训练GAN崩溃又重启、重启又调参的夜晚，都比读十篇综述更让人理解深度学习。

如果让我给正在看这篇文章的人一个具体建议：不要去实现那些花哨的变体，先把最基础的DCGAN从零到训练稳定完整跑通一遍，把固定噪声输出、loss震荡、模式崩溃这三个问题亲手解决掉。这个过程是不可跳过的，也是GAN从玩具到工具的真正分水岭。后续你有兴趣拓展的话，可以尝试引入WGAN-GP的梯度惩罚、Self-Attention GAN的注意力机制、或者干脆把生成器换成StyleGAN的映射网络结构——但那些都建立在你对基础版本每一个参数“出了事怎么修”都了然于胸的前提之上。先把地基打好，上面盖什么都稳。