DCGAN实战指南：从代码细节到训练调优的工程化解析

1. 这不是“讲清楚GANs”的课，而是带你亲手拆开它、看清齿轮怎么咬合

“Understanding GANs”这个标题看起来像一门公开课的章节名，但在我带过二十多期AI工程实践训练营、亲手陪学员调崩过三百多次生成器之后，我越来越确信：真正理解GANs，从来不是靠背下那个“生成器对抗判别器”的经典定义，而是你亲手让一张噪声图，在第47个epoch突然开始显出人眼能辨认的轮廓时，后颈那一阵发麻的感觉。这种理解是肌肉记忆式的——它长在你反复修改torch.nn.LeakyReLU(negative_slope=0.2)的坡度、手动计算BCEWithLogitsLoss里log(1 + exp(-x))的数值稳定性、甚至盯着TensorBoard里两条loss曲线像冤家一样反复拉锯时，慢慢沉淀下来的直觉。它解决的不是“GANs是什么”这个哲学问题，而是“为什么我改了学习率模型就彻底不学了”“为什么生成图片全是灰色噪点”“为什么判别器loss掉到0.001就再也下不去”这些扎在项目第一线的真实痛点。这篇文章就是为那些已经写过import torch、跑过MNIST、但一碰生成任务就卡在“能跑通，但跑不好”阶段的工程师和进阶学习者写的。它不讲泛泛而谈的数学推导，只聚焦于你打开Jupyter Notebook后，光标该落在哪一行代码上、参数该填什么数字、报错信息背后到底在暗示什么硬件或逻辑瓶颈。如果你正被DCGAN的checkerboard artifacts折磨，或者被StyleGAN的latent space插值结果搞得怀疑人生，那接下来的内容，就是你调试日志里最该优先查看的那几行注释。

2. 核心设计思路：为什么非得用“对抗”这条路？——从图像重建的失败史说起

2.1 传统方法的天花板：为什么VAE和PixelRNN都走不到高清生成

要真正吃透GANs的设计哲学，得先回到2014年之前那个令人沮丧的现实：我们手里的工具，根本造不出一张像样的新脸。当时主流的生成模型只有两条路：一条是变分自编码器（VAE），另一条是基于像素预测的循环神经网络（PixelRNN/PixelCNN）。我拿自己2016年在医疗影像组做的一个真实项目举例——目标是生成高分辨率的肺部CT切片用于数据增强。我们先上了VAE：编码器把512×512的CT图压缩成128维向量，解码器再把它展开。结果呢？重建出来的图像是模糊的、雾蒙蒙的，所有关键的血管分支细节全被平滑掉了。原因很物理：VAE优化的是重构误差（L2 loss），它天然偏好“平均化”输出，因为对所有可能的模糊结果取平均，比精准复现某一个尖锐边缘更大概率降低整体误差。这就像你让一个画家临摹一幅高清照片，但规定他每画一笔都必须参考周围十张不同风格的草稿，最后交出来的必然是四不像的折中产物。而PixelRNN呢？它试图用RNN逐像素预测，理论上能建模任意复杂分布。但我们实测发现，当图像分辨率超过128×128，训练时间直接爆炸——因为RNN的序列长度等于像素总数，512×512就是262144步！更致命的是，它生成的图像充满高频噪声，边缘像被砂纸磨过。根本原因在于：RNN的长期依赖建模能力在超长序列下严重退化，它记不住“左上角是个肺结节”，所以右下角就胡乱猜测。这两条路走到尽头，都撞上了同一个墙：概率密度建模的固有缺陷——要么牺牲清晰度保稳定，要么追求细节却失控。这就是Ian Goodfellow团队提出GANs的原始驱动力：绕开直接建模p(x)这个不可能完成的任务，转而用一个可微分的“游戏规则”来驱动生成器进化。

2.2 对抗思想的精妙之处：用“裁判打分”代替“标准答案”

GANs最反直觉也最天才的设计，是把生成问题转化成了一个零和博弈。我们不再要求生成器“完美复刻训练集”，而是给它配一个同样由神经网络构成的“严苛考官”——判别器D。D的任务非常简单粗暴：看一张图，就回答“这是真的（来自训练集）还是假的（来自生成器G）”。而G的目标呢？不是让自己的输出看起来“像某张真图”，而是让D在看到自己的输出时，给出的“真”概率无限接近0.5——也就是让D彻底无法分辨。这个设定的精妙，在于它彻底规避了传统方法对“绝对标准”的依赖。举个生活化的例子：想象你在教一个雕塑系学生雕人脸。如果按VAE思路，你得给他一张高清照片，说“照着这个雕，越像越好”，结果他雕出个光滑的石膏蛋；如果按PixelRNN思路，你让他从左上角第一个像素开始，每个像素都问“下一个该是什么灰度值”，他雕到鼻子时早忘了耳朵的弧度。而GANs的做法是：你请来一位经验丰富的老雕塑家（D）当评委，只告诉他规则：“你只要判断眼前这个作品，是出自本校毕业展（真数据）还是美院附中学生作业（G生成）”。然后你告诉你的学生（G）：“你不用管老师觉得像不像，你只要想办法，让老师每次看到你的作品，都犹豫三秒，最后硬着头皮打个75分。” 这个75分，就是D输出的sigmoid概率值。当G足够强，D的输出就会在0.5附近震荡——这意味着G已经骗过了人类专家的肉眼。这种“通过对抗提升能力”的机制，天然鼓励生成器去捕捉数据分布中最本质、最具判别性的特征（比如人脸的眼睛间距、鼻梁走向），而不是纠结于某个像素的精确灰度值。这也是为什么GANs生成的图像，即使局部有瑕疵，整体观感也极具“真实感”的根源：它学的是“什么是人脸”，而不是“这张人脸长什么样”。

2.3 架构选型的底层逻辑：为什么DCGAN成了事实标准？

当你决定动手实现第一个GAN时，摆在面前的第一个选择就是架构。是自己从头搭一个全连接网络？还是抄一篇顶会论文的结构？我的建议非常明确：从DCGAN（Deep Convolutional GAN）开始，而且要严格遵循它的设计规范。这不是因为DCGAN有多先进（它2015年就发布了），而是因为它用一系列看似琐碎的工程约束，踩平了早期GANs训练中90%的坑。我来拆解这四个关键约束及其背后的物理意义：

1. 全卷积替代全连接（No Fully Connected Layers in Generator/ Discriminator）：早期GANs在生成器末尾用FC层把100维噪声映射成784维（28×28）像素，这导致生成图像充满棋盘格伪影（checkerboard artifacts）。原因在于反卷积（transposed convolution）的上采样过程存在重叠区域，FC层无法建模这种空间相关性。DCGAN强制使用卷积+上采样，让每个像素的生成都依赖其邻域，从根本上抑制了伪影。实操中，我见过太多人为了“省事”在Generator最后一层加FC，结果调参三天，发现只要换成Conv2DTranspose，loss立刻收敛。

2. BatchNorm的神来之笔（Batch Normalization in Both Networks）：这是DCGAN最被低估的贡献。在G和D中，除了输入层和输出层，所有卷积层后都加BN。它的作用远不止“加速训练”这么简单。对生成器G而言，BN层把每一层的输入分布强行拉回均值为0、方差为1，这相当于给G的内部表征加了一个“稳定锚点”，让它不会因为某一层权重稍大就导致后续层全部饱和。对判别器D而言，BN则起到了“特征归一化”的作用，让D更关注图像内容本身，而不是被不同batch间的数据尺度差异干扰。我做过对照实验：关掉D的BN，D的loss会像心电图一样剧烈抖动；关掉G的BN，生成图像的对比度会随epoch剧烈变化，有时全黑，有时全白。

3. 激活函数的取舍（LeakyReLU for D, ReLU for G）：判别器D用LeakyReLU（负斜率设为0.2），是为了避免“死区”（dead neurons）——当输入为负时，普通ReLU输出0，梯度也为0，这部分神经元就永远学不会了。而生成器G用标准ReLU，是因为它需要强烈的非线性来从噪声中“爆发”出结构。这里有个关键细节：G的输出层必须用Tanh，而不是Sigmoid。因为MNIST等数据集的像素值被归一化到了[-1, 1]区间，Tanh的输出范围正好匹配；若用Sigmoid（输出[0,1]），G就必须额外做一次缩放，这会引入不必要的数值误差。

4. 优化器的铁律（Adam over SGD）：DCGAN论文明确指出，用SGD训练GANs几乎必然失败。Adam优化器的自适应学习率机制，对GANs这种双目标、强耦合的系统至关重要。它能让G和D的学习步长根据各自当前的梯度历史自动调整，避免一方过快压制另一方。我曾用SGD跑过200个epoch，D的loss降到0.01就再也不动了，G完全学不到东西；换成Adam（lr=0.0002, β1=0.5），50个epoch内就看到清晰的数字轮廓。

提示：这四条不是“建议”，而是DCGAN能跑通的必要条件。任何一条的偏离，都可能让你陷入“loss下降但图像毫无改进”的绝望循环。这不是玄学，是无数人用GPU小时换来的血泪共识。

3. 核心细节解析：从代码到像素，每一个参数都在说话

3.1 噪声向量z：不是随机数，而是“生成指令集”

新手最容易误解的，就是把生成器的输入z简单当成“随机噪声”。实际上，z是一个精心设计的、高维的“潜在指令集”。它的维度（通常100或128）直接决定了G的表达能力上限。维度太小（如10），G就像一个词汇量只有10个词的作家，再怎么努力也写不出复杂的句子；维度太大（如1000），G又会陷入过拟合，把训练集里的每张图都记住，失去泛化能力。我在指导学员时，会让他们做一个小实验：固定z的前50维为0，只让后50维随机变化，观察生成图像的变化。结果你会发现，图像的整体结构（如数字是1还是7）往往由前半部分控制，而纹理、粗细等细节由后半部分控制。这说明z的空间是有语义结构的。因此，z的采样方式绝不能马虎。最常用的是从标准正态分布N(0,1)采样，因为它的各向同性（isotropic）特性，能让G在所有方向上均匀探索。千万别用均匀分布U(-1,1)，它会导致z向量的模长集中在某个狭窄区间，G学到的只是这个球壳上的数据，表达能力大打折扣。另外，z的batch size也暗藏玄机。太小（如16），D看到的“假图”多样性不足，容易过拟合到这批特定的噪声；太大（如256），显存吃紧，且单次更新梯度噪声过大。我实测下来，对于128×128图像，64是最优平衡点——既能保证多样性，又不会压垮RTX 3090。

3.2 损失函数：BCEWithLogitsLoss为何是唯一选择？

GANs的原始论文用的是标准的二元交叉熵（BCE）损失，公式是- [y * log(D(x)) + (1-y) * log(1-D(x))]。但现代PyTorch实现中，无一例外都用nn.BCEWithLogitsLoss，而不是先算D(x)再套nn.BCELoss。这个细节的差别，关乎你能否在训练初期就看到希望。原因在于数值稳定性。D(x)的输出是经过sigmoid的，范围在(0,1)。当D(x)极其接近0或1时（这在训练初期非常常见），log(D(x))或log(1-D(x))会产生-inf，导致梯度爆炸或消失。BCEWithLogitsLoss则聪明地将sigmoid和log loss合并为一个原子操作，内部使用log(1 + exp(-x))等稳定公式，完美规避了这个问题。我曾经为了验证这点，特意写了两版代码：一版用sigmoid + BCELoss，一版用BCEWithLogitsLoss。前者在第3个epoch就出现nanloss，后者稳稳跑到200个epoch。此外，BCEWithLogitsLoss的reduction='mean'参数必须设为'mean'，而不是'sum'。因为sum会让loss随batch size线性增长，导致你调学习率时永远找不到那个“刚刚好”的值；而mean则让loss尺度与batch size无关，参数调优变得可预测。

3.3 判别器的“作弊”与“惩罚”：为什么D要训得比G狠？

几乎所有GANs教程都会告诉你：“要交替训练D和G”。但没人告诉你，这个“交替”的节奏，是GANs能否活过前50个epoch的生命线。我的黄金法则是：在训练初期（前30% epoch），让D每更新1次，G更新1次；进入中期（30%-70%），D每更新1次，G更新1次；到了后期（70%以后），D每更新1次，G更新2次。这个动态节奏的背后，是深刻的博弈论逻辑。想象D和G是一对拳击手。开局时，D是职业选手，G是刚进健身房的新手。如果让G先上场，它会被D一拳KO，永远学不会防守。所以前期，我们必须让D先热身，多打几回合（多更新几次），把自己的“判别肌肉”练出来，建立一个可靠的baseline。这时G的更新，更多是“感受压力”，而不是“学会技巧”。当中期D的判别力达到一定水平（loss稳定在0.3-0.5），G才真正开始学习如何欺骗。而到了后期，D已经非常强大，G必须加倍努力才能跟上——这就是为什么G的更新频率要提高。另一个关键技巧是“标签平滑”（Label Smoothing）。不要把真样本的label设为1.0，而是设为0.9；假样本的label设为0.0，而不是0.0。这听起来反直觉，但它能有效防止D过度自信。当D对真图输出0.999时，它的梯度会变得极小（因为sigmoid在极端值处梯度趋近于0），更新停滞。用0.9作为软标签，D的输出会被“拉”向0.9，保持在一个梯度良好的区间。我在CIFAR-10上测试过，开启标签平滑后，D的loss波动幅度降低了40%，G的生成质量提升了一个明显档次。

3.4 图像预处理：被忽视的“第一道滤网”

很多人把精力全放在网络结构上，却忽略了数据入口处的“第一道滤网”——图像预处理。这一步的失误，足以让后面所有努力归零。以最常见的MNIST为例，原始数据是0-255的uint8格式。如果你直接把它喂给网络，会发生什么？G的输出层用Tanh，范围是[-1,1]，而输入却是[0,255]，巨大的尺度不匹配会导致梯度在反向传播中疯狂放大或缩小。正确的做法是：先归一化到[0,1]，再线性变换到[-1,1]。公式就是(x / 255.0) * 2 - 1。这个看似简单的操作，背后是让G的输入和输出在同一个数值尺度上，确保梯度流动顺畅。更隐蔽的坑在数据增强。对GANs，千万不要用随机旋转、随机裁剪这类强几何变换！因为GANs学习的是数据的内在分布，而旋转/裁剪会人为制造出训练集中不存在的模式（比如倒置的数字6），让D困惑，也让G学到错误的先验。唯一安全的增强是水平翻转（对人脸、汽车等左右对称数据）和轻微的色彩抖动（color jitter），且抖动幅度必须极小（亮度/对比度变化<0.1）。我曾有一个学员，为了“增加数据量”，对CelebA人脸数据集做了30度随机旋转，结果G生成的人脸全是歪脖子，D的loss在0.6上下徘徊就是下不去。关掉旋转，一切恢复正常。记住：GANs的鲁棒性，来自于对真实数据分布的敬畏，而不是对数据量的贪婪。

4. 实操过程：从零开始搭建一个可工作的DCGAN（含完整代码逻辑）

4.1 环境与依赖：版本锁定是稳定的基石

在动手写代码前，请务必执行这行命令：

pip install torch==1.13.1 torchvision==0.14.1 numpy==1.23.5 matplotlib==3.7.1

别嫌麻烦。GANs对PyTorch版本极其敏感。1.12.x系列有已知的torch.nn.ConvTranspose2d梯度计算bug，会导致checkerboard artifacts；1.14.x又引入了新的autograd引擎，某些自定义loss会出现不可预测的nan。1.13.1是经过工业界大规模验证的“黄金版本”。torchvision的版本必须严格匹配，否则datasets.MNIST的返回格式可能变化，导致DataLoader报错。numpy和matplotlib的版本锁定，则是为了确保随机种子的可重现性——在GANs调试中，“这次能跑通，下次就不行”是最折磨人的体验，而版本漂移正是罪魁祸首。我建议你创建一个干净的conda环境：

conda create -n gan_env python=3.9 conda activate gan_env pip install torch==1.13.1 torchvision==0.14.1 numpy==1.23.5 matplotlib==3.7.1

4.2 生成器G：从100维噪声到28×28图像的魔法旅程

下面是你必须亲手敲入的生成器核心代码，每一行我都标注了它的物理意义：

import torch import torch.nn as nn class Generator(nn.Module): def __init__(self, nz=100, ngf=64, nc=1): # nz: noise dim, ngf: generator feature map base, nc: channel super(Generator, self).__init__() # 第一层：100维噪声 -> 512维特征图 (4x4) # 输入是 (N, 100, 1, 1)，输出是 (N, 512, 4, 4) # kernel_size=4, stride=1, padding=0 是为了从1x1扩张到4x4 self.main = nn.Sequential( # 输入层：全连接，把100维z映射成512*4*4的向量，再reshape成4x4的特征图 nn.Linear(nz, ngf * 8 * 4 * 4), # 100 -> 512*4*4 = 8192 nn.ReLU(True), # Reshape操作在forward里做，这里只定义网络结构 # 接下来是4层上采样卷积 # 第二层：4x4 -> 8x8 nn.ConvTranspose2d(ngf * 8, ngf * 4, 4, 2, 1, bias=False), # in:512, out:256, k=4,s=2,p=1 nn.BatchNorm2d(ngf * 4), nn.ReLU(True), # 第三层：8x8 -> 16x16 nn.ConvTranspose2d(ngf * 4, ngf * 2, 4, 2, 1, bias=False), # in:256, out:128 nn.BatchNorm2d(ngf * 2), nn.ReLU(True), # 第四层：16x16 -> 32x32 (但我们只需要28x28，所以最后crop) nn.ConvTranspose2d(ngf * 2, ngf, 4, 2, 1, bias=False), # in:128, out:64 nn.BatchNorm2d(ngf), nn.ReLU(True), # 第五层：32x32 -> 28x28? 不，是32x32 -> 28x28 via cropping # 实际上，我们输出32x32，然后在数据加载时crop到28x28，保持一致性 nn.ConvTranspose2d(ngf, nc, 4, 2, 1, bias=False), # in:64, out:1, k=4,s=2,p=1 -> 32x32 nn.Tanh() # 输出范围 [-1, 1] ) def forward(self, input): # input shape: (N, 100) x = self.main[0](input) # Linear: (N, 100) -> (N, 8192) x = x.view(x.size(0), -1, 4, 4) # Reshape to (N, 512, 4, 4) output = self.main[1:](x) # 应用后面的ConvTranspose2d序列 return output

这段代码里藏着三个关键设计点：

1. Linear层的魔力：它不是多余的。nn.Linear(nz, ngf*8*4*4)的作用，是把100维的向量，一次性“注入”到一个4×4的二维空间里。这比直接用ConvTranspose2d从1×1开始上采样，更能保留噪声的全局结构信息。
2. bias=False的深意：在所有ConvTranspose2d层都禁用偏置项。因为BatchNorm2d层已经包含了可学习的仿射变换（weight和bias），再加一个卷积偏置，会造成参数冗余，影响训练稳定性。
3. Tanh的不可替代性：它是整个生成流程的“终点站”。没有它，G的输出会是任意实数，无法与归一化到[-1,1]的真图像匹配，D的判别将失去意义。

4.3 判别器D：一个像素级的“真假大师”

判别器的代码同样需要精确到每一个参数：

class Discriminator(nn.Module): def __init__(self, nc=1, ndf=64): # ndf: discriminator feature map base super(Discriminator, self).__init__() self.main = nn.Sequential( # 第一层：28x28 -> 14x14 # 输入 (N, 1, 28, 28)，输出 (N, 64, 14, 14) nn.Conv2d(nc, ndf, 4, 2, 1, bias=False), # k=4,s=2,p=1 nn.LeakyReLU(0.2, inplace=True), # 第二层：14x14 -> 7x7 nn.Conv2d(ndf, ndf * 2, 4, 2, 1, bias=False), nn.BatchNorm2d(ndf * 2), nn.LeakyReLU(0.2, inplace=True), # 第三层：7x7 -> 3x3 (因为7//2=3, floor division) nn.Conv2d(ndf * 2, ndf * 4, 4, 2, 1, bias=False), nn.BatchNorm2d(ndf * 4), nn.LeakyReLU(0.2, inplace=True), # 第四层：3x3 -> 1x1 (全局判别) nn.Conv2d(ndf * 4, ndf * 8, 3, 1, 0, bias=False), # k=3,s=1,p=0 -> 1x1 nn.BatchNorm2d(ndf * 8), nn.LeakyReLU(0.2, inplace=True), # 最后一层：1x1特征图 -> 1维标量输出 nn.Conv2d(ndf * 8, 1, 1, 1, 0, bias=False), # k=1,s=1,p=0 -> 1x1 # 注意：这里不加Sigmoid！BCEWithLogitsLoss会自动处理 ) def forward(self, input): output = self.main(input) return output.view(-1, 1) # 展平为 (N, 1) 形状，供loss计算

这里的关键点在于：

• 最后一层的Conv2d(1,1)：它取代了传统的全局平均池化（GAP）或全连接层。因为GAP会丢失空间位置信息，而1x1卷积能保持每个位置的独立判别能力，让D能更精细地定位图像中的伪造痕迹。
• inplace=True的性能考量：LeakyReLU的inplace参数设为True，意味着它直接在输入张量上修改，而不是创建新张量。这对显存紧张的训练场景至关重要，能节省约15%的显存占用。
• view(-1,1)的形状统一：无论输入batch size是多少，forward的输出都必须是(N,1)形状，这样才能和BCEWithLogitsLoss的target(N,1)完美匹配。少一个view，就会报size mismatch错误。

4.4 训练循环：每一行代码都是一个决策点

完整的训练循环，是GANs的灵魂所在。下面是我经过上百次调试后确认的“最小可行”版本：

import torch.optim as optim from torch.nn import BCEWithLogitsLoss # 初始化网络 netG = Generator().to(device) netD = Discriminator().to(device) # 优化器：Adam，且beta1=0.5是DCGAN的硬性要求！ optimizerG = optim.Adam(netG.parameters(), lr=0.0002, betas=(0.5, 0.999)) optimizerD = optim.Adam(netD.parameters(), lr=0.0002, betas=(0.5, 0.999)) criterion = BCEWithLogitsLoss() # 训练主循环 for epoch in range(num_epochs): for i, data in enumerate(dataloader, 0): ############################ # (1) 更新判别器D：最大化 log(D(x)) + log(1 - D(G(z))) ############################ ## 真样本 real_cpu = data[0].to(device) # (N, 1, 28, 28) b_size = real_cpu.size(0) label = torch.full((b_size,), 0.9, dtype=torch.float, device=device) # 标签平滑：0.9 output = netD(real_cpu).view(-1) # (N,) errD_real = criterion(output, label) errD_real.backward() D_x = output.mean().item() # 记录D对真图的平均输出 ## 假样本 noise = torch.randn(b_size, nz, device=device) # (N, 100) fake = netG(noise) # (N, 1, 28, 28) label.fill_(0.0) # 假样本标签为0.0 output = netD(fake.detach()).view(-1) # 关键！detach()切断G的梯度流 errD_fake = criterion(output, label) errD_fake.backward() D_G_z1 = output.mean().item() # 记录D对假图的平均输出 errD = errD_real + errD_fake optimizerD.step() ############################ # (2) 更新生成器G：最大化 log(D(G(z))) ############################ # 注意：这里重新计算fake，且不detach，以便G能收到梯度 optimizerG.zero_grad() label.fill_(0.9) # G的目标是让D认为它是真图，所以label=0.9 output = netD(fake).view(-1) # (N,) errG = criterion(output, label) errG.backward() D_G_z2 = output.mean().item() optimizerG.step() # 打印进度 if i % 50 == 0: print(f'[{epoch}/{num_epochs}][{i}/{len(dataloader)}] ' f'Loss_D: {errD.item():.4f} Loss_G: {errG.item():.4f} ' f'D(x): {D_x:.4f} D(G(z)): {D_G_z1:.4f} / {D_G_z2:.4f}')

这个循环里，有三个你绝对不能忽略的“魔鬼细节”：

1. .detach()的生死线：在更新D时，fake.detach()是必须的。它告诉PyTorch：“这张假图只是D的输入，G的参数不要参与这次反向传播”。如果没有它，D的梯度会沿着fake反向流回G，导致G被D的判别目标意外“污染”，训练彻底混乱。
2. optimizerG.zero_grad()的位置：它必须在计算errG之前调用。因为errG的计算路径中包含了fake（由G生成），如果不先清空G的梯度，上一轮遗留的梯度会和本轮叠加，造成梯度爆炸。
3. D_G_z1和D_G_z2的区别：D_G_z1是D在“评估”假图时的输出（此时fake是detached的），反映D当前的判别水平；D_G_z2是G更新后，D对同一batch假图的最新输出，反映G的进步。监控这两个值的差距，是判断G/D是否平衡的最直观指标。理想状态是D_G_z1 ≈ D_G_z2 ≈ 0.5。

5. 常见问题与排查技巧实录：那些让我熬过凌晨三点的Bug

5.1 “Loss下降但图像全是噪点”——潜伏的梯度消失/爆炸

这是新手遇到的第一座大山。现象是：Loss_D和Loss_G都稳步下降，但TensorBoard里生成的图像始终是雪花屏。排查步骤如下：

独家心得：90%的此类问题，根子在BatchNorm。检查你的nn.BatchNorm2d是否在eval()模式下运行？训练时必须是train()！我曾在一个多GPU训练脚本里，不小心在DataParallel包装后调用了model.eval()，结果所有BN层冻结，G的输出变成常数，花了六个小时才定位。

5.2 “D的loss掉到0.01就卡住，G完全不学”——判别器过拟合

现象是：Loss_D在10个epoch内就跌破0.05，Loss_G却纹丝不动，D(G(z))稳定在0.0。这说明D已经强大到能把G生成的任何东西都秒杀，G彻底放弃抵抗。解决方案是“给D戴个镣铐”：

1. Dropout注入：在D的中间层（如第二、第三Conv2d后）加入nn.Dropout2d(0.3)。0.3是经验值，太高会削弱D能力，太低无效。
2. 谱归一化（Spectral Normalization）：这是最有效的“防过拟合”技术。它对D的每一层权重W施加约束：||W||_2 ≤ 1。PyTorch实现只需一行：from torch.nn.utils import spectral_norm，然后对D的每个Conv2d层应用spectral_norm(layer)。它能强制D学习更平滑、更泛化的判别边界。
3. 降低D的学习率：将optimizerD.lr设为optimizerG.lr的一半（如G用0.0002，D用0.0001）。让D的进化速度慢于G，给G留出生机。

5.3 “生成图像有明显棋盘格（checkerboard）”——反卷积的原罪

这是DCGAN时代最臭名昭著的伪影，表现为图像上规律的十字交叉网格。根源在于ConvTranspose2d的上采样算法。解决方案有三重保险：

1. 首选：用PixelShuffle替代。把ConvTranspose2d换成`nn.Conv2