Python实现生成对抗网络：生成逼真数据

Python实现GAN (生成对抗网络) – 从0到1的深度学习之旅

嘿，小伙伴们！今天咱们要玩一个有趣的项目 – 用Python实现GAN网络。这个项目会帮你理解如何训练AI来生成超逼真的数据。我们会用MNIST手写数字数据集来演示，让AI学会画数字！

第一步：导入必要的包

import torch



import torch.nn as nn



import torch.optim as optim



import torchvision



import torchvision.transforms as transforms



from torch.utils.data import DataLoader



import numpy as np



import matplotlib.pyplot as plt



# 设置随机种子，确保结果可复现



torch.manual_seed(42)

第二步：准备数据集

# 数据预处理和加载



transform = transforms.Compose([



transforms.ToTensor()，



transforms.Normalize((0.5，)， (0.5，))



])



# 加载MNIST数据集



train_dataset = torchvision.datasets.MNIST(



root='./data'，



train=True，



transform=transform，



download=True



)



# 创建数据加载器



train_loader = DataLoader(



dataset=train_dataset，



batch_size=64，



shuffle=True



)

第三步：构建生成器网络

class Generator(nn.Module)：



def __init__(self)：



super(Generator， self).__init__()



# 生成器结构：用简单的全连接层



self.gen = nn.Sequential(



# 输入是随机噪声(latent_dim)



nn.Linear(100， 256)，



nn.LeakyReLU(0.2)，



nn.BatchNorm1d(256)，



nn.Linear(256， 512)，



nn.LeakyReLU(0.2)，



nn.BatchNorm1d(512)，



nn.Linear(512， 1024)，



nn.LeakyReLU(0.2)，



nn.BatchNorm1d(1024)，



# 输出层，生成28*28=784维的图像



nn.Linear(1024， 784)，



nn.Tanh()



)



def forward(self， x)：



return self.gen(x)

第四步：构建判别器网络

class Discriminator(nn.Module)：



def __init__(self)：



super(Discriminator， self).__init__()



# 判别器结构



self.disc = nn.Sequential(



# 输入是展平的图像(784维)



nn.Linear(784， 1024)，



nn.LeakyReLU(0.2)，



nn.Dropout(0.3)，



nn.Linear(1024， 512)，



nn.LeakyReLU(0.2)，



nn.Dropout(0.3)，



nn.Linear(512， 256)，



nn.LeakyReLU(0.2)，



nn.Dropout(0.3)，



# 输出一个概率值



nn.Linear(256， 1)，



nn.Sigmoid()



)



def forward(self， x)：



return self.disc(x)

第五步：训练模型

# 初始化模型



generator = Generator()



discriminator = Discriminator()



# 损失函数和优化器



criterion = nn.BCELoss()



g_optimizer = optim.Adam(generator.parameters()， lr=0.0002， betas=(0.5， 0.999))



d_optimizer = optim.Adam(discriminator.parameters()， lr=0.0002， betas=(0.5， 0.999))



# 训练参数



num_epochs = 100



latent_dim = 100



fixed_noise = torch.randn(16， latent_dim)  # 用于可视化



# 训练循环



for epoch in range(num_epochs)：



for i， (real_images， _) in enumerate(train_loader)：



batch_size = real_images.size(0)



# 准备真实和虚假的标签



real_label = torch.ones(batch_size， 1)



fake_label = torch.zeros(batch_size， 1)



# 展平图像



real_images = real_images.view(-1， 784)



# 训练判别器



d_optimizer.zero_grad()



output_real = discriminator(real_images)



d_loss_real = criterion(output_real， real_label)



# 生成假图像



noise = torch.randn(batch_size， latent_dim)



fake_images = generator(noise)



output_fake = discriminator(fake_images.detach())



d_loss_fake = criterion(output_fake， fake_label)



# 计算判别器总损失



d_loss = d_loss_real + d_loss_fake



d_loss.backward()



d_optimizer.step()



# 训练生成器



g_optimizer.zero_grad()



output_fake = discriminator(fake_images)



g_loss = criterion(output_fake， real_label)



g_loss.backward()



g_optimizer.step()



if i % 100 == 0：



print(f'Epoch [{epoch}/{num_epochs}]， Step [{i}/{len(train_loader)}]， '



f'd_loss： {d_loss.item()：.4f}， g_loss： {g_loss.item()：.4f}')

第六步：生成和显示结果

def show_images(images)：



plt.figure(figsize=(4， 4))



plt.axis(“off”)



plt.imshow(np.transpose(torchvision.utils.make_grid(



images.reshape(-1， 1， 28， 28)， nrow=4， padding=2， normalize=True



).cpu()， (1， 2， 0)))



plt.show()



# 生成示例图像



with torch.no_grad()：



fake_images = generator(fixed_noise)



show_images(fake_images)

小贴士：

增加训练稳定性：

* 使用标签平滑化技术

* 添加梯度裁剪

* 尝试不同的激活函数

提高生成质量：

* 增加网络层数和通道数

* 使用更复杂的网络结构（如卷积层）

* 调整学习率和批次大小

避免模式崩溃：

* 使用Wasserstein GAN

* 实现批次归一化

* 适当调整判别器和生成器的训练比例

这个GAN实现虽然简单，但已经能产生不错的效果了。记得调参是提升效果的关键，慢慢调整，你一定能生成出更逼真的图像！

文章转自微信公众号@寒江映孤月