天生对抗网络（GAN，Generative Adversarial Network）

天生对抗网络（GAN，Generative Adversarial Network）是一种深度学习模子，由两部门构成：天生器（Generator）和辨别器（Discriminator）。天生器的目标是天生逼真的样本，而辨别器的目标是区分真实样本与天生样本。它们通过对抗过程相互训练，终极使天生器可以大概天生高度逼真的数据。
根本概念

• 天生器：从随机噪声（通常是高斯噪声）天生数据，表现为 G(z)G(z)G(z)，此中 zzz 是埋伏变量（噪声）。
  
• 辨别器：判定输入数据是否真实，表现为 D(x)D(x)D(x)，此中 xxx 是输入数据。辨别器输出一个值，表现其对输入数据为真实的概率。
  

目标函数

GAN 的目标是通过最小化以下对抗丧失来训练天生器和辨别器：
min⁡Gmax⁡DV(D,G)=Ex∼pdata(x)[log⁡D(x)]+Ez∼pz(z)[log⁡(1−D(G(z)))]\min_G \max_D V(D, G) = \mathbb{E}_{x \sim p_{data}(x)}[\log D(x)] + \mathbb{E}_{z \sim p_z(z)}[\log(1 - D(G(z)))]Gmin​Dmax​V(D,G)=Ex∼pdata​(x)​[logD(x)]+Ez∼pz​(z)​[log(1−D(G(z)))]

• pdata(x)p_{data}(x)pdata​(x)：真实数据分布。
  
• pz(z)p_z(z)pz​(z)：埋伏变量分布（通常为高斯分布）。
  
• D(x)D(x)D(x)：辨别器对真实样本的辨别概率。
  
• G(z)G(z)G(z)：天生器天生的样本。
  

训练过程

• 辨别器训练：通过真实样本和天生样本的丧失来优化辨别器。
  
• 天生器训练：通过辨别器的反馈，优化天生器，使得天生的样本更逼近真实样本。
  

通过不停的对抗训练，天生器终极可以大概天生靠近真实数据的样本，辨别器则不停进步其区分本领。
以下是一个使用 PyTorch 实现的简朴 GAN 案例，目标是天生手写数字（MNIST 数据集）。代码包罗天生器和辨别器的界说，以及训练过程。
GAN 案例代码

假如你要使用自界说的 MNISTDataset 类来加载数据，可以将它集成到之前的 GAN 示例中。以下是完备的代码示例，连合你的 MNISTDataset 实现。
完备的 GAN 示例代码

epoch设置为20，以作示例。

1. import torch
2. import torch.nn as nn
3. import torch.optim as optim
4. import numpy as np
5. import os
6. import matplotlib.pyplot as plt
7. from torch.utils.data import Dataset, DataLoader
9. # 自定义 MNIST 数据集类
10. class MNISTDataset(Dataset):
11.     def __init__(self, images_path, labels_path, transform=None):
12.         self.images = self.load_images(images_path)
13.         self.labels = self.load_labels(labels_path)
14.         self.transform = transform
16.     def load_images(self, path):
17.         with open(path, 'rb') as f:
18.             f.read(16)  # 跳过前16个字节
19.             images = np.frombuffer(f.read(), np.uint8).reshape(-1, 1, 28, 28)
20.         return torch.tensor(images, dtype=torch.float32) / 255.0  # 归一化到 [0, 1]
22.     def load_labels(self, path):
23.         with open(path, 'rb') as f:
24.             f.read(8)  # 跳过前8个字节
25.             labels = np.frombuffer(f.read(), np.uint8)
26.         return labels
28.     def __len__(self):
29.         return len(self.labels)
31.     def __getitem__(self, idx):
32.         image = self.images[idx]
33.         label = self.labels[idx]
35.         if self.transform:
36.             image = self.transform(image)
38.         return image, label
40. # 超参数
41. latent_size = 100
42. num_epochs = 20
43. batch_size = 64
44. learning_rate = 0.0002
46. # 数据准备
47. data_root = r'./MNIST'
48. train_dataset = MNISTDataset(
49.     images_path=os.path.join(data_root, 'train-images-idx3-ubyte'),
50.     labels_path=os.path.join(data_root, 'train-labels-idx1-ubyte')
51. )
53. data_loader = DataLoader(dataset=train_dataset, batch_size=batch_size, shuffle=True)
55. # 生成器模型
56. class Generator(nn.Module):
57.     def __init__(self):
58.         super(Generator, self).__init__()
59.         self.model = nn.Sequential(
60.             nn.Linear(latent_size, 256),
61.             nn.ReLU(),
62.             nn.Linear(256, 512),
63.             nn.ReLU(),
64.             nn.Linear(512, 1024),
65.             nn.ReLU(),
66.             nn.Linear(1024, 28 * 28),
67.             nn.Tanh()  # 输出在[-1, 1]范围内
68.         )
70.     def forward(self, z):
71.         return self.model(z).view(-1, 1, 28, 28)
73. # 判别器模型
74. class Discriminator(nn.Module):
75.     def __init__(self):
76.         super(Discriminator, self).__init__()
77.         self.model = nn.Sequential(
78.             nn.Linear(28 * 28, 1024),
79.             nn.LeakyReLU(0.2),
80.             nn.Linear(1024, 512),
81.             nn.LeakyReLU(0.2),
82.             nn.Linear(512, 256),
83.             nn.LeakyReLU(0.2),
84.             nn.Linear(256, 1),
85.             nn.Sigmoid()  # 输出在[0, 1]范围内
86.         )
88.     def forward(self, x):
89.         return self.model(x.view(-1, 28 * 28))
91. # 初始化模型和优化器
92. device = torch.device('cuda' if torch.cuda.is_available() else 'cpu')  # 检查是否有 GPU
93. generator = Generator().to(device)  # 移动到 GPU
94. discriminator = Discriminator().to(device)  # 移动到 GPU
95. criterion = nn.BCELoss()
96. optimizer_G = optim.Adam(generator.parameters(), lr=learning_rate)
97. optimizer_D = optim.Adam(discriminator.parameters(), lr=learning_rate)
99. # 训练过程
100. for epoch in range(num_epochs):
101.     for i, (images, _) in enumerate(data_loader):
102.         images = images.to(device)  # 移动输入数据到 GPU
104.         # 标签
105.         real_labels = torch.ones(images.size(0), 1).to(device)  # 移动到 GPU
106.         fake_labels = torch.zeros(images.size(0), 1).to(device)  # 移动到 GPU
108.         # 判别器训练
109.         optimizer_D.zero_grad()
110.         outputs = discriminator(images)
111.         d_loss_real = criterion(outputs, real_labels)
113.         z = torch.randn(images.size(0), latent_size).to(device)  # 随机噪声，移动到 GPU
114.         fake_images = generator(z)
115.         outputs = discriminator(fake_images.detach())
116.         d_loss_fake = criterion(outputs, fake_labels)
118.         d_loss = d_loss_real + d_loss_fake
119.         d_loss.backward()
120.         optimizer_D.step()
122.         # 生成器训练
123.         optimizer_G.zero_grad()
124.         outputs = discriminator(fake_images)
125.         g_loss = criterion(outputs, real_labels)
126.         g_loss.backward()
127.         optimizer_G.step()
129.     if (epoch + 1) % 10 == 0:
130.         print(f'Epoch [{epoch + 1}/{num_epochs}], d_loss: {d_loss.item():.4f}, g_loss: {g_loss.item():.4f}')
132. # 可视化生成的图像
133. with torch.no_grad():
134.     z = torch.randn(64, latent_size).to(device)  # 随机噪声，移动到 GPU
135.     fake_images = generator(z)
137. # 显示生成的图像
138. grid_img = fake_images.cpu().numpy()  # 移动到 CPU 以便绘图
139. grid_img = grid_img.reshape(-1, 28, 28)
140. plt.figure(figsize=(8, 8))
141. for i in range(64):
142.     plt.subplot(8, 8, i + 1)
143.     plt.imshow(grid_img[i], cmap='gray')
144.     plt.axis('off')
145. plt.show()

复制代码

代码阐明

• 自界说数据集：MNISTDataset 类用于从指定的路径加载 MNIST 数据。
  
• 数据归一化：在 load_images 方法中，将图像数据归一化到 [0, 1] 范围。
  
• 数据加载：使用 DataLoader 创建训练数据集的加载器。
  
• GAN 模子：包罗天生器和辨别器的界说。
  
• 训练过程：辨别器和天生器瓜代更新。
  
• 可视化天生图像：训练竣事后天生并表现手写数字图像。
  

你可以运行这个代码，并观察天生的手写数字。确保 MNIST 数据集文件在指定的路径下。