目录
4. PyTorch实现GAN的完整代码示例：生成一个以假乱真的MINIST数字数据图像
1. 前言
生成对抗神经网络（Generative Adversarial Networks，GAN）是一种强大的生成模型，由Ian Goodfellow于2014年提出。GAN的核心思想是通过两个神经网络的对抗性训练——生成器（Generator）和判别器（Discriminator）——来生成高质量的、与真实数据相似的新数据。GAN在图像生成、视频生成、数据增强等领域展现了巨大的潜力。
在这篇博客中，我们将详细了解GAN的工作原理，并通过一个完整的PyTorch实现示例，帮助您快速掌握GAN的构建和训练过程。
2. GAN的基本原理
GAN由两个核心组件组成：
-
生成器（Generator）：生成器的任务是从随机噪声中生成与真实数据相似的样本。生成器试图“欺骗”判别器，使其无法区分生成的数据和真实数据。
-
判别器（Discriminator）：判别器的任务是区分真实数据与生成器生成的伪造数据。判别器通过提高判别能力来减少生成器欺骗它的概率。
GAN的训练过程可以看作是一场“博弈”：生成器试图生成越来越逼真的数据，而判别器则不断学习如何区分真假数据。最终，生成器生成的样本与真实样本分布越来越接近，判别器无法区分真假数据。
3. GAN的训练过程
GAN的训练过程包括以下步骤：
-
初始化：初始化生成器和判别器的参数。
-
训练判别器：使用真实数据和生成数据分别训练判别器，使其能够区分真假数据。
-
训练生成器：通过判别器的反馈，优化生成器的参数，使其生成的样本更逼真。
-
迭代优化：不断重复上述步骤，直到生成器生成的样本与真实数据几乎无法区分。
4. PyTorch实现GAN的完整代码示例：生成一个以假乱真的MINIST数字数据图像
4.1 导入必要的库
import torch
import torch.nn as nn
import torch.optim as optim
from torch.utils.data import DataLoader
from torchvision import datasets, transforms
import numpy as np
import matplotlib.pyplot as plt4.2 数据加载与预处理
# 数据预处理
transform = transforms.Compose([
transforms.ToTensor(),
transforms.Normalize(mean=[0.5], std=[0.5])
])
# 加载MNIST数据集
train_dataset = datasets.MNIST(root='./data', train=True, transform=transform, download=True)
train_loader = DataLoader(dataset=train_dataset, batch_size=64, shuffle=True)4.3 定义生成器和判别器
# 定义生成器
class Generator(nn.Module):
def __init__(self, latent_dim=100, img_shape=(1, 28, 28)):
super(Generator, self).__init__()
self.img_shape = img_shape
self.model = nn.Sequential(
nn.Linear(latent_dim, 128),
nn.LeakyReLU(0.2, inplace=True),
nn.Linear(128, 256),
nn.BatchNorm1d(256),
nn.LeakyReLU(0.2, inplace=True),
nn.Linear(256, 512),
nn.BatchNorm1d(512),
nn.LeakyReLU(0.2, inplace=True),
nn.Linear(512, np.prod(img_shape)),
nn.Tanh()
)
def forward(self, z):
img = self.model(z)
img = img.view(img.size(0), *self.img_shape)
return img
# 定义判别器
class Discriminator(nn.Module):
def __init__(self, img_shape=(1, 28, 28)):
super(Discriminator, self).__init__()
self.model = nn.Sequential(
nn.Linear(np.prod(img_shape), 512),
nn.LeakyReLU(0.2, inplace=True),
nn.Linear(512, 256),
nn.LeakyReLU(0.2, inplace=True),
nn.Linear(256, 1),
nn.Sigmoid()
)
def forward(self, img):
img_flat = img.view(img.size(0), -1)
validity = self.model(img_flat)
return validity其中img = img.view(img.size(0), *self.img_shape)：
-
将一维的张量重新组织成图像的形状。
-
img.size(0)是批量大小（batch size）。 -
*self.img_shape是图像的形状（例如(1, 28, 28)）。 -
这一步将生成的像素值从一维向量重新组织成图像的多维张量。
np.prod(img_shape) 计算 img_shape 中所有元素的乘积。
latent_dim 是输入随机噪声的维度，默认为 100。
4.4 初始化模型和优化器
# 超参数设置
latent_dim = 100
lr = 0.0002
betas = (0.5, 0.999)
# 初始化生成器和判别器
generator = Generator(latent_dim=latent_dim)
discriminator = Discriminator()
# 损失函数和优化器
adversarial_loss = nn.BCELoss()
optimizer_G = optim.Adam(generator.parameters(), lr=lr, betas=betas)
optimizer_D = optim.Adam(discriminator.parameters(), lr=lr, betas=betas)4.5 训练GAN
# 训练过程
num_epochs = 100
for epoch in range(num_epochs):
for i, (imgs, _) in enumerate(train_loader):
# 真实和伪造的标签
valid = torch.ones(imgs.size(0), 1, dtype=torch.float32)
fake = torch.zeros(imgs.size(0), 1, dtype=torch.float32)
# 训练判别器
optimizer_D.zero_grad()
# 真实数据的损失
real_loss = adversarial_loss(discriminator(imgs), valid)
# 生成伪造数据
z = torch.randn(imgs.size(0), latent_dim)
gen_imgs = generator(z)
# 伪造数据的损失
fake_loss = adversarial_loss(discriminator(gen_imgs.detach()), fake)
# 总损失
d_loss = (real_loss + fake_loss) / 2
d_loss.backward()
optimizer_D.step()
# 训练生成器
optimizer_G.zero_grad()
# 生成器的损失
g_loss = adversarial_loss(discriminator(gen_imgs), valid)
g_loss.backward()
optimizer_G.step()
# 打印训练信息
if i % 100 == 0:
print(f"[Epoch {epoch}/{num_epochs}] [Batch {i}/{len(train_loader)}] [D loss: {d_loss.item()}] [G loss: {g_loss.item()}]")4.6 生成样本并可视化
# 生成样本
z = torch.randn(25, latent_dim)
gen_imgs = generator(z)
# 可视化生成的图像
plt.figure(figsize=(5, 5))
for i in range(25):
plt.subplot(5, 5, i+1)
plt.imshow(gen_imgs[i, 0].detach().numpy(), cmap='gray')
plt.axis('off')
plt.show()1. gen_imgs[i, 0]
-
gen_imgs是生成器生成的图像张量，形状为(batch_size, channels, height, width)。 -
i是批量中的第i个样本。 -
0是通道索引，表示选择第 0 个通道（例如，对于灰度图像，只有一个通道）。
2. .detach()
-
.detach()是 PyTorch 中的一个方法，用于将张量从计算图中分离出来，返回一个新的张量，不带梯度信息。 -
这在可视化时很有用，因为不需要计算梯度。
3. .numpy()
-
.numpy()是 PyTorch 张量的一个方法，用于将张量转换为 NumPy 数组。 -
matplotlib的imshow函数需要 NumPy 数组作为输入。
4.7 完整代码
完整代码如下方便调试：
import os
os.environ["KMP_DUPLICATE_LIB_OK"] = "TRUE"
import torch
import torch.nn as nn
import torch.optim as optim
from torch.utils.data import DataLoader
from torchvision import datasets, transforms
import numpy as np
import matplotlib.pyplot as plt
# 数据预处理
transform = transforms.Compose([
transforms.ToTensor(),
transforms.Normalize(mean=[0.5], std=[0.5])
])
# 加载MNIST数据集
train_dataset = 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, latent_dim=100, img_shape=(1, 28, 28)):
super(Generator, self).__init__()
self.img_shape = img_shape
self.model = nn.Sequential(
nn.Linear(latent_dim, 128),
nn.LeakyReLU(0.2, inplace=True),
nn.Linear(128, 256),
nn.BatchNorm1d(256),
nn.LeakyReLU(0.2, inplace=True),
nn.Linear(256, 512),
nn.BatchNorm1d(512),
nn.LeakyReLU(0.2, inplace=True),
nn.Linear(512, np.prod(img_shape)),
nn.Tanh()
)
def forward(self, z):
img = self.model(z)
img = img.view(img.size(0), *self.img_shape)
return img
# 定义判别器
class Discriminator(nn.Module):
def __init__(self, img_shape=(1, 28, 28)):
super(Discriminator, self).__init__()
self.model = nn.Sequential(
nn.Linear(np.prod(img_shape), 512),
nn.LeakyReLU(0.2, inplace=True),
nn.Linear(512, 256),
nn.LeakyReLU(0.2, inplace=True),
nn.Linear(256, 1),
nn.Sigmoid()
)
def forward(self, img):
img_flat = img.view(img.size(0), -1)
validity = self.model(img_flat)
return validity
# 超参数设置
latent_dim = 100
lr = 0.0002
betas = (0.5, 0.999)
# 初始化生成器和判别器
generator = Generator(latent_dim=latent_dim)
discriminator = Discriminator()
# 损失函数和优化器
adversarial_loss = nn.BCELoss()
optimizer_G = optim.Adam(generator.parameters(), lr=lr, betas=betas)
optimizer_D = optim.Adam(discriminator.parameters(), lr=lr, betas=betas)
# 训练过程
num_epochs = 100
for epoch in range(num_epochs):
for i, (imgs, _) in enumerate(train_loader):
# 真实和伪造的标签
valid = torch.ones(imgs.size(0), 1, dtype=torch.float32)
fake = torch.zeros(imgs.size(0), 1, dtype=torch.float32)
# 训练判别器
optimizer_D.zero_grad()
# 真实数据的损失
real_loss = adversarial_loss(discriminator(imgs), valid)
# 生成伪造数据
z = torch.randn(imgs.size(0), latent_dim)
gen_imgs = generator(z)
# 伪造数据的损失
fake_loss = adversarial_loss(discriminator(gen_imgs.detach()), fake)
# 总损失
d_loss = (real_loss + fake_loss) / 2
d_loss.backward()
optimizer_D.step()
# 训练生成器
optimizer_G.zero_grad()
# 生成器的损失
g_loss = adversarial_loss(discriminator(gen_imgs), valid)
g_loss.backward()
optimizer_G.step()
# 打印训练信息
if i % 100 == 0:
print(
f"[Epoch {epoch}/{num_epochs}] [Batch {i}/{len(train_loader)}] [D loss: {d_loss.item()}] [G loss: {g_loss.item()}]")
# 生成样本
z = torch.randn(25, latent_dim)
gen_imgs = generator(z)
# 可视化生成的图像
plt.figure(figsize=(5, 5))
for i in range(25):
plt.subplot(5, 5, i+1)
plt.imshow(gen_imgs[i, 0].detach().numpy(), cmap='gray')
plt.axis('off')
plt.show()结果如下，可以看到迭代100次后学习的还不错：
5. 总结
通过本文，我们详细介绍了生成对抗神经网络（GAN）的基本原理，并通过PyTorch实现了一个简单的GAN模型。GAN的核心在于生成器和判别器的对抗训练，这种机制使得GAN能够生成高质量的逼真数据。GAN的应用非常广泛，包括图像生成、风格迁移、数据增强等。
未来，GAN的研究方向包括提高训练稳定性、改进生成质量以及探索更多应用场景。希望本文能够帮助您更好地理解和应用GAN技术。我是橙色小博，关注我，一起在人工智能领域学习进步！
扫一扫
1924
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
