从零手写GAN：生成对抗网络实战与调参避坑指南

在深度学习折腾一圈之后，我身边不少朋友一听到“生成对抗网络”这个词儿，第一反应就是“那玩意儿训练太玄学了，碰不得”。但真要把这个“玄学”解剖开，你会发现从零到实战跑通一个能生成图像的GAN，远没有传说中那么高不可攀。我前阵子拿Python从零手写了一遍GAN，从最朴素的损失函数开始，到后面调参调得手发麻，踩了一个又一个坑，最后看到生成的图像从一团雪花噪声慢慢变成能辨认出结构的数字时，那种兴奋感是真的有后劲。这篇就把我整个流程、代码细节以及踩过的坑，一次性给你拆开讲清楚。

1. 先搞懂GAN在做什么：一句话版原理

1.1 生成器和判别器的“猫鼠游戏”

说实话，GAN的核心思想特别朴素，就两个网络在互相“拉扯”。一个叫生成器（Generator），一个叫判别器（Discriminator）。生成器的工作是从一个随机噪声向量里“捏造”出一张图片，目的是骗过判别器；判别器的工作是分辨输入图片到底来自真实数据集，还是生成器伪造的。这就像做假钞的和验钞机之间的博弈：造假钞的越造越逼真，验钞机的鉴别能力也越练越强，两边最终在动态博弈中逐渐达到一个“制衡点”——生成器造出的图片以假乱真，判别器反而被逼得只能瞎猜。

这个博弈过程在数学上被描述成一个“极小极大博弈”（Minimax Game）。咱们不会陷进太深的数学推导，但你只需要记住一根主线：判别器想让自己的判别准确率尽量高，生成器想让自己的伪造尽量骗过判别器。二者在训练中交替优化，互相给对方“制造困难”，最终促使生成分布向真实分布靠拢。

1.2 为什么说代码实现比想象中简单

很多人被论文里的公式劝退，但落到代码上，GAN网络结构本身往往就是两个普通的多层感知机或者卷积网络。我这次用一个非常经典的MNIST手写数字数据集来做实战，网络用的就是最简单的全连接层结构。整份代码加数据加载加训练循环，大概也就两百多行。核心训练逻辑无非三个循环：先训判别器，再训生成器，然后不断往复。

注意：这里有个容易绕进去的点——不少人第一次看训练代码会懵，为什么判别器要把“真实图片+生成图片”凑成一个batch训练，而生成器只拿“假图片”去更新那个没标错部分的误差。你需要从“梯度传播路径”的角度去理解：生成器的参数不能直接拿真实图片的误差来更新，它只能通过判别器的反馈来间接优化。所以生成器输入是一堆随机噪声，输出是假图，然后让判别器评价这批假图，算出来的损失反传给生成器。

2. 环境准备与工具选型：把地基打扎实

2.1 依赖安装与版本选择

开始写代码前，先把环境收拾利索。我做这类小项目通常直接用PyTorch，因为它的动态图机制太贴合这种需要灵活调整的对抗训练逻辑了，调试时断点一打，中间张量一目了然。

我这次的环境配置如下：

• Python 3.8起
• PyTorch 1.10以上（你要是装2.0也完全没问题）
• torchvision用于加载MNIST数据集以及常见的图像变换
• matplotlib用于绘制训练过程中的图像变化
• numpy用于张量操作

安装命令没什么花活，直接一把梭：

bash复制pip install torch torchvision matplotlib numpy

服务器有CUDA的话就装对应GPU版本，没GPU用CPU也能跑。实测下来CPU跑一个小的全连接GAN，一个Epoch可能要半分钟左右，训练几十个Epoch之后生成效果已经能看出来个大概。对新手入门来说，CPU完全够用。

2.2 数据集准备：MNIST是最友好的起点

MNIST是28x28的单通道手写数字灰度图，简单干净，适合用来验证GAN训练流程。用torchvision自带的接口加载的话几十行就完事了。加载后我习惯做几个处理：

• 取值范围归一化到[-1, 1]。这个很关键，因为生成器输出一般经过tanh激活函数，取值范围天然在[-1, 1]，把真实数据也映射到同样的空间才能让判别器公平对比。
• 开启DataLoader的shuffle，防止训练时把同一类样本反复喂给判别器，导致判别器产生偏见。

python复制transform = transforms.Compose([
    transforms.ToTensor(),
    transforms.Normalize(mean=[0.5], std=[0.5])
])

dataset = torchvision.datasets.MNIST(
    root='./data',
    train=True,
    transform=transform,
    download=True
)

dataloader = torch.utils.data.DataLoader(
    dataset,
    batch_size=128,
    shuffle=True,
    num_workers=2
)

这里特意用了Normalize(mean=[0.5], std=[0.5])，可以让像素值从[0,1]映射到[-1,1]，与生成器tanh输出范围对齐。这个细节如果忽略，训练很可能会出现损失震荡。

3. 从零搭建网络核心代码

3.1 生成器网络：从噪声到图像的解码器

生成器本质上是把低维隐空间里的随机噪声映射到高维图像空间。噪声向量维度在本次实验中是128维。网络的层数不需要太深，三层全连接就能跑出非常可观的效果，但要保证一层带一层地“放大”维度。

我定义的生成器如下：

python复制class Generator(nn.Module):
    def __init__(self, noise_dim=128, output_dim=28*28):
        super(Generator, self).__init__()
        self.fc = nn.Sequential(
            nn.Linear(noise_dim, 256),
            nn.ReLU(True),
            nn.BatchNorm1d(256),
            nn.Linear(256, 512),
            nn.ReLU(True),
            nn.BatchNorm1d(512),
            nn.Linear(512, output_dim),
            nn.Tanh()
        )

    def forward(self, x):
        return self.fc(x)

这里两个细节值得敲黑板。

第一是BatchNorm。它的作用是稳定训练，让每一层输出的数据分布不至于在对抗过程中被扰动得过猛。特别在生成器里，如果不加BatchNorm，损失曲线基本就是心电图一样乱抖，图像质量也很难上去。你直接用全连接层不加这个也可以在玩具样本上出图，但那个效果和图质都肉眼可见地劣化。

第二是激活函数。中间层用ReLU（或LeakyReLU），输出层用Tanh。如果你把输出层换成ReLU或者sigmoid，会破坏图像值域匹配，导致判别器看到“真实样本”和“生成样本”的分布天然不一样，训练会变得特别费力。这一处是初学者最容易忽略的陷阱。

3.2 判别器网络：一个二分类器

判别器做的事就是二分类，输入是一张铺平的图像向量（长度为784），输出是0到1之间的“真伪概率”。我计划在模型里直接用线性层输出logits，训练时配合BCEWithLogitsLoss来计算损失，避免数值稳定性问题。

python复制class Discriminator(nn.Module):
    def __init__(self, input_dim=28*28):
        super(Discriminator, self).__init__()
        self.fc = nn.Sequential(
            nn.Linear(input_dim, 512),
            nn.LeakyReLU(0.2, inplace=True),
            nn.Linear(512, 256),
            nn.LeakyReLU(0.2, inplace=True),
            nn.Linear(256, 1)  # logit
        )

    def forward(self, x):
        return self.fc(x)

判别器这里我用LeakyReLU而不是ReLU，因为ReLU在负数区域完全截断，极易导致神经元死亡，而对抗训练本来就够不稳定了，没必要在这种地方给自己添堵。LeakyReLU留了一个小斜率（斜率0.2），保证了梯度在负数区域也能回传。判别器我故意没有加BatchNorm，这个做法并非绝对标准，但我们在后面结合训练策略再解释。

3.3 训练循环：对抗优化的完整拼图

重头戏在训练循环。我们定义两个独立优化器，分别伺候两个网络。推荐使用Adam优化器，因为它自适应的学习率在对抗博弈这种复杂的动态场景下，比SGD稳定不少。GAN训练有个著名的“经验配置”：学习率设为2e-4，beta1取0.5。默认Adam的beta1是0.9，但GAN训练时往往希望更“敏锐”地响应最近的梯度变化，所以把beta1调低，可以让训练初期更顺滑。

每轮迭代的内部逻辑如下：

1. 从DataLoader取一批真实图片，构造真标签为1，假标签为0。
2. 取随机噪声，用生成器生成假图。
3. 判别器分别判断真图和假图的logit。
4. 计算判别器损失，反向传播更新判别器。
5. 再来一轮噪声生成，判别器重新判断新生成图片的logit，并让判别器认为它们是真实的，然后反向传播更新生成器。

关键点在于第4步和第5步优化顺序，以及更新生成器时，判别器参数必须“冻结”——不是说你真的把参数置成requires_grad=False，而是通过detach()把从噪声到生成结果的梯度链路断开，或者通过合理组织代码使状态更新过程中不主动更新判别器。其实直接按标准写法，更新生成器时只调用optimizer_G.step()，不做optimizer_D.step()就可以做到。

训练循环代码段如下：

python复制criterion = nn.BCEWithLogitsLoss()

optimizer_G = torch.optim.Adam(generator.parameters(), lr=0.0002, betas=(0.5, 0.999))
optimizer_D = torch.optim.Adam(discriminator.parameters(), lr=0.0002, betas=(0.5, 0.999))

for epoch in range(num_epochs):
    for i, (imgs, _) in enumerate(dataloader):
        current_batch = imgs.size(0)
        real_imgs = imgs.view(current_batch, -1)

        # 随机噪声
        z = torch.randn(current_batch, noise_dim)
        fake_imgs = generator(z)

        # 训练判别器
        real_pred = discriminator(real_imgs)
        fake_pred = discriminator(fake_imgs.detach())

        real_loss = criterion(real_pred, torch.ones_like(real_pred))
        fake_loss = criterion(fake_pred, torch.zeros_like(fake_pred))
        loss_D = (real_loss + fake_loss) / 2

        optimizer_D.zero_grad()
        loss_D.backward()
        optimizer_D.step()

        # 训练生成器
        z = torch.randn(current_batch, noise_dim)
        fake_imgs = generator(z)
        fake_pred = discriminator(fake_imgs)
        loss_G = criterion(fake_pred, torch.ones_like(fake_pred))

        optimizer_G.zero_grad()
        loss_G.backward()
        optimizer_G.step()

判别器部分特意用了fake_imgs.detach()，这是训练循环中第一个必须铭记于心的关键细节。它代表当计算判别器对假图的损失时，网格中假图是从生成器传出来的，如果不加detach()，反向传播时梯度会同时传导到生成器的参数，这就搞乱了我们先单独优化判别器的初衷。我一开始就是因为忘了加这个，导致两个网络训练互相干扰，损失曲线直接原地起飞。

生成器部分重新采样了噪声z = torch.randn(...)，这么做的好处是让生成器每一步面对“新鲜”的噪声分布，避免它与前面判别器刚看过的假图产生记忆耦合，也能打破同一批噪声反复使用带来的路径依赖。

整个外层循环跑下来，训练过程是枯燥的，但每过几个Epoch我都会把生成器的输出保存一批图出来看一眼，一方面是监督进度，另一方面也是给自己一些即时正反馈。

4. 训练中的坑：我的调参经验与排查实录

4.1 模式崩溃：逼死人的死循环

几乎所有第一次从零手写GAN的人都撞上过“模式崩溃”。症状很典型：生成的图像从头到尾就是一个或几个数字在反复横跳，比如全输出相似的“5”或者相似的“1”，完全看不到多样性。

我这次也撞上了，而且断断续续调了两三天。最终定位下来最核心的原因是判别器训练得太好而生成器跟不上，或者反过来生成器只找到了损失函数的一个“漏洞”——它发现只要输出某种特定图案就能让当前判别器认为是真图，于是死抱着这个图案不放。

解决办法我用了几个组合拳：

• 给判别器加入Dropout，削弱它某种意义上的“统治力”。
• 调低判别器学习率，让生成器有时间喘息追赶。
• 每更新一次判别器就多更新几次生成器，人为拉平训练进度。
• 使用特征匹配、小批量判别等进阶方案（这个是在更深的调参中才上的手段）。

对于入门实验，最简单的方案是给两个网络设置不同学习率：生成器保持2e-4，判别器降到1e-4。别小看这一点参数差异，对抗博弈对平衡性极度敏感，谁强了就压谁一头通常能换来更多样的输出。

另外要注意“标签平滑（Label Smoothing）”。真实标签不要用死的1，而要用0.9左右的值，假标签用0.1而不是0。这样做可以让判别器预测分数走出饱和区，也不至于给生成器过于严苛的惩罚，缓解判别器过于自信后带来的梯度消失问题。

python复制real_target = torch.full_like(real_pred, 0.9)  # 平滑真实标签
fake_target = torch.zeros_like(fake_pred)      # 假样本保持0

也别平滑过头，弄成0.85或0.8会导致生成器压力变小，生成质量反而打折扣。

4.2 不收敛与损失爆炸：损失值不是唯一指标

我还遇到过一个非常迷惑的场景：训练Epoch数翻了一倍，损失曲线反而一直高位震荡，生成图像看不出任何进展。起初我盯着损失值干着急，后来意识到一个铁律——在GAN里，判别器和生成器的损失绝对值并不是良好的评估指标。因为它是两个玩家互相博弈的结果，判别器可以今天赢明天输，损失值在动态平衡中不断波动，没有一个稳定的收敛方向。更靠谱的指标是图像的视觉效果，或者借助FID、IS这类专业评估指标。

如果损失直接爆炸到NaN，基本就是梯度爆炸导致的。排查步骤我一般这样：

• 检查输入数据有没有NaN或异常值。
• 把学习率从2e-4降到1e-4甚至5e-5。
• 给生成器和判别器的输出层夹一个梯度裁剪或引入谱归一化。
• 确认损失函数输入输出形状匹配，确认目标值没有意外错位。

其中最坑的是BatchNorm在生成器里的行为。BatchNorm在训练阶段是按batch统计均值和方差的，而在生成或评估阶段是使用全局统计量的。如果batch size太小（比如16以下），这种统计量就非常不稳，会大幅加剧训练震荡。我的最小设置建议是batch size不低于64。

4.3 超参数选择速查表

下面这份表是我多次实验后认为最稳的起手配置，可以免得你从无限超参数海洋里挣扎：

这套配置不能说一定保证每轮都能得到完美图片，但至少可以让训练过程平稳落地，不会动不动崩溃。

4.4 常见问题与排查速查表

这些坑每个人大概率都要过一遍，踩过之后你对整个对抗优化机制的理解，会比看十篇论文都深。

5. 实战案例：GAN生成手写数字的效果演变

5.1 从头写一个随时保存中间状态的训练脚本

在写脚本时，除了把训练循环跑通，还有很重要的一环——保存结果。我一般每5个Epoch就会用固定的一组噪声向量重新生成一批图片，保存下来横向对比。用固定噪声的好处是她可以让你看到同一个隐空间位置上的“轨迹演变”，比每次随机噪声更能体现训练进度。

完整脚本结构大概是：

python复制def show_images(images, epoch, save_path):
    images = (images + 1) / 2  # 从[-1,1]还原到[0,1]
    grid = torchvision.utils.make_grid(images, nrow=10).permute(1, 2, 0)
    plt.imshow(grid.numpy())
    plt.axis('off')
    plt.savefig(f'{save_path}/epoch_{epoch}.png')
    plt.close()

训练中，每轮Epoch结束，调用这个函数把批量生成的图像存下来。我一般生成100张图（10x10网格），一眼能看到多样性是否上去。这个可视化习惯真的特别重要，因为只看Loss曲线你根本不知道模型到底学到了什么。

5.2 训练过程中的视觉演变观察

我清晰记得第10个Epoch左右，生成的图像基本还是一片模糊的灰度噪点，但中央区域已经出现了隐隐约约的笔画结构。到第30个Epoch左右，数字轮廓开始能辨认出来了，笔画边缘带着一层毛刺和雾状感。到第60个Epoch，画面清爽了很多，能看出不同数字的姿态变化，只不过部分数字会互相混淆，比如“3”和“8”偶尔长得很像。直到第100个Epoch，生成图像在肉眼下与真实MNIST样本差异已经非常小，除了偶尔几张略显歪斜，整体效果足够拿得出手。

这也是GAN最神奇的地方：它并不需要“见过全部真实图片的精确复制”，而是从真实样本的统计规律中学会了怎么“画”新数字。如果拿生成器多采样几批，你几乎不会在输出中看到和训练集一模一样的那张原图，看到的其实是模型脑补出的各类变体。

5.3 用插值观察潜在空间

在我觉得效果差不多稳定的时候，我做了一个特别有意思的小实验——在噪声空间里把两个随机向量做线性插值，观察生成图像的变化。比如取一个能生成“0”的噪声向量和一个能生成“6”的噪声向量，在它们之间做20步逐渐过渡，结果就能看到数字从“0”平滑变形为“6”的过程。这说明GAN在隐空间里学到的是连续且有结构的语义表示，而不是简单的记忆映射。这种线性插值能力算是GAN训练成功的最直观证明之一，大家跑通之后强烈建议试试，视觉效果超有说服力。

插值代码非常简单：

python复制z1 = torch.randn(1, noise_dim)
z2 = torch.randn(1, noise_dim)
steps = 20
interpolated = []
for alpha in np.linspace(0, 1, steps):
    z = (1 - alpha) * z1 + alpha * z2
    with torch.no_grad():
        img = generator(z).view(28, 28)
    interpolated.append(img)

把这些图像拼起来保存成一张横向长图，你会看到笔画如何从一个形状平滑地流向另一个形状。这个结果往往比所谓“精准实测指标”更能让人直观理解生成模型的价值。

6. 从Mini走向实战：发散创新的方向

6.1 给生成器加条件：CGAN

当你已经能生成像样的MNIST数字时，下一步我建议试试条件生成对抗网络（Conditional GAN），简称CGAN。做法并不复杂，只需把类别标签（比如数字“7”）拼接到生成器和判别器的输入里。生成器输入变成“噪声+标签”，判别器输入变成“图像+标签”。这样网络就能学会按指定类别输出你想要的内容，而不是只给你随机数字。

这种“加条件”的思路在真实业务中价值极大。比如风格迁移任务里，可以把“风格类别”当作条件输入；在图像修复中，可以把“遮挡区域”的条件输进去。CGAN是我觉得“从玩具到实战”最重要的一座桥，没有之一。

条件输入的具体实现一般是先用nn.Embedding把类别索引转成嵌入向量，然后与噪声在特征维度上拼接：

python复制label_embed = nn.Embedding(num_classes=10, embedding_dim=10)
z = torch.cat([noise, label_embed(label)], dim=1)

后面的网络结构无需大的改动，只要把第一层的输入维度调整为noise_dim + embedding_dim即可。

6.2 让训练更稳定的WGAN思想

如果CGAN还不能满足你，下一步就是解决GAN训练稳定性之痛——WGAN。WGAN的核心改动非常简单：把判别器输出的“概率”（0到1之间）换成“一个打分”（可以是任意实数，即Critic），损失函数改成Wasserstein距离的近似形式，同时为了满足Lipschitz约束，要么对参数做权重裁剪（WGAN原始做法），要么用梯度惩罚（WGAN-GP）。

改成WGAN-GP后，训练过程的稳定性会肉眼可见地提升：模式崩溃几乎不再发生，生成图像质量也更干净，不再需要小心翼翼地调整两个网络的学习率平衡。代码上主要改动的是损失计算和加入了梯度惩罚项。

我在入门阶段用过这个小改动去训练更复杂的图像数据集，比直接硬怼DCGAN的默认参数要省心许多。如果你的目标是“实战”，我建议从第二个项目就切换到WGAN-GP，它抗造。

6.3 从图像生成走向多模态

GAN不止能做图片。它在风格迁移、超分辨率、数据增强、音频合成等场景都有应用基础。在实际业务中，我最看好的场景是“数据增强”：当手里的正样本少得可怜时，训练一个GAN来扩充数据集，让分类模型在合成样本和真实样本混合的数据上重新训练，有时能取得意想不到的泛化提升。

当然，这并不意味着合成数据能完全替代真实数据，它更适合作为补充。尤其在语义分割或医学影像等标注成本极高的方向，GAN辅助生成预训练样本的思路已经有不少落地验证。

7. 最后再分享一点实战小技巧

我自己从零手写GAN最大的体会是：先跑通最小案例，再谈优化，最后才谈创新。很多人一上来就直奔DCGAN或StyleGAN，结果网络结构复杂到一定程度后，出了问题根本不知道哪一环出了篓子——网络不收敛到底该先怀疑损失函数、数据预处理、激活函数、还是优化器？在复杂模型里排查这些问题是灾难性的。用全连接GAN跑通MNIST，把整个训练回路上的每个细节都摸清，后面切换到任何先进结构都不至于毫无头绪。

另外在训练过程中，要养成定期保存checkpoint的好习惯，我通常每个Epoch都保存一次，不是为了显摆，而是因为某一个Epoch里可能就藏着训练效果最好的中间产物。GAN训练在后期有时会出现“过拟合式退化”，突然生成质量走下坡路，能从checkpoint里找回最佳状态非常重要。

最后提醒一句：实验过程中多尝试改变噪声分布方差、改变随机种子，让每次实验之间有点扰动，这能帮你积累不少对GAN训练“手感”的直觉，光靠看教程很难换来这种经验。

训练跑通的成就感，真的只有自己亲手坐在屏幕前盯着图像一点点从噪点变成数字时才体验得到。希望这篇细节拉满的实战手记，能帮你把“调参地狱”熬过去。