生成对抗网络（Generative Adversarial Network）
生成对抗网络（Generative Adversarial Network，简称 GAN）是由 Ian Goodfellow 等人在 2014 年提出的一种深度学习模型。GAN 通过两个网络——生成器（Generator）和判别器（Discriminator）的对抗训练来生成逼真的数据。
1. GAN 的基本概念
GAN 主要由两个部分组成：生成器（Generator）和判别器（Discriminator）。
1.1 生成器（Generator）
生成器是一个神经网络，它接收随机噪声作为输入，并输出模拟真实数据的生成样本。生成器的目标是“欺骗”判别器，使其无法区分生成的数据和真实数据。
可以将生成器想象成一个艺术家，它从随机噪声中创作出一幅画，并希望这幅画看起来像是真的。
代码示例:
import torch
import torch.nn as nn
class Generator(nn.Module):
def __init__(self, input_size, output_size):
super(Generator, self).__init__()
self.model = nn.Sequential(
nn.Linear(input_size, 128),
nn.ReLU(True),
nn.Linear(128, 256),
nn.ReLU(True),
nn.Linear(256, output_size),
nn.Tanh() # 输出范围在 -1 到 1 之间
)
def forward(self, x):
return self.model(x)
# 示例生成器网络
input_size = 100 # 输入噪声的维度
output_size = 784 # 生成的图像尺寸 (28x28)
generator = Generator(input_size, output_size)
# 随机噪声输入
random_noise = torch.randn(1, input_size)
generated_image = generator(random_noise)
print(f"生成的图像张量形状: {generated_image.shape}")
1.2 判别器（Discriminator）
判别器是另一个神经网络，它接收输入数据（无论是真实的还是生成的）并输出一个概率值，表示输入数据是真实的还是伪造的。判别器的目标是尽可能准确地区分真实数据和生成数据。
判别器就像是一位鉴定专家，它要判断给出的图片是真实的还是生成的。
代码示例:
class Discriminator(nn.Module):
def __init__(self, input_size):
super(Discriminator, self).__init__()
self.model = nn.Sequential(
nn.Linear(input_size, 256),
nn.LeakyReLU(0.2, inplace=True),
nn.Linear(256, 128),
nn.LeakyReLU(0.2, inplace=True),
nn.Linear(128, 1),
nn.Sigmoid() # 输出范围在 0 到 1 之间
)
def forward(self, x):
return self.model(x)
# 示例判别器网络
discriminator = Discriminator(output_size)
output = discriminator(generated_image)
print(f"判别器的输出: {output.item()}")
2. GAN 的对抗训练
在 GAN 中，生成器和判别器通过对抗训练相互提升：
- 生成器的目标是生成足够逼真的样本，使得判别器认为这些样本是真实的。
- 判别器的目标是尽可能准确地区分真实样本和生成样本。
这种对抗训练的过程就像是“猫捉老鼠”的游戏，生成器不断提高自己的欺骗能力，而判别器不断提升自己的鉴别能力。
2.1 损失函数
GAN 的损失函数由两个部分组成：
- 生成器损失: 通过判别器的输出计算，生成器希望这个损失越小越好，即判别器越难分辨出生成的样本。
- 判别器损失: 通过真实样本和生成样本的对比计算，判别器希望这个损失越小越好，即能更好地区分真实样本和生成样本。
代码示例:
criterion = nn.BCELoss() # 二元交叉熵损失
# 判别器的损失 (真实数据和生成数据)
real_labels = torch.ones(1, 1) # 真实标签为 1
fake_labels = torch.zeros(1, 1) # 生成的标签为 0
# 假设有真实数据 real_data 和生成的假数据 fake_data
real_data = torch.randn(1, output_size)
fake_data = generator(random_noise)
# 计算判别器损失
real_loss = criterion(discriminator(real_data), real_labels)
fake_loss = criterion(discriminator(fake_data.detach()), fake_labels)
d_loss = real_loss + fake_loss
# 计算生成器损失
g_loss = criterion(discriminator(fake_data), real_labels)
3. 项目示例：手写数字生成
我们将使用一个简单的 GAN 来生成手写数字图像。我们将使用 MNIST 数据集进行训练，生成类似手写数字的图片。
3.1 数据加载和预处理
import torchvision
import torchvision.transforms as transforms
# 定义数据变换，将图像标准化为 [-1, 1] 范围
transform = transforms.Compose([
transforms.ToTensor(),
transforms.Normalize((0.5,), (0.5,))
])
# 加载 MNIST 数据集
mnist_data = torchvision.datasets.MNIST(root='./data', train=True, download=True, transform=transform)
dataloader = torch.utils.data.DataLoader(mnist_data, batch_size=64, shuffle=True)
3.2 构建生成器和判别器
# 构建生成器和判别器实例
generator = Generator(input_size=100, output_size=784)
discriminator = Discriminator(input_size=784)
# 定义优化器
g_optimizer = torch.optim.Adam(generator.parameters(), lr=0.0002)
d_optimizer = torch.optim.Adam(discriminator.parameters(), lr=0.0002)
3.3 训练 GAN
epochs = 50
for epoch in range(epochs):
for real_images, _ in dataloader:
batch_size = real_images.size(0)
real_images = real_images.view(batch_size, -1)
# 训练判别器
real_labels = torch.ones(batch_size, 1)
fake_labels = torch.zeros(batch_size, 1)
outputs = discriminator(real_images)
d_loss_real = criterion(outputs, real_labels)
noise = torch.randn(batch_size, 100)
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}/{epochs}], d_loss: {d_loss.item():.4f}, g_loss: {g_loss.item():.4f}")
3.4 生成图像
# 生成并可视化图像
import matplotlib.pyplot as plt
noise = torch.randn(16, 100)
generated_images = generator(noise)
generated_images = generated_images.view(generated_images.size(0), 1, 28, 28)
fig, axs = plt.subplots(4, 4, figsize=(6, 6))
for i in range(4):
for j in range(4):
axs[i, j].imshow(generated_images[i*4 + j].squeeze().detach().numpy(), cmap='gray')
axs[i, j].axis('off')
plt.show()
3.5 完整代码
import torch
import torch.nn as nn
import torch.optim as optim
import torchvision
import torchvision.transforms as transforms
import matplotlib.pyplot as plt
# 1. 数据加载和预处理
transform = transforms.Compose([
transforms.ToTensor(),
transforms.Normalize((0.5,), (0.5,))
])
# 加载 MNIST 数据集
mnist_data = torchvision.datasets.MNIST(root='./data', train=True, download=True, transform=transform)
dataloader = torch.utils.data.DataLoader(mnist_data, batch_size=64, shuffle=True)
# 2. 定义生成器网络
class Generator(nn.Module):
def __init__(self, input_size, output_size):
super(Generator, self).__init__()
self.model = nn.Sequential(
nn.Linear(input_size, 128),
nn.ReLU(True),
nn.Linear(128, 256),
nn.ReLU(True),
nn.Linear(256, output_size),
nn.Tanh() # 输出范围在 -1 到 1 之间
)
def forward(self, x):
return self.model(x)
# 3. 定义判别器网络
class Discriminator(nn.Module):
def __init__(self, input_size):
super(Discriminator, self).__init__()
self.model = nn.Sequential(
nn.Linear(input_size, 256),
nn.LeakyReLU(0.2, inplace=True),
nn.Linear(256, 128),
nn.LeakyReLU(0.2, inplace=True),
nn.Linear(128, 1),
nn.Sigmoid() # 输出范围在 0 到 1 之间
)
def forward(self, x):
return self.model(x)
# 4. 构建生成器和判别器实例
generator = Generator(input_size=100, output_size=784)
discriminator = Discriminator(input_size=784)
# 定义损失函数和优化器
criterion = nn.BCELoss()
g_optimizer = optim.Adam(generator.parameters(), lr=0.0002)
d_optimizer = optim.Adam(discriminator.parameters(), lr=0.0002)
# 5. 训练过程
epochs = 50
for epoch in range(epochs):
for real_images, _ in dataloader:
batch_size = real_images.size(0)
real_images = real_images.view(batch_size, -1)
# 训练判别器
real_labels = torch.ones(batch_size, 1)
fake_labels = torch.zeros(batch_size, 1)
outputs = discriminator(real_images)
d_loss_real = criterion(outputs, real_labels)
noise = torch.randn(batch_size, 100)
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}/{epochs}], d_loss: {d_loss.item():.4f}, g_loss: {g_loss.item():.4f}")
# 6. 生成并可视化图像
noise = torch.randn(16, 100)
generated_images = generator(noise)
generated_images = generated_images.view(generated_images.size(0), 1, 28, 28)
fig, axs = plt.subplots(4, 4, figsize=(6, 6))
for i in range(4):
for j in range(4):
axs[i, j].imshow(generated_images[i*4 + j].squeeze().detach().numpy(), cmap='gray')
axs[i, j].axis('off')
plt.show()
4. 总结
通过这个项目示例，我们逐步构建了一个生成对抗网络（GAN），并使用它生成了手写数字图像。在此过程中，我们讲解了 GAN 的基本概念，包括生成器和判别器的作用、GAN 的对抗训练过程以及常见的损失函数。最后，我们通过实际的代码示例展示了如何实现 GAN 并生成图像。
GAN 的这种对抗训练方式，使得它在图像生成、风格迁移等领域具有非常强大的能力。
6158
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
