GAN的代码实现（pytorch）

引用是一个关于生成器模型的PyTorch代码实现。这段代码是一个基本的生成器模型，它接收长度为100的噪声输入，并通过一系列全连接层和激活函数生成一个形状为(1,28,28)的图像。其中最后一个激活函数是tanh，将输出的像素值限制在-1到1之间。

引用和引用提到了StyleGAN和unet-stylegan2，它们是PyTorch中实现的改进版本的GAN。StyleGAN和unet-stylegan2都是用于生成逼真图像的模型，它们在图像质量和生成能力方面有所提升。

以下是一个基本的GAN代码实现的示例，用于在PyTorch中生成图像：

import torch
import torch.nn as nn
import torch.optim as optim

# 定义生成器模型
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):
        img = self.main(x)
        img = img.view(-1, 1, 28, 28)
        return img

# 定义判别器模型
class Discriminator(nn.Module):
    def __init__(self):
        super(Discriminator, self).__init__()
        self.main = nn.Sequential(
            nn.Linear(784, 512),
            nn.ReLU(),
            nn.Linear(512, 256),
            nn.ReLU(),
            nn.Linear(256, 1),
            nn.Sigmoid()
        )
    
    def forward(self, x):
        x = x.view(-1, 784)
        validity = self.main(x)
        return validity

# 定义训练过程
def train(generator, discriminator, dataloader, num_epochs=100, batch_size=64, lr=0.0002):
    adversarial_loss = nn.BCELoss()
    device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
    
    generator.to(device)
    discriminator.to(device)
    adversarial_loss.to(device)
    
    optimizer_G = optim.Adam(generator.parameters(), lr=lr, betas=(0.5, 0.999))
    optimizer_D = optim.Adam(discriminator.parameters(), lr=lr, betas=(0.5, 0.999))
    
    for epoch in range(num_epochs):
        for i, (imgs, _) in enumerate(dataloader):
            real_imgs = imgs.to(device)
            batch_size = real_imgs.size(0)
            valid = torch.ones(batch_size, 1).to(device)
            fake = torch.zeros(batch_size, 1).to(device)
            
            # 训练生成器
            optimizer_G.zero_grad()
            z = torch.randn(batch_size, 100).to(device)
            gen_imgs = generator(z)
            g_loss = adversarial_loss(discriminator(gen_imgs), valid)
            g_loss.backward()
            optimizer_G.step()
            
            # 训练判别器
            optimizer_D.zero_grad()
            real_loss = adversarial_loss(discriminator(real_imgs), valid)
            fake_loss = adversarial_loss(discriminator(gen_imgs.detach()), fake)
            d_loss = (real_loss + fake_loss) / 2
            d_loss.backward()
            optimizer_D.step()
            
            if (i+1) % 10 == 0:
                print("[Epoch %d/%d] [Batch %d/%d] [G loss: %.4f] [D loss: %.4f]"
                      % (epoch+1, num_epochs, i+1, len(dataloader), g_loss.item(), d_loss.item()))

# 使用MNIST数据集进行训练
import torchvision.datasets as datasets
import torchvision.transforms as transforms

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

mnist_dataset = datasets.MNIST(root='./data', train=True, transform=transform, download=True)
dataloader = torch.utils.data.DataLoader(mnist_dataset, batch_size=64, shuffle=True)

generator = Generator()
discriminator = Discriminator()

train(generator, discriminator, dataloader)