PyTorch实战:用GAN生成MNIST手写数字的5个常见错误与解决方案
第一次用PyTorch实现GAN生成MNIST手写数字时,那种兴奋感至今记忆犹新。看着代码跑起来,损失函数开始下降,满心期待能生成出像模像样的数字图片。但现实往往很骨感——生成器要么输出一堆模糊的噪点,要么反复生成同一个数字,甚至训练到一半损失直接爆炸。如果你也遇到过这些情况,别担心,这几乎是每个GAN新手必经的“入门仪式”。
MNIST作为深度学习界的“Hello World”,看似简单,但在GAN的世界里却是个绝佳的试金石。28x28的灰度图像,10个数字类别,数据量适中,训练速度快,这些特性让它成为理解GAN训练动态的最佳实验场。然而,正是这种看似简单的任务,反而更容易暴露GAN训练中的各种陷阱。
今天我们不谈那些高大上的理论推导,就从最实际的代码层面出发,聊聊我在实践中踩过的坑,以及如何一步步解决它们。无论你是刚接触GAN的新手,还是已经有一定经验但总在某些问题上卡壳的开发者,相信这些经验能帮你少走弯路。
1. 模式崩溃:为什么我的生成器只会画“8”?
模式崩溃大概是GAN训练中最让人头疼的问题之一。你满怀期待地运行了几十个epoch,结果发现生成器输出的图片全是同一个数字,或者几种数字的混合体,完全没有多样性。更糟糕的是,这种情况一旦发生,往往很难自我修复。
1.1 现象识别与根本原因
模式崩溃的本质是生成器找到了一个“局部最优解”——它发现只要生成某一种特定模式(比如数字“8”),就能轻易骗过当前的判别器。一旦陷入这种状态,生成器就没有动力去探索其他模式了。
我在早期实验中遇到过这样的情况:训练到第50个epoch时,生成器突然开始只输出模糊的“8”字形,而且随着训练继续,这个“8”变得越来越清晰,但其他数字完全消失。检查损失函数曲线,会发现生成器损失持续下降,判别器损失则波动剧烈。
# 典型的模式崩溃现象检查代码
def check_mode_collapse(generated_images, epoch):
"""
检查是否存在模式崩溃
generated_images: 当前批次生成的所有图像
epoch: 当前训练轮次
"""
# 计算生成图像的多样性指标
pixel_variance = torch.var(generated_images, dim=0).mean().item()
image_similarity = F.cosine_similarity(generated_images, generated_images.mean(dim=0, keepdim=True)).mean().item()
print(f"Epoch {epoch}:")
print(f" 像素方差: {pixel_variance:.6f}")
print(f" 图像相似度: {image_similarity:.4f}")
# 如果像素方差过低或相似度过高,可能发生了模式崩溃
if pixel_variance < 0.01 or image_similarity > 0.95:
print(" ⚠️ 警告:检测到可能的模式崩溃迹象")
return True
return False
1.2 实用解决方案
方案一:调整训练节奏
模式崩溃往往发生在判别器过于强大时。一个简单的策略是让生成器多训练几步,或者让判别器少训练几步。在实践中,我发现一个不错的平衡点是每训练判别器1-2次,训练生成器1次。
# 调整训练节奏的代码示例
for epoch in range(num_epochs):
for i, (real_images, _) in enumerate(dataloader):
# 训练判别器
optimizer_D.zero_grad()
# 真实图像损失
real_validity = discriminator(real_images)
real_loss = adversarial_loss(real_validity, valid_labels)
# 生成图像损失
z = torch.randn(batch_size, latent_dim)
fake_images = generator(z)
fake_validity = discriminator(fake_images.detach())
fake_loss = adversarial_loss(fake_validity, fake_labels)
d_loss = (real_loss + fake_loss) / 2
d_loss.backward()
optimizer_D.step()
# 每训练判别器2次,训练生成器1次
if i % 2 == 0:
optimizer_G.zero_grad()
z = torch.randn(batch_size, latent_dim)
gen_images = generator(z)
validity = discriminator(gen_images)
g_loss = adversarial_loss(validity, valid_labels)
g_loss.backward()
optimizer_G.step()
方案二:使用特征匹配损失
特征匹配是Ian Goodfellow在2016年提出的技巧,它要求生成器不仅要骗过判别器,还要让生成图像在判别器的中间层特征上与真实图像相似。
class GeneratorWithFeatureMatching(nn.Module):
def __init__(self, latent_dim=100):
super().__init__()
# 生成器网络结构...
def forward(self, z):
# 前向传播...
return generated_images
def feature_matching_loss(self, real_features, fake_features):
"""
计算特征匹配损失
real_features: 真实图像在判别器中间层的特征
fake_features: 生成图像在判别器中间层的特征
"""
# 使用L2距离
loss = F.mse_loss(fake_features, real_features.detach())
return loss
# 在训练循环中添加特征匹配损失
real_features = discriminator.get_intermediate_features(real_images)
fake_features = discriminator.get_intermediate_features(fake_images)
fm_loss = generator.feature_matching_loss(real_features, fake_features)
total_g_loss = g_loss + 0.1 * fm_loss # 添加权重系数
方案三:尝试不同的GAN变体
如果标准GAN实在难以训练,可以考虑使用更稳定的变体:
| GAN变体 | 核心改进 | 适用场景 | MNIST上的表现 |
|---|---|---|---|
| WGAN-GP | 使用Wasserstein距离+梯度惩罚 | 稳定性要求高 | ★★★★★ |
| LSGAN | 最小二乘损失 | 简单易实现 | ★★★★☆ |
| DCGAN | 卷积结构 | 图像生成 | ★★★★☆ |
| BEGAN | 平衡训练 | 避免模式崩溃 | ★★★★☆ |
提示:对于MNIST这样的简单数据集,WGAN-GP通常能提供最稳定的训练过程,虽然计算开销稍大,但值得投入。
1.3 监控与早期干预
建立有效的监控机制可以在模式崩溃发生前就采取措施:
- 多样性指标监控:定期计算生成图像的熵或互信息
- 历史样本对比:保存每个epoch的生成样本,直观比较多样性变化
- 损失曲线分析:关注判别器损失是否过早趋近于0
# 建立监控系统
class GANTrainMonitor:
def __init__(self, save_dir="monitor_results"):
self.save_dir = save_dir
os.makedirs(save_dir, exist_ok=True)
self.history = {
'd_loss': [], 'g_loss': [],
'diversity_score': [], 'inception_score': []
}
def update(self, epoch, d_loss, g_loss, generated_images):
# 记录损失
self.history['d_loss'].append(d_loss)
self.history['g_loss'].append(g_loss)
# 计算多样性得分
diversity = self.calculate_diversity(generated_images)
self.history['diversity_score'].append(diversity)
# 保存样本用于可视化
if epoch % 10 == 0:
self.save_sample_images(generated_images, epoch)
# 检查异常
if self.detect_anomaly():
print(f"Epoch {epoch}: 检测到训练异常,建议调整超参数")
def calculate_diversity(self, images):
"""计算生成图像的多样性得分"""
# 简单实现:计算批次内图像的标准差
std_per_pixel = images.std(dim=0)
diversity = std_per_pixel.mean().item()
return diversity
2. 训练不稳定:损失函数像过山车一样波动
GAN训练的不稳定性是出了名的。你可能经常看到这样的场景:前一个epoch还一切正常,下一个epoch损失就突然爆炸;或者生成器和判别器的损失交替上升下降,始终无法收敛。
2.1 损失函数的选择与调整
标准的二元交叉熵损失在GAN训练中可能过于激进。一个常见的改进是使用带有标签平滑的损失函数,这能防止判别器变得过于自信。
# 改进的损失函数实现
class ImprovedAdversarialLoss:
def __init__(self, label_smoothing=0.1):
self.label_smoothing = label_smoothing
self.bce = nn.BCELoss()
def discriminator_loss(self, real_pred, fake_pred):
# 真实标签添加噪声
real_labels = torch.ones_like(real_pred) * (1 - self.label_smoothing)
fake_labels = torch.zeros_like(fake_pred) + self.label_smoothing
real_loss = self.bce(real_pred, real_labels)
fake_loss = self.bce(fake_pred, fake_labels)
return (real_loss + fake_loss) / 2
def generator_loss(self, fake_pred):
# 生成器希望判别器认为假图像是真的
target_labels = torch.ones_like(fake_pred) * (1 - self.label_smoothing)
return self.bce(fake_pred, target_labels)
# 使用示例
loss_fn = ImprovedAdversarialLoss(label_smoothing=0.1)
d_loss = loss_fn.discriminator_loss(real_validity, fake_validity)
g_loss = loss_fn.generator_loss(fake_validity_for_g)
2.2 优化器的选择与参数调优
Adam优化器是GAN训练的首选,但它的超参数需要仔细调整。我通过大量实验总结出了以下经验:
# 优化器配置对比
def setup_optimizers(generator, discriminator, lr=0.0002, beta1=0.5, beta2=0.999):
"""
设置生成器和判别器的优化器
参数选择基于经验:
- lr: 0.0001-0.0002通常效果较好
- beta1: 0.5比默认的0.9更适合GAN
- beta2: 保持0.999
"""
opt_g = torch.optim.Adam(
generator.parameters(),
lr=lr,
betas=(beta1, beta2)
)
opt_d = torch.optim.Adam(
discriminator.parameters(),
lr=lr * 0.5, # 判别器学习率稍低
betas=(beta1, beta2)
)
return opt_g, opt_d
# 学习率调度策略
def get_lr_scheduler(optimizer, total_epochs):
"""
使用余弦退火学习率调度
在GAN训练中,学习率逐渐降低有助于后期稳定
"""
scheduler = torch.optim.lr_scheduler.CosineAnnealingLR(
optimizer,
T_max=total_epochs,
eta_min=1e-6 # 最小学习率
)
return scheduler
2.3 梯度裁剪与归一化
梯度爆炸是训练不稳定的主要原因之一。以下是一些实用的梯度控制技巧:
# 梯度裁剪实现
def train_with_gradient_clipping(generator, discriminator,
dataloader, num_epochs,
clip_value=0.01):
for epoch in range(num_epochs):
for real_images, _ in dataloader:
# 训练判别器
optimizer_D.zero_grad()
# ... 计算损失 ...
d_loss.backward()
# 梯度裁剪
torch.nn.utils.clip_grad_norm_(
discriminator.parameters(),
clip_value
)
optimizer_D.step()
# 训练生成器
optimizer_G.zero_grad()
# ... 计算损失 ...
g_loss.backward()
# 梯度裁剪
torch.nn.utils.clip_grad_norm_(
generator.parameters(),
clip_value
)
optimizer_G.step()
# 每10个epoch检查梯度范数
if epoch % 10 == 0:
grad_norms = []
for param in generator.parameters():
if param.grad is not None:
grad_norms.append(param.grad.norm().item())
avg_grad_norm = sum(grad_norms) / len(grad_norms)
print(f"Epoch {epoch}: 平均梯度范数 = {avg_grad_norm:.6f}")
if avg_grad_norm > 10.0:
print("⚠️ 梯度范数过大,考虑减小学习率或增加裁剪阈值")
2.4 批归一化与层归一化的选择
在GAN中,归一化层的选择对训练稳定性有显著影响:
class StableGenerator(nn.Module):
def __init__(self, latent_dim=100, use_batchnorm=True):
super().__init__()
self.main = nn.Sequential(
# 第一层
nn.Linear(latent_dim, 256),
self._get_norm_layer(256, use_batchnorm),
nn.LeakyReLU(0.2, inplace=True),
# 第二层
nn.Linear(256, 512),
self._get_norm_layer(512, use_batchnorm),
nn.LeakyReLU(0.2, inplace=True),
# 第三层
nn.Linear(512, 1024),
self._get_norm_layer(1024, use_batchnorm),
nn.LeakyReLU(0.2, inplace=True),
# 输出层
nn.Linear(1024, 28*28),
nn.Tanh()
)
def _get_norm_layer(self, num_features, use_batchnorm):
"""根据条件返回归一化层"""
if use_batchnorm:
return nn.BatchNorm1d(num_features, momentum=0.8)
else:
return nn.LayerNorm(num_features)
def forward(self, z):
img = self.main(z)
img = img.view(img.size(0), 1, 28, 28)
return img
注意:在生成器的输出层和判别器的输入层通常不使用归一化,这有助于保持梯度的流动。
3. 生成质量差:图片模糊、噪声多、不像数字
即使训练过程看起来稳定,生成的图像质量也可能不尽如人意。模糊、噪声、结构不清晰是常见问题。
3.1 网络架构的优化
对于MNIST这样的简单图像,全连接网络可能就足够了,但卷积网络通常能产生更好的结果。以下是两种架构的对比:
# 全连接网络(简单但效果有限)
class SimpleGenerator(nn.Module):
def __init__(self, latent_dim=100):
super().__init__()
self.model = nn.Sequential(
nn.Linear(latent_dim, 128),
nn.LeakyReLU(0.2),
nn.Linear(128, 256),
nn.BatchNorm1d(256),
nn.LeakyReLU(0.2),
nn.Linear(256, 512),
nn.BatchNorm1d(512),
nn.LeakyReLU(0.2),
nn.Linear(512, 1024),
nn.BatchNorm1d(1024),
nn.LeakyReLU(0.2),
nn.Linear(1024, 28*28),
nn.Tanh()
)
def forward(self, z):
img = self.model(z)
return img.view(-1, 1, 28, 28)
# 卷积网络(DCGAN风格,效果更好)
class DCGANGenerator(nn.Module):
def __init__(self, latent_dim=100):
super().__init__()
self.init_size = 7 # 初始特征图大小
self.l1 = nn.Sequential(
nn.Linear(latent_dim, 128 * self.init_size ** 2)
)
self.conv_blocks = nn.Sequential(
nn.BatchNorm2d(128),
nn.Upsample(scale_factor=2),
nn.Conv2d(128, 128, 3, stride=1, padding=1),
nn.BatchNorm2d(128, 0.8),
nn.LeakyReLU(0.2, inplace=True),
nn.Upsample(scale_factor=2),
nn.Conv2d(128, 64, 3, stride=1, padding=1),
nn.BatchNorm2d(64, 0.8),
nn.LeakyReLU(0.2, inplace=True),
nn.Conv2d(64, 1, 3, stride=1, padding=1),
nn.Tanh()
)
def forward(self, z):
out = self.l1(z)
out = out.view(out.shape[0], 128, self.init_size, self.init_size)
img = self.conv_blocks(out)
return img
3.2 激活函数的选择
激活函数的选择对生成质量有直接影响。以下是我在MNIST生成任务中的经验总结:
| 激活函数 | 在生成器中的表现 | 在判别器中的表现 | 适用场景 |
|---|---|---|---|
| ReLU | 可能导致梯度消失 | 不推荐 | 一般不用于GAN |
| LeakyReLU | 效果良好 | 效果优秀 | 默认选择 |
| Tanh | 输出层常用 | 不适用 | 将输出限制在[-1,1] |
| Sigmoid | 不推荐 | 输出层用于二分类 | 判别器输出层 |
| ELU | 平滑性好 | 训练稳定 | 高质量生成 |
# 使用LeakyReLU的改进版本
class ImprovedLeakyReLU(nn.Module):
"""带可学习参数的LeakyReLU"""
def __init__(self, negative_slope=0.2, inplace=False):
super().__init__()
self.negative_slope = nn.Parameter(
torch.tensor(negative_slope)
)
self.inplace = inplace
def forward(self, x):
return F.leaky_relu(
x,
negative_slope=self.negative_slope.item(),
inplace=self.inplace
)
def extra_repr(self):
return f'negative_slope={self.negative_slope.item():.3f}'
3.3 输入噪声的分布与维度
潜在向量的分布和维度对生成质量有重要影响:
class NoiseSampler:
"""改进的噪声采样策略"""
def __init__(self, latent_dim=100, distribution='normal'):
self.latent_dim = latent_dim
self.distribution = distribution
def sample(self, batch_size, device='cuda'):
"""采样噪声向量"""
if self.distribution == 'normal':
# 标准正态分布
return torch.randn(batch_size, self.latent_dim, device=device)
elif self.distribution == 'uniform':
# 均匀分布
return torch.rand(batch_size, self.latent_dim, device=device) * 2 - 1
elif self.distribution == 'spherical':
# 球面分布,有助于提高多样性
z = torch.randn(batch_size, self.latent_dim, device=device)
return z / z.norm(dim=1, keepdim=True)
elif self.distribution == 'truncated_normal':
# 截断正态分布,避免极端值
z = torch.randn(batch_size, self.latent_dim, device=device)
return torch.clamp(z, -2, 2)
else:
raise ValueError(f"不支持的分布类型: {self.distribution}")
def interpolate(self, z1, z2, steps=10):
"""在两个噪声向量间插值"""
alphas = torch.linspace(0, 1, steps, device=z1.device)
interpolated = []
for alpha in alphas:
z = alpha * z1 + (1 - alpha) * z2
interpolated.append(z)
return torch.stack(interpolated)
# 使用示例
sampler = NoiseSampler(latent_dim=100, distribution='truncated_normal')
noise = sampler.sample(batch_size=64)
# 测试不同潜在维度的影响
def test_latent_dimensions():
"""测试不同潜在维度对生成质量的影响"""
dims = [10, 25, 50, 100, 200]
results = {}
for dim in dims:
print(f"\n测试潜在维度: {dim}")
generator = Generator(latent_dim=dim)
sampler = NoiseSampler(latent_dim=dim)
# 训练并评估...
# 记录生成质量指标
results[dim] = {
'fid_score': fid,
'inception_score': is_score,
'diversity': diversity
}
return results
3.4 数据预处理与归一化
正确的数据预处理可以显著提升生成质量:
def get_mnist_transforms(normalize=True, augment=False):
"""
获取MNIST数据预处理流程
normalize: 是否归一化到[-1, 1]
augment: 是否使用数据增强
"""
transforms_list = [
transforms.Resize(28),
transforms.ToTensor(),
]
if augment:
# 轻微的数据增强
transforms_list.insert(1, transforms.RandomRotation(5))
transforms_list.insert(2, transforms.RandomAffine(
degrees=0, translate=(0.05, 0.05)
))
if normalize:
# 归一化到[-1, 1],与Tanh输出匹配
transforms_list.append(transforms.Normalize([0.5], [0.5]))
else:
# 归一化到[0, 1]
transforms_list.append(transforms.Normalize([0.5], [0.5]))
return transforms.Compose(transforms_list)
# 对比不同归一化策略
def compare_normalization_strategies():
"""比较不同归一化策略的效果"""
strategies = {
'none': transforms.Compose([
transforms.ToTensor()
]),
'zero_one': transforms.Compose([
transforms.ToTensor()
]), # 已经是[0,1]
'neg_one_one': transforms.Compose([
transforms.ToTensor(),
transforms.Normalize([0.5], [0.5])
]),
'imagenet_style': transforms.Compose([
transforms.ToTensor(),
transforms.Normalize([0.485], [0.229]) # ImageNet的均值和标准差
])
}
results = {}
for name, transform in strategies.items():
print(f"\n测试归一化策略: {name}")
# 使用该策略训练GAN...
# 评估生成质量
results[name] = evaluate_quality()
return results
4. 判别器过强或过弱:训练平衡的艺术
GAN训练的核心在于生成器和判别器之间的动态平衡。判别器太强,生成器学不到东西;判别器太弱,生成器学到的分布不准确。
4.1 诊断判别器状态
首先需要准确判断判别器的状态:
class DiscriminatorMonitor:
"""监控判别器状态的工具类"""
def __init__(self):
self.history = {
'real_accuracy': [],
'fake_accuracy': [],
'confidence_real': [],
'confidence_fake': []
}
def update(self, real_pred, fake_pred, threshold=0.5):
"""
更新监控指标
real_pred: 对真实图像的预测概率
fake_pred: 对生成图像的预测概率
"""
# 计算准确率
real_acc = (real_pred > threshold).float().mean().item()
fake_acc = (fake_pred < threshold).float().mean().item()
# 计算置信度
real_conf = real_pred.mean().item()
fake_conf = fake_pred.mean().item()
self.history['real_accuracy'].append(real_acc)
self.history['fake_accuracy'].append(fake_acc)
self.history['confidence_real'].append(real_conf)
self.history['confidence_fake'].append(fake_conf)
def get_status(self):
"""获取判别器当前状态"""
if len(self.history['real_accuracy']) < 10:
return "收集数据中..."
recent_real_acc = np.mean(self.history['real_accuracy'][-10:])
recent_fake_acc = np.mean(self.history['fake_accuracy'][-10:])
if recent_real_acc > 0.9 and recent_fake_acc > 0.9:
return "判别器过强"
elif recent_real_acc < 0.6 and recent_fake_acc < 0.6:
return "判别器过弱"
elif abs(recent_real_acc - recent_fake_acc) > 0.3:
return "判别器不平衡"
else:
return "判别器状态良好"
def suggest_action(self):
"""根据状态给出调整建议"""
status = self.get_status()
suggestions = {
"判别器过强": [
"降低判别器学习率",
"减少判别器训练次数",
"增加生成器训练次数",
"使用标签平滑",
"添加判别器梯度惩罚"
],
"判别器过弱": [
"增加判别器层数",
"提高判别器学习率",
"增加判别器训练次数",
"减少生成器训练次数",
"使用更复杂的判别器架构"
],
"判别器不平衡": [
"检查数据预处理",
"调整真实和生成样本的权重",
"使用不同的优化器参数",
"添加谱归一化"
]
}
return suggestions.get(status, ["继续当前训练"])
4.2 动态调整训练策略
根据判别器的状态动态调整训练策略:
class AdaptiveTrainingScheduler:
"""自适应训练调度器"""
def __init__(self,
initial_d_steps=1,
initial_g_steps=1,
initial_lr_d=0.0002,
initial_lr_g=0.0002):
self.d_steps = initial_d_steps
self.g_steps = initial_g_steps
self.lr_d = initial_lr_d
self.lr_g = initial_lr_g
self.monitor = DiscriminatorMonitor()
# 历史记录
self.adjustment_history = []
def adjust_training(self, real_pred, fake_pred, epoch):
"""根据监控结果调整训练策略"""
self.monitor.update(real_pred, fake_pred)
status = self.monitor.get_status()
adjustments = []
if status == "判别器过强":
if self.d_steps > 1:
self.d_steps -= 1
adjustments.append(f"减少判别器训练步数到 {self.d_steps}")
if self.lr_d > 1e-5:
self.lr_d *= 0.8
adjustments.append(f"降低判别器学习率到 {self.lr_d:.6f}")
if self.g_steps < 3:
self.g_steps += 1
adjustments.append(f"增加生成器训练步数到 {self.g_steps}")
elif status == "判别器过弱":
if self.d_steps < 5:
self.d_steps += 1
adjustments.append(f"增加判别器训练步数到 {self.d_steps}")
if self.lr_d < 0.001:
self.lr_d *= 1.2
adjustments.append(f"提高判别器学习率到 {self.lr_d:.6f}")
elif status == "判别器不平衡":
# 尝试调整样本权重
adjustments.append("启用样本权重调整")
if adjustments:
print(f"Epoch {epoch}: {status}")
print("调整措施:", " | ".join(adjustments))
self.adjustment_history.append({
'epoch': epoch,
'status': status,
'adjustments': adjustments,
'd_steps': self.d_steps,
'g_steps': self.g_steps,
'lr_d': self.lr_d,
'lr_g': self.lr_g
})
return self.d_steps, self.g_steps, self.lr_d, self.lr_g
def get_training_schedule(self, epoch, batch_idx):
"""获取当前批次的训练计划"""
# 可以根据epoch和batch动态调整
if epoch < 10:
# 初期:更多关注判别器
current_d_steps = min(self.d_steps + 1, 3)
current_g_steps = max(self.g_steps - 1, 1)
elif epoch < 50:
# 中期:平衡训练
current_d_steps = self.d_steps
current_g_steps = self.g_steps
else:
# 后期:更多关注生成器
current_d_steps = max(self.d_steps - 1, 1)
current_g_steps = min(self.g_steps + 1, 3)
return current_d_steps, current_g_steps
4.3 使用梯度惩罚
梯度惩罚是WGAN-GP中的关键技术,能有效防止判别器过强:
def compute_gradient_penalty(discriminator, real_images, fake_images):
"""
计算梯度惩罚项
参考:WGAN-GP (Gulrajani et al., 2017)
"""
batch_size = real_images.size(0)
device = real_images.device
# 在真实和生成图像之间随机插值
alpha = torch.rand(batch_size, 1, 1, 1, device=device)
alpha = alpha.expand_as(real_images)
interpolated = alpha * real_images + (1 - alpha) * fake_images
interpolated.requires_grad_(True)
# 计算判别器对插值图像的输出
d_interpolated = discriminator(interpolated)
# 计算梯度
grad_outputs = torch.ones_like(d_interpolated, device=device)
gradients = torch.autograd.grad(
outputs=d_interpolated,
inputs=interpolated,
grad_outputs=grad_outputs,
create_graph=True,
retain_graph=True,
only_inputs=True
)[0]
gradients = gradients.view(batch_size, -1)
gradient_norm = gradients.norm(2, dim=1)
# 计算梯度惩罚(希望梯度范数接近1)
gradient_penalty = ((gradient_norm - 1) ** 2).mean()
return gradient_penalty
# 在训练循环中使用梯度惩罚
def train_with_gradient_penalty(discriminator, generator,
real_images, lambda_gp=10):
# 生成假图像
z = torch.randn(real_images.size(0), latent_dim, device=device)
fake_images = generator(z)
# 计算判别器损失
real_validity = discriminator(real_images)
fake_validity = discriminator(fake_images.detach())
# Wasserstein距离
d_loss = -torch.mean(real_validity) + torch.mean(fake_validity)
# 添加梯度惩罚
gp = compute_gradient_penalty(discriminator,
real_images.data,
fake_images.data)
d_loss += lambda_gp * gp
return d_loss
4.4 谱归一化技术
谱归一化能限制判别器的Lipschitz常数,提高训练稳定性:
class SpectralNormConv2d(nn.Module):
"""带谱归一化的卷积层"""
def __init__(self, in_channels, out_channels,
kernel_size, stride=1, padding=0):
super().__init__()
self.conv = nn.Conv2d(in_channels, out_channels,
kernel_size, stride, padding)
nn.init.orthogonal_(self.conv.weight)
# 谱归一化
self.conv = nn.utils.spectral_norm(self.conv)
def forward(self, x):
return self.conv(x)
class SpectralNormLinear(nn.Module):
"""带谱归一化的全连接层"""
def __init__(self, in_features, out_features):
super().__init__()
self.linear = nn.Linear(in_features, out_features)
nn.init.orthogonal_(self.linear.weight)
# 谱归一化
self.linear = nn.utils.spectral_norm(self.linear)
def forward(self, x):
return self.linear(x)
# 使用谱归一化的判别器
class SN_Discriminator(nn.Module):
def __init__(self):
super().__init__()
self.model = nn.Sequential(
# 输入: 1x28x28
SpectralNormConv2d(1, 64, 4, 2, 1), # 64x14x14
nn.LeakyReLU(0.2, inplace=True),
SpectralNormConv2d(64, 128, 4, 2, 1), # 128x7x7
nn.LeakyReLU(0.2, inplace=True),
nn.Flatten(),
SpectralNormLinear(128*7*7, 1024),
nn.LeakyReLU(0.2, inplace=True),
SpectralNormLinear(1024, 1)
# 注意:输出层不使用Sigmoid,因为WGAN使用线性输出
)
def forward(self, img):
validity = self.model(img)
return validity
5. 评估与调试:如何知道模型真的在进步?
训练GAN时,损失函数下降并不一定意味着生成质量在提高。我们需要更可靠的评估指标和调试工具。
5.1 多维度评估指标
class GANEvaluator:
"""GAN模型评估器"""
def __init__(self, real_dataloader, device='cuda'):
self.real_dataloader = real_dataloader
self.device = device
# 预计算真实数据的统计信息
self.real_stats = self._compute_real_stats()
def _compute_real_stats(self):
"""计算真实数据的统计信息"""
all_images = []
for images, _ in self.real_dataloader:
all_images.append(images)
all_images = torch.cat(all_images, dim=0)
return {
'mean': all_images.mean().item(),
'std': all_images.std().item(),
'min': all_images.min().item(),
'max': all_images.max().item()
}
def evaluate(self, generator, num_samples=1000):
"""全面评估生成器"""
results = {}
# 1. 生成样本
with torch.no_grad():
z = torch.randn(num_samples, generator.latent_dim, device=self.device)
fake_images = generator(z).cpu()
# 2. 计算基础统计指标
results['basic_stats'] = self._compute_basic_stats(fake_images)
# 3. 计算FID分数(需要预训练的Inception网络)
results['fid_score'] = self._compute_fid(fake_images)
# 4. 计算Inception Score
results['inception_score'] = self._compute_inception_score(fake_images)
# 5. 多样性评估
results['diversity'] = self._compute_diversity(fake_images)
# 6. 可视化检查
self._visualize_samples(fake_images[:25], "current_generation.png")
return results
def _compute_basic_stats(self, images):
"""计算基础统计信息"""
return {
'mean': images.mean().item(),
'std': images.std().item(),
'min': images.min().item(),
'max': images.max().item(),
'range': images.max().item() - images.min().item()
}
def _compute_diversity(self, images):
"""计算生成样本的多样性"""
# 方法1:计算样本间的平均距离
flattened = images.view(images.size(0), -1)
distances = torch.cdist(flattened, flattened, p=2)
# 排除对角线(自身距离)
mask = ~torch.eye(images.size(0), dtype=torch.bool)
avg_distance = distances[mask].mean().item()
# 方法2:计算特征空间的覆盖率
# 使用PCA降维后计算覆盖率
from sklearn.decomposition import PCA
from sklearn.cluster import KMeans
images_np = images.numpy().reshape(images.size(0), -1)
pca = PCA(n_components=50)
reduced = pca.fit_transform(images_np)
# 使用K-means聚类评估覆盖率
kmeans = KMeans(n_clusters=10, random_state=42)
clusters = kmeans.fit_predict(reduced)
unique_clusters = len(np.unique(clusters))
return {
'avg_pairwise_distance': avg_distance,
'cluster_coverage': unique_clusters / 10.0 # 10个数字类别
}
def _visualize_samples(self, images, filename):
"""可视化生成样本"""
import matplotlib.pyplot as plt
fig, axes = plt.subplots(5, 5, figsize=(10, 10))
for i, ax in enumerate(axes.flat):
if i < len(images):
img = images[i].squeeze().numpy()
ax.imshow(img, cmap='gray')
ax.axis('off')
plt.tight_layout()
plt.savefig(filename, dpi=150, bbox_inches='tight')
plt.close()
5.2 实时监控与可视化
建立实时监控面板,帮助理解训练过程:
class TrainingDashboard:
"""训练监控面板"""
def __init__(self, log_dir="logs"):
self.log_dir = log_dir
os.makedirs(log_dir, exist_ok=True)
# 初始化记录
self.metrics = {
'd_loss': [], 'g_loss': [],
'd_real_acc': [], 'd_fake_acc': [],
'grad_norms': [], 'weight_updates': []
}
# 创建TensorBoard记录器
from torch.utils.tensorboard import SummaryWriter
self.writer = SummaryWriter(log_dir)
def update(self, epoch, batch_idx, **kwargs):
"""更新监控指标"""
for key, value in kwargs.items():
if key in self.metrics:
self.metrics[key].append(value)
# 记录到TensorBoard
global_step = epoch * 1000 + batch_idx
for key, value in kwargs.items():
if isinstance(value, (int, float)):
self.writer.add_scalar(key, value, global_step)
def plot_training_curves(self):
"""绘制训练曲线"""
import matplotlib.pyplot as plt
fig, axes = plt.subplots(2, 3, figsize=(15, 10))
# 损失曲线
axes[0, 0].plot(self.metrics['d_loss'], label='Discriminator')
axes[0, 0].plot(self.metrics['g_loss'], label='Generator')
axes[0, 0].set_title('Training Loss')
axes[0, 0].set_xlabel('Iteration')
axes[0, 0].set_ylabel('Loss')
axes[0, 0].legend()
axes[0, 0].grid(True, alpha=0.3)
# 准确率曲线
axes[0, 1].plot(self.metrics['d_real_acc'], label='Real Accuracy')
axes[0, 1].plot(self.metrics['d_fake_acc'], label='Fake Accuracy')
axes[0, 1].set_title('Discriminator Accuracy')
axes[0, 1].set_xlabel('Iteration')
axes[0, 1].set_ylabel('Accuracy')
axes[0, 1].legend()
axes[0, 1].grid(True, alpha=0.3)
# 梯度范数
if self.metrics['grad_norms']:
axes[0, 2].plot(self.metrics['grad_norms'])
axes[0, 2].set_title('Gradient Norms')
axes[0, 2].set_xlabel('Iteration')
axes[0, 2].set_ylabel('Norm')
axes[0, 2].grid(True, alpha=0.3)
# 损失比率
if len(self.metrics['d_loss']) > 1 and len(self.metrics['g_loss']) > 1:
ratios = []
for d, g in zip(self.metrics['d_loss'], self.metrics['g_loss']):
if g != 0:
ratios.append(d / g)
axes[1, 0].plot(ratios)
axes[1, 0].axhline(y=1.0, color='r', linestyle='--', alpha=0.5)
axes[1, 0].set_title('D/G Loss Ratio')
axes[1, 0].set_xlabel('Iteration')
axes[1, 0].set_ylabel('Ratio')
axes[1, 0].grid(True, alpha=0.3)
# 移动平均损失
window = 100
if len(self.metrics['d_loss']) > window:
d_smooth = np.convolve(self.metrics['d_loss'],
np.ones(window)/window, mode='valid')
g_smooth = np.convolve(self.metrics['g_loss'],
np.ones(window)/window, mode='valid')
axes[1, 1].plot(d_smooth, label='D (smooth)')
axes[1, 1].plot(g_smooth, label='G (smooth)')
axes[1, 1].set_title('Smoothed Loss (window=100)')
axes[1, 1].set_xlabel('Iteration')
axes[1, 1].set_ylabel('Loss')
axes[1, 1].legend()
axes[1, 1].grid(True, alpha=0.3)
plt.tight_layout()
plt.savefig(os.path.join(self.log_dir, 'training_curves.png'),
dpi=150, bbox_inches='tight')
plt.close()
def generate_latent_space_visualization(self, generator, epoch):
"""生成潜在空间可视化"""
# 在潜在空间中采样几个点
z1 = torch.randn(1, generator.latent_dim, device='cuda')
z2 = torch.randn(1, generator.latent_dim, device='cuda')
# 在两点间插值
steps = 10
alphas = torch.linspace(0, 1, steps, device='cuda')
interpolated_images = []
for alpha in alphas:
z = alpha * z1 + (1 - alpha) * z2
with torch.no_grad():
img = generator(z).cpu()
interpolated_images.append(img)
# 保存可视化结果
self._save_interpolation_grid(interpolated_images, epoch)
def close(self):
"""关闭记录器"""
self.writer.close()
5.3 自动化超参数搜索
class HyperparameterOptimizer:
"""超参数优化器"""
def __init__(self, param_space):
"""
param_space: 超参数搜索空间
示例:
{
'lr': [0.0001, 0.0002, 0.0005],
'batch_size': [32, 64, 128],
'latent_dim': [50, 100, 200],
'd_steps': [1, 2, 3],
'g_steps': [1, 2, 3]
}
"""
self.param_space = param_space
self.results = []
def grid_search(self, train_func, num_epochs=50):
"""网格搜索最佳超参数"""
from itertools import product
# 生成所有参数组合
param_names = list(self.param_space.keys())
param_values = list(self.param_space.values())
for combination in product(*param_values):
params = dict(zip(param_names, combination))
print(f"\n测试参数组合: {params}")
try:
# 训练模型
final_metrics = train_func(params, num_epochs)
# 记录结果
self.results.append({
'params': params,
'metrics': final_metrics,
'score': self._compute_score(final_metrics)
})
print(f"得分: {self.results[-1]['score']:.4f}")
except Exception as e:
print(f"训练失败: {e}")
continue
# 按得分排序
self.results.sort(key=lambda x: x['score'], reverse=True)
return self.results
def _compute_score(self, metrics):
"""计算综合得分"""
# 可以根据需要调整权重
weights = {
'fid_score': -1.0, # FID越低越好
'inception_score': 1.0, # IS越高越好
'diversity': 1.0, # 多样性越高越好
'training_time': -0.1, # 训练时间越短越好
'stability': 2.0 # 训练稳定性很重要
}
score = 0
for metric, value in metrics.items():
if metric in weights:
score += weights[metric] * value
return score
def get_best_params(self, top_k=3):
"""获取最佳参数组合"""
return self.results[:top_k]
def plot_parameter_importance(self):
"""绘制参数重要性分析"""
import pandas as pd
import seaborn as sns
import matplotlib.pyplot as plt
# 转换为DataFrame
records = []
for result in self.results:
record = result['params'].copy()
record['score'] = result['score']
records.append(record)
df = pd.DataFrame(records)
# 绘制相关性热图
plt.figure(figsize=(10, 8))
correlation = df.corr()
sns.heatmap(correlation, annot=True, cmap='coolwarm', center=0)
plt.title('超参数与得分的相关性')
plt.tight_layout()
plt.savefig('parameter_correlation.png', dpi=150)
plt.close()
return df
5.4 实用的调试检查清单
在训练过程中,我习惯按照以下检查清单进行系统调试:
class GANDebugChecklist:
"""GAN调试检查清单"""
def __init__(self):
self.checks = []
def add_check(self, name, function, frequency=100):
"""添加检查项"""
self.checks.append({
'name': name,
'function': function,
'frequency': frequency,
'last_check': 0
})
def run_checks(self, iteration, **kwargs):
"""运行检查"""
results = {}
for check in self.checks:
if iteration - check['last_check'] >= check['frequency']:
try:
result = check['function'](**kwargs)
results[check['name']] = result
check['last_check'] = iteration
# 如果有问题,打印警告
if result.get('status') == 'warning':
print(f"⚠️ {check['name']}: {result.get('message')}")
elif result.get('status') == 'error':
print(f"❌ {check['name']}: {result.get('message')}")
except Exception as e:
print(f"检查 {check['name']} 失败: {e}")
return results
@staticmethod
def create_default_checklist():
"""创建默认检查清单"""
checklist = GANDebugChecklist()
# 检查1: 梯度是否正常
def check_gradients(generator, discriminator):
grad_stats = {'generator': {}, 'discriminator': {}}
for name, model in [('generator', generator),
('discriminator', discriminator)]:
total_norm = 0
num_params = 0
has_nan = False
has_inf = False
for param in model.parameters():
if param.grad is not None:
grad = param.grad.data
total_norm += grad.norm().item() ** 2
num_params += 1
if torch.isnan(grad).any():
has_nan = True
if torch.isinf(grad).any():
has_inf = True
if num_params > 0:
grad_norm = total_norm ** 0.5
grad_stats[name]['norm'] = grad_norm
grad_stats[name]['has_nan'] = has_nan
grad_stats[name]['has_inf'] = has_inf
status = 'ok'
message = f"梯度范数: {grad_norm:.6f}"
if has_nan:
status = 'error'
message = "梯度包含NaN值"
elif has_inf:
status = 'error'
message = "梯度包含Inf值"
elif grad_norm > 100:
status = 'warning'
message = f"梯度范数过大: {grad_norm:.6f}"
elif grad_norm < 1e-6:
status = 'warning'
message = f"梯度范数过小: {grad_norm:.6f}"
grad_stats[name]['status'] = status
grad_stats[name]['message'] = message
return grad_stats
checklist.add_check('梯度检查', check_gradients, frequency=50)
# 检查2: 参数是否正常
def check_parameters(generator, discriminator):
param_stats = {}
for name, model in [('generator', generator),
('discriminator', discriminator)]:
params = list(model.parameters())
if not params:
continue
# 计算参数统计
all_params = torch.cat([p.data.view(-1) for p in params])
stats = {
'mean': all_params.mean().item(),
'std': all_params.std().item(),
'min': all_params.min().item(),
'max': all_params.max().item(),
'num_nan': torch.isnan(all_params).sum().item(),
'num_inf': torch.isinf(all_params).sum().item()
}
param_stats[name] = stats
# 检查异常
if stats['num_nan'] > 0 or stats['num_inf'] > 0:
print(f"❌ {name} 参数异常: NaN={stats['num_nan']}, "
f"Inf={stats['num_inf']}")
return param_stats
checklist.add_check('参数检查', check_parameters, frequency=100)
# 检查3: 损失是否合理
def check_losses(d_loss, g_loss, d_real_acc, d_fake_acc):
stats = {
'd_loss': d_loss,
'g_loss': g_loss,
'd_real_acc': d_real_acc,
'd_fake_acc': d_fake_acc,
'd_g_ratio': d_loss / g_loss if g_loss != 0 else float('inf')
}
# 检查损失是否爆炸
if d_loss > 100 or g_loss > 100:
stats['status'] = 'error'
stats['message'] = f"损失值过大: D={d_loss:.2f}, G={g_loss:.2f}"
elif d_loss < 1e-6 or g_loss < 1e-6:
stats['status'] = 'warning'
stats['message'] = f"损失值过小: D={d_loss:.6f}, G={g_loss:.6f}"
elif abs(stats['d_g_ratio'] - 1) > 10:
stats['status'] = 'warning'
stats['message'] = f"D/G损失比异常: {stats['d_g_ratio']:.2f}"
else:
stats['status'] = 'ok'
stats['message'] = '损失正常'
return stats
checklist.add_check('损失检查', check_losses, frequency=10)
return checklist
在实际项目中,我发现最有效的策略是从小开始,逐步复杂化。先用最简单的全连接网络和标准参数训练,确保基础流程能跑通。然后逐步引入卷积结构、改进的损失函数、谱归一化等技术。每次只改变一个变量,这样当出现问题时能快速定位原因。
训练GAN确实需要耐心和细致的调试,但一旦掌握了这些技巧,你会发现它其实并没有传说中那么难以驾驭。关键是要理解每个组件的作用,建立有效的监控机制,并且不要害怕实验——很多时候,最好的参数配置就藏在那些看似不合理的尝试中。
603



被折叠的 条评论
为什么被折叠?



