本节课你将学到
- GAN的基本原理和工作机制
- 使用PyTorch构建生成器和判别器
- DCGAN架构实现技巧
- 训练GAN模型的实用技巧
开始之前
环境要求
-
Python 3.8+
-
需要安装的包：
bashpip install torch torchvision matplotlib numpy -
GPU推荐（可大幅加速训练）
前置知识
- 第21讲TensorFlow基础
- 第23讲神经网络原理
- 基本PyTorch使用经验
核心概念
什么是GAN？
GAN就像艺术品鉴定师与伪造者的博弈：
-
生成器(Generator)：伪造者
- 试图创作逼真的假画作
- 从随机噪声开始，逐渐改进技术
-
判别器(Discriminator)：鉴定师
- 试图区分真品和赝品
- 随着伪造者技术进步，鉴定能力也提升
GAN训练过程
随机噪声 更新生成器 假图像 真实图像 更新判别器 真/假判断
DCGAN架构特点
- 生成器：使用转置卷积上采样
- 判别器：使用卷积下采样
- 去除全连接层
- 使用Batch Normalization
- LeakyReLU激活函数
代码实战
1. 导入库与配置
python
import torch
import torch.nn as nn
import torch.optim as optim
import torchvision
import torchvision.datasets as datasets
import torchvision.transforms as transforms
from torch.utils.data import DataLoader
import matplotlib.pyplot as plt
import numpy as np
# 设备配置
device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
print(f"使用设备: {device}")
# 超参数
lr = 0.0002
batch_size = 64
image_size = 64
channels_img = 1
z_dim = 100 # 噪声向量维度
num_epochs = 202. 准备数据集（MNIST）
python
# 数据预处理
transform = transforms.Compose([
transforms.Resize(image_size),
transforms.ToTensor(),
transforms.Normalize([0.5], [0.5]), # 归一化到[-1, 1]
])
# 下载并加载MNIST数据集
dataset = datasets.MNIST(
root="dataset/",
train=True,
transform=transform,
download=True
)
# 创建数据加载器
dataloader = DataLoader(dataset, batch_size=batch_size, shuffle=True)3. 构建生成器
python
class Generator(nn.Module):
def __init__(self, z_dim, channels_img, features_g):
super(Generator, self).__init__()
self.gen = nn.Sequential(
# 输入: z_dim x 1 x 1
self._block(z_dim, features_g * 16, 4, 1, 0), # 4x4
self._block(features_g * 16, features_g * 8, 4, 2, 1), # 8x8
self._block(features_g * 8, features_g * 4, 4, 2, 1), # 16x16
self._block(features_g * 4, features_g * 2, 4, 2, 1), # 32x32
nn.ConvTranspose2d(features_g * 2, channels_img, 4, 2, 1), # 64x64
nn.Tanh(), # 输出值在[-1,1]之间
)
def _block(self, in_channels, out_channels, kernel_size, stride, padding):
return nn.Sequential(
nn.ConvTranspose2d(
in_channels, out_channels, kernel_size, stride, padding, bias=False
),
nn.BatchNorm2d(out_channels),
nn.ReLU(),
)
def forward(self, x):
return self.gen(x)4. 构建判别器
python
class Discriminator(nn.Module):
def __init__(self, channels_img, features_d):
super(Discriminator, self).__init__()
self.disc = nn.Sequential(
# 输入: channels_img x 64 x 64
nn.Conv2d(channels_img, features_d, 4, 2, 1), # 32x32
nn.LeakyReLU(0.2),
self._block(features_d, features_d * 2, 4, 2, 1), # 16x16
self._block(features_d * 2, features_d * 4, 4, 2, 1), # 8x8
self._block(features_d * 4, features_d * 8, 4, 2, 1), # 4x4
nn.Conv2d(features_d * 8, 1, 4, 2, 0), # 1x1
nn.Sigmoid(), # 输出概率值
)
def _block(self, in_channels, out_channels, kernel_size, stride, padding):
return nn.Sequential(
nn.Conv2d(in_channels, out_channels, kernel_size, stride, padding, bias=False),
nn.BatchNorm2d(out_channels),
nn.LeakyReLU(0.2),
)
def forward(self, x):
return self.disc(x)5. 初始化模型与优化器
python
# 初始化模型
gen = Generator(z_dim, channels_img, 64).to(device)
disc = Discriminator(channels_img, 64).to(device)
# 初始化权重
def weights_init(m):
if isinstance(m, (nn.Conv2d, nn.ConvTranspose2d, nn.BatchNorm2d)):
nn.init.normal_(m.weight.data, 0.0, 0.02)
gen.apply(weights_init)
disc.apply(weights_init)
# 优化器
opt_gen = optim.Adam(gen.parameters(), lr=lr, betas=(0.5, 0.999))
opt_disc = optim.Adam(disc.parameters(), lr=lr, betas=(0.5, 0.999))
# 损失函数
criterion = nn.BCELoss()6. 训练循环
python
# 固定噪声用于可视化训练进展
fixed_noise = torch.randn(64, z_dim, 1, 1).to(device)
for epoch in range(num_epochs):
for batch_idx, (real, _) in enumerate(dataloader):
real = real.to(device)
batch_size = real.shape[0]
# 训练判别器
noise = torch.randn(batch_size, z_dim, 1, 1).to(device)
fake = gen(noise)
# 判别器对真实图像的预测
disc_real = disc(real).view(-1)
loss_disc_real = criterion(disc_real, torch.ones_like(disc_real))
# 判别器对生成图像的预测
disc_fake = disc(fake.detach()).view(-1)
loss_disc_fake = criterion(disc_fake, torch.zeros_like(disc_fake))
# 判别器总损失
loss_disc = (loss_disc_real + loss_disc_fake) / 2
disc.zero_grad()
loss_disc.backward()
opt_disc.step()
# 训练生成器
output = disc(fake).view(-1)
loss_gen = criterion(output, torch.ones_like(output))
gen.zero_grad()
loss_gen.backward()
opt_gen.step()
# 每100个batch打印一次
if batch_idx % 100 == 0:
print(
f"Epoch [{epoch}/{num_epochs}] Batch {batch_idx}/{len(dataloader)} "
f"Loss D: {loss_disc:.4f}, loss G: {loss_gen:.4f}"
)
# 每轮保存生成图像示例
with torch.no_grad():
fake = gen(fixed_noise)
img_grid = torchvision.utils.make_grid(fake[:32], normalize=True)
plt.imshow(np.transpose(img_grid.cpu(), (1, 2, 0)))
plt.axis("off")
plt.savefig(f"output/epoch_{epoch}.png")
plt.close()完整项目
项目结构：
dcgan_mnist/
├── train.py # 训练脚本
├── models.py # 模型定义
├── utils.py # 辅助函数
├── requirements.txt
├── output/ # 输出目录
└── README.mdrequirements.txt内容：
torch>=2.0.0
torchvision>=0.15.0
matplotlib>=3.7.0
numpy>=1.24.0运行效果
训练过程可视化
Epoch [0/20] Batch 0/938 Loss D: 0.6931, loss G: 0.6978
Epoch [0/20] Batch 100/938 Loss D: 0.0123, loss G: 5.4321
...
Epoch [20/20] Batch 800/938 Loss D: 0.5123, loss G: 1.2314常见问题
Q1: 模式崩溃(Mode Collapse)怎么办？
解决方案：
- 增加批次大小(
batch_size) - 使用Wasserstein GAN(WGAN)
- 尝试不同的学习率
- 添加多样性惩罚项
Q2: 判别器太强/太弱
平衡技巧：
- 太强：减少判别器更新频率
- 太弱：增加判别器容量
- 使用TTUR(Two Time-scale Update Rule)
Q3: 训练不稳定
稳定训练方法：
- 使用梯度惩罚(Gradient Penalty)
- 尝试不同的优化器参数
- 使用谱归一化(Spectral Normalization)
- 添加标签平滑(Label Smoothing)
课后练习
- 尝试生成彩色图像（如CIFAR-10）
- 实现条件GAN（生成指定数字）
- 尝试不同的GAN架构（如WGAN-GP）
- 使用GAN生成人脸（CelebA数据集）