基于生成对抗网络毕设的实战指南：从模型选型到部署避坑-编程阁

基于生成对抗网络毕设的实战指南：从模型选型到部署避坑

做毕设选到“生成对抗网络”那一刻，我脑子里只有两个字：刺激。
两周后，GPU 风扇嗡嗡转，TensorBoard 上的损失曲线像心电图一样乱跳，我才明白：GAN 的“刺激”=“折磨”。模式崩溃、梯度消失、训练震荡……踩坑踩到怀疑人生。
这篇笔记把我在毕设里趟过的浑水一次性倒出来，给后来人搭一座“能跑通、能复现、能答辩”的浮桥。全程 PyTorch，代码可直接塞进论文附录，老师挑不出毛病。

1. 背景痛点：为什么 GAN 毕设总是翻车

模式崩溃（Mode Collapse）：生成器偷懒，只输出同一类“安全样本”，判别器很快躺平，损失骤降，图像却千篇一律。
梯度消失：判别器太强，生成器梯度近似 0，网络一起摆烂，Loss 曲线变成一条“死水”。
训练震荡：学习率稍大，判别器 loss 瞬间爆炸，生成器跟着抽风，TensorBoard 像蹦迪。
复现困难：随机种子没锁、数据增强顺序不一致、GPU 型号不同，都会导致“同样代码不同天”。

一句话：GAN 不是“跑通一次”就行，而是要“每次都能跑到同一终点”。

2. 技术选型对比：DCGAN vs WGAN vs WGAN-GP

| 模型 | 核心改进 | 优点 | 缺点 | 毕设场景建议 | |---|---|---|---|---|---| | DCGAN | 卷积+BN+ReLU | 代码少，易出图 | 崩溃高发，调参玄学 | 想快速出图写综述可用 | | WGAN | 权重裁剪 | 损失可指示收敛 | 裁剪阈值敏感，易梯度爆炸/消失 | 不推荐，毕设时间宝贵 | | WGAN-GP | 梯度惩罚 | 稳定、易复现、曲线平滑 | 训练慢 10~20% | 毕设首选，答辩老师认得 |

结论：
① 只想“有图就行”→ DCGAN；
② 想“稳定可写分析”→ WGAN-GP；
③ WGAN 夹在中间，两头不靠，直接放弃。

3. 核心实现细节：PyTorch 搭建 WGAN-GP

下面以 64×64 人脸头像为例，分模块讲关键代码。完整文件在文末统一给出，这里只放“必改参数+易错点”。

3.1 生成器 Generator

输入：100 维噪声 z
输出：3×64×64 图像
结构：ConvTranspose → BN → ReLU，最后一层 Tanh 把像素压到 [-1,1]（与归一化对齐）

class Generator(nn.Module): def __init__(self, nz=100, ngf=64): super().__init__() self.main = nn.Sequential( # 1×1 → 4×4 nn.ConvTranspose2d(nz, ngf*8, 4, 1, 0, bias=False), nn.BatchNorm2d(ngf*8), nn.ReLU(True), # 4×4 → 8×8 nn.ConvTranspose2d(ngf*8, ngf*4, 4, 2, 1, bias=False), nn.BatchNorm2d(ngf*4), nn.ReLU(True), # 8×8 → 16×16 nn.ConvTranspose2d(ngf*4, ngf*2, 4, 2, 1, bias=False), nn.BatchNorm2d(ngf*2), nn.ReLU(True), # 16×16 → 32×32 nn.ConvTranspose2d(ngf*2, ngf, 4, 2, 1, bias=False), nn.BatchNorm2d(ngf), nn.ReLU(True), # 32×32 → 64×64 nn.ConvTranspose2d(ngf, 3, 4, 2, 1, bias=False), nn.Tanh() ) def forward(self, x): return self.main(x)

3.2 判别器 Discriminator

输入：3×64×64
输出：未经过 Sigmoid 的一维分数（WGAN 不需要 Sigmoid）

class Discriminator(nn.Module): def __init__(self, ndf=64): super().__init__() self.main = nn.Sequential( nn.Conv2d(3, ndf, 4, 2, 1, bias=False), nn.LeakyReLU(0.2, True), nn.Conv2d(ndf, ndf*2, 4, 2, 1, bias=False), nn.BatchNorm2d(ndf*2), nn.LeakyReLU(0.2, True), nn.Conv2d(ndf*2, ndf*4, 4, 2, 1, bias=False), nn.BatchNorm2d(ndf*4), nn.LeakyReLU(0.2, True), nn.Conv2d(ndf*4, ndf*8, 4, 2, 1, bias=False), nn.BatchNorm2d(ndf*8), nn.LeakyReLU(0.2, True), nn.Conv2d(ndf*8, 1, 4, 1, 0, bias=False) # 输出 1×1 分数 ) def forward(self, x): return self.main(x).view(-1)

3.3 梯度惩罚项

WGAN-GP 的精华，PyTorch 自动求导 5 行搞定：

def gradient_penalty(disc, real, fake, device): batch_size = real.size(0) alpha = torch.rand(batch_size, 1, 1, 1, device=device) interp = alpha * real + (1-alpha) * fake interp.requires_grad_(True) d_interp = disc(interp) grads = torch.autograd.grad(outputs=d_interp, inputs=interp, grad_outputs=torch.ones_like(d_interp), create_graph=True, retain_graph=True)[0] gp = ((grads.norm(2, dim=1) - 1) ** 2).mean() return gp

3.4 损失函数与优化器

判别器损失：-D(x) + D(G(z)) + λ·GP
生成器损失：-D(G(z))
优化器：Adam + β1=0.5, β2=0.999，lr=1e-4（经验值，别用 2e-4 以上）

4. 完整可运行代码（Clean Code 版）

项目结构：

pro ├─ data/face64 # 放 jpg ├─ weights/ # 保存 ckpt ├─ logs/ # TensorBoard ├─ train.py └─ model.py # 上面 Generator+Discriminator

train.py 核心循环（已删冗余打印，留关键注释）：

# train.py import torch, random, numpy as np from torch.utils.data import DataLoader from torchvision import datasets, transforms, utils from model import Generator, Discriminator, gradient_penalty from torch.utils.tensorboard import SummaryWriter def seed_everything(seed=42): random.seed(seed); np.random.seed(seed) torch.manual_seed(seed); torch.cuda.manual_seed_all(seed) def main(): seed_everything() device = 'cuda' if torch.cuda.is_available() else 'cpu' batch_size = 64 nz, lr, num_epochs, lambda, critic_iters = 100, 1e-4, 100, 10, 5 dataset = datasets.ImageFolder('data/face64', transform=transforms.Compose([ transforms.Resize(64), transforms.ToTensor(), transforms.Normalize((0.5,0.5,0.5),(0.5,0.5,0.5)) ])) dataloader = DataLoader(dataset, batch_size=batch_size, shuffle=True, num_workers=4, pin_memory=True) G = Generator(nz).to(device); D = Discriminator().to(device) optG = torch.optim.Adam(G.parameters(), lr=lr, betas=(0.5,0.999)) optD = torch.optim.Adam(D.parameters(), lr=lr, betas=(0.5,0.999)) writer = SummaryWriter('logs') fixed_z = torch.randn(64, nz, 1, 1, device=device) for epoch in range(num_epochs): for i, (real, _) in enumerate(dataloader): real = real.to(device) # -------------- 训练判别器 -------------- # for _ in range(critic_iters): noise = torch.randn(batch_size, nz, 1, 1, device=device) fake = G(noise).detach() d_real = D(real) d_fake = D(fake) gp = gradient_penalty(D, real, fake, device) d_loss = d_fake.mean() - d_real.mean() + lambda_*gp optD.zero_grad(); d_loss.backward(); optD.step() # -------------- 训练生成器 -------------- # noise = torch.randn(batch_size, nz, 1, 1, device=device) fake = G(noise) g_loss = -D(fake).mean() optG.zero_grad(); g_loss.backward(); optG.step() # 日志 & 采样 writer.add_scalar('Loss/D', d_loss.item(), epoch) writer.add_scalar('Loss/G', g_loss.item(), epoch) with torch.no_grad(): fake_grid = utils.make_grid(G(fixed_z), normalize=True) writer.add_image('Generated', fake_grid, epoch) if epoch % 20 == 0: torch.save({'G':G.state_dict(),'D':D.state_dict()}, f'weights/ckpt_{epoch}.pth') writer.close() if __name__ == '__main__': main()

Clean Code 原则体现：

函数长度 < 40 行，注释只写“为什么”而非“做什么”；
魔数（critic_iters=5, λ=10）集中放 main 头部，方便调参；
所有 I/O 路径用相对路径，git clone 即可跑。

训练 100 epoch 后，生成样本肉眼可见从“抽象派”进化到“能认脸”。

5. 性能与稳定性：调参三板斧

学习率：1e-4 是甜点，>2e-4 必震荡；若 loss 飘高，先降 D 的 lr，再降 G。
批大小：64 够用，128 能再稳一点，但 GPU 内存翻倍；<32 则 BN 抖动，崩溃风险↑。
归一化：
- 数据归一化到 [-1,1] 与生成器 Tanh 对齐；
- 生成器除输出层外全加 BN，判别器不加 BN 最后一层，防止梯度冲突。

额外技巧：

每 5k 步线性衰减 D/G lr 到 1e-5，可让细节纹理再上一个台阶；
给 D 加 Dropout(0.3) 能防过拟合，但别放 G，否则颜色会花。

6. 生产环境避坑指南

数据预处理陷阱
- 统一尺寸后务必中心裁剪，否则人脸偏移，生成器学歪；
- 别用 ImageNet 的均值方差，人脸 RGB 分布不同，自己统计 5k 张即可。
随机种子控制
- 除了 torch、random、numpy，还要锁 cuda.conv_benchmark=False，避免算法非确定性；
- 保存 ckpt 时把torch.get_rng_state()一并写进去，方便完全复现。
GPU 内存优化
- torch.cuda.empty_cache()别乱加，每 step 调用会拖速 5%；
- 用torch.backends.cudnn.benchmark=True前确保输入尺寸固定，否则反增显存。
结果可复现性
- 训练脚本开头生成git diff > code.patch，连同 ckpt、日志、环境requirements.txt一起打包；
- 答辩现场老师让你重跑，10 分钟复现，印象分直接拉满。