基于python的GAN网络

如何使用Python实现GAN
实现概述
生成对抗网络（GAN）由两部分组成：生成器和鉴别器。这两个组件相互竞争并共同进化，最终使得生成器可以创建逼真的数据样本[^1]。
构建GAN的关键要素

生成器负责创造看起来像真实数据的新实例。
鉴别器的任务则是区分输入的数据是来自实际分布还是由生成器产生的伪造品。
训练过程中的核心在于调整损失函数(loss function)，这决定了模型参数更新的方向以及程度[^2]。

使用PyTorch框架编写的基础版GAN代码如下：
import torch
from torch import nn, optim
from torchvision import datasets, transforms
from torch.utils.data import DataLoader

# 定义超参数
batch_size = 64
image_size = (28 * 28)
hidden_dim = 256
z_dim = 100
learning_rate = 0.0002
num_epochs = 20

device = 'cuda' if torch.cuda.is_available() else 'cpu'

class Generator(nn.Module):
def __init__(self):
super(Generator, self).__init__()
self.model = nn.Sequential(
nn.Linear(z_dim, hidden_dim),
nn.ReLU(),
nn.Linear(hidden_dim, image_size),
nn.Sigmoid()
)

def forward(self, z):
img = self.model(z)
img = img.view(img.size(0), 1, 28, 28)
return img

class Discriminator(nn.Module):
def __init__(self):
super(Discriminator, self).__init__()
self.model = nn.Sequential(
nn.Linear(image_size, hidden_dim),
nn.LeakyReLU(0.2),
nn.Dropout(0.3),
nn.Linear(hidden_dim, 1),
nn.Sigmoid()
)

def forward(self, imgs):
imgs_flat = imgs.view(imgs.size(0), -1)
validity = self.model(imgs_flat)
return validity

def train_gan(dataloader, generator, discriminator, optimizer_G, optimizer_D, num_epochs):

criterion = nn.BCELoss()

for epoch in range(num_epochs):
for i, (imgs, _) in enumerate(dataloader):

real_imgs = imgs.to(device)

valid = torch.ones((real_imgs.shape[0], 1)).to(device)
fake = torch.zeros((real_imgs.shape[0], 1)).to(device)

# Train the discriminator with real images.
outputs = discriminator(real_imgs).reshape(-1)
d_loss_real = criterion(outputs, valid)
real_score = outputs.mean().item()

# Generate a batch of noise samples and generate corresponding fake images using these noises as input to the generator network.
z = torch.randn(batch_size, z_dim).to(device)
gen_imgs = generator(z)

# Train the discriminator on generated data.
outputs = discriminator(gen_imgs.detach()).reshape(-1)
d_loss_fake = criterion(outputs, fake)
fake_score = outputs.mean().item()

# Backpropagation step for updating weights within D based upon both losses computed above.
d_loss = (d_loss_real + d_loss_fake) / 2
optimizer_D.zero_grad()
d_loss.backward(retain_graph=True)
optimizer_D.step()

# Update G according to its own loss calculated against output from updated version of D after being fed synthetic inputs produced by current state of G itself.
g_output = discriminator(gen_imgs).reshape(-1)
g_loss = criterion(g_output, valid)

optimizer_G.zero_grad()
g_loss.backward()
optimizer_G.step()

if __name__ == '__main__':

transform = transforms.Compose([
transforms.ToTensor(),
transforms.Normalize([0.5], [0.5])
])

dataset = datasets.MNIST(root='./data', download=True, transform=transform)
dataloader = DataLoader(dataset, batch_size=batch_size, shuffle=True)

generator = Generator().to(device)
discriminator = Discriminator().to(device)

optimizer_G = optim.Adam(generator.parameters(), lr=learning_rate)
optimizer_D = optim.Adam(discriminator.parameters(), lr=learning_rate)

train_gan(dataloader=dataloader,
generator=generator,
discriminator=discriminator,
optimizer_G=optimizer_G,
optimizer_D=optimizer_D,
num_epochs=num_epochs)

登录后复制
这段程序展示了如何利用PyTorch来定义一个简单的MNIST手写数字图片生成对抗网络，并对其进行基本训练循环的操作[^4]。