使用pytorch编写一个Gan

在PyTorch中创建一个生成式对抗网络（GAN）的基本步骤如下：

1. **导入库**：

import torch
import torch.nn as nn
from torch.autograd import Variable

2. **定义生成器（Generator）**：
- GAN通常包含两个神经网络：生成器G和判别器D。生成器的作用是从随机噪声中生成看起来像训练数据的新样本。例如，你可以使用DCGAN结构（Deconvolutional Generative Adversarial Networks）：

class Generator(nn.Module):
    def __init__(self, nz=100, ngf=64, nc=3, img_size=64):
        super(Generator, self).__init__()
        self.main = nn.Sequential(
            # 输入是一个固定大小的噪声向量
            nn.ConvTranspose2d(nz, ngf * 8, 4, 1, 0, bias=False),
            nn.BatchNorm2d(ngf * 8),
            nn.ReLU(True),

            nn.ConvTranspose2d(ngf * 8, ngf * 4, 4, 2, 1, bias=False),
            nn.BatchNorm2d(ngf * 4),
            nn.ReLU(True),

            nn.ConvTranspose2d(ngf * 4, ngf * 2, 4, 2, 1, bias=False),
            nn.BatchNorm2d(ngf * 2),
            nn.ReLU(True),

            nn.ConvTranspose2d(ngf * 2, ngf, 4, 2, 1, bias=False),
            nn.BatchNorm2d(ngf),
            nn.ReLU(True),

            nn.ConvTranspose2d(ngf, nc, 4, 2, 1, bias=False),
            nn.Tanh()
        )

    def forward(self, input):
        return self.main(input)

3. **定义判别器（Discriminator）**：

class Discriminator(nn.Module):
    def __init__(self, ndf=64, nc=3, img_size=64):
        super(Discriminator, self).__init__()
        self.main = nn.Sequential(
            nn.Conv2d(nc, ndf, 4, 2, 1, bias=False),
            nn.LeakyReLU(0.2, inplace=True),

            nn.Conv2d(ndf, ndf * 2, 4, 2, 1, bias=False),
            nn.BatchNorm2d(ndf * 2),
            nn.LeakyReLU(0.2, inplace=True),

            nn.Conv2d(ndf * 2, ndf * 4, 4, 2, 1, bias=False),
            nn.BatchNorm2d(ndf * 4),
            nn.LeakyReLU(0.2, inplace=True),

            nn.Conv2d(ndf * 4, ndf * 8, 4, 2, 1, bias=False),
            nn.BatchNorm2d(ndf * 8),
            nn.LeakyReLU(0.2, inplace=True),

            nn.Conv2d(ndf * 8, 1, 4, 1, 0, bias=False),
            nn.Sigmoid()
        )

    def forward(self, input):
        return self.main(input).view(-1)

4. **训练循环**：
- 定义优化器、损失函数等
- 在每个训练迭代中，更新生成器和判别器

完整示例：

# 实例化模型
gen = Generator()
disc = Discriminator()

# 进行训练...
optimizer_G = torch.optim.Adam(gen.parameters(), lr=0.0002, betas=(0.5, 0.999))
optimizer_D = torch.optim.Adam(disc.parameters(), lr=0.0002, betas=(0.5, 0.999))

for epoch in range(num_epochs):
    for data in dataloader:
        # 更多细节如数据预处理和批大小...

        noise = torch.randn(batch_size, nz, 1, 1)
        fake_data = gen(noise)

        real_data = data
        real_labels = torch.ones(batch_size)
        fake_labels = torch.zeros(batch_size)

        # 训练判别器
        disc.zero_grad()
        output = disc(real_data)
        errD_real = criterion(output, real_labels)
        d_loss_real = errD_real.mean()

        output = disc(fake_data.detach())
        errD_fake = criterion(output, fake_labels)
        d_loss_fake = errD_fake.mean()

        errD = d_loss_real + d_loss_fake
        errD.backward()
        optimizer_D.step()

        # 训练生成器
        gen.zero_grad()
        valid = disc(fake_data)
        errG = criterion(valid, real_labels)
        g_loss = errG.mean()
        g_loss.backward()
        optimizer_G.step()