### PyTorch实现生成对抗网络（GAN）模型的教程与示例代码 生成对抗网络（GAN）是一种强大的生成模型，由生成器（Generator）和判别器（Discriminator）组成。以下是一个完整的PyTorch实现GAN的示例代码，包括数据加载、模型定义、训练过程等。 #### 1. 数据加载 使用`torchvision.datasets`加载MNIST数据集，并对其进行预处理。 ```python import torch from torchvision import datasets, transforms batch_size = 64 transform = transforms.Compose([ transforms.ToTensor(), transforms.Normalize((0.5,), (0.5,)) ]) train_dataset = datasets.MNIST(root='./data', train=True, transform=transform, download=True) train_loader = torch.utils.data.DataLoader(dataset=train_dataset, batch_size=batch_size, shuffle=True) ``` #### 2. 模型定义 定义生成器（Generator）和判别器（Discriminator）的结构。 ##### 生成器（Generator） 生成器将随机噪声映射到图像空间。 ```python import torch.nn as nn class Generator(nn.Module): def __init__(self): super(Generator, self).__init__() self.main = nn.Sequential( nn.Linear(100, 256), nn.ReLU(), nn.Linear(256, 512), nn.ReLU(), nn.Linear(512, 784), nn.Tanh() ) def forward(self, x): return self.main(x).view(-1, 1, 28, 28) ``` ##### 判别器（Discriminator） 判别器用于区分真实图像和生成图像。 ```python class Discriminator(nn.Module): def __init__(self): super(Discriminator, self).__init__() self.main = nn.Sequential( nn.Linear(784, 512), nn.LeakyReLU(0.2), nn.Linear(512, 256), nn.LeakyReLU(0.2), nn.Linear(256, 1), nn.Sigmoid() ) def forward(self, x): return self.main(x.view(-1, 784)) ``` #### 3. 损失函数与优化器 定义二元交叉熵损失函数，并为生成器和判别器分别设置优化器。 ```python device = torch.device("cuda" if torch.cuda.is_available() else "cpu") generator = Generator().to(device) discriminator = Discriminator().to(device) criterion = nn.BCELoss() lr = 0.0002 g_optimizer = torch.optim.Adam(generator.parameters(), lr=lr) d_optimizer = torch.optim.Adam(discriminator.parameters(), lr=lr) ``` #### 4. 训练过程 在每个批次中分别更新生成器和判别器的参数。 ```python num_epochs = 20 fixed_noise = torch.randn(batch_size, 100, device=device) for epoch in range(num_epochs): for i, (real_images, _) in enumerate(train_loader): batch_size = real_images.size(0) real_images = real_images.to(device) # === 训练判别器 === real_labels = torch.ones(batch_size, 1, device=device) fake_labels = torch.zeros(batch_size, 1, device=device) outputs = discriminator(real_images) d_loss_real = criterion(outputs, real_labels) noise = torch.randn(batch_size, 100, device=device) fake_images = generator(noise) outputs = discriminator(fake_images.detach()) d_loss_fake = criterion(outputs, fake_labels) d_loss = d_loss_real + d_loss_fake d_optimizer.zero_grad() d_loss.backward() d_optimizer.step() # === 训练生成器 === outputs = discriminator(fake_images) g_loss = criterion(outputs, real_labels) g_optimizer.zero_grad() g_loss.backward() g_optimizer.step() print(f"Epoch [{epoch+1}/{num_epochs}], d_loss: {d_loss.item():.4f}, g_loss: {g_loss.item():.4f}") ``` #### 5. 生成样本 训练完成后，可以使用固定噪声生成图像。 ```python import matplotlib.pyplot as plt generator.eval() with torch.no_grad(): fake_images = generator(fixed_noise) fake_images = fake_images.cpu().detach().numpy() fake_images = (fake_images + 1) / 2 # 反归一化 plt.figure(figsize=(10, 10)) for i in range(16): plt.subplot(4, 4, i+1) plt.imshow(fake_images[i].squeeze(), cmap="gray") plt.axis("off") plt.show() ```