帮我实现一个GAN结构，基于pytorch，并给出示例

好的，以下是一个基于 PyTorch 的 GAN 结构的示例代码：

import torch
import torch.nn as nn
import torch.optim as optim
import torchvision.datasets as dset
import torchvision.transforms as transforms
from torch.utils.data import DataLoader
from torch.autograd import Variable

# 定义生成器
class Generator(nn.Module):
    def __init__(self, input_size, hidden_size, output_size):
        super(Generator, self).__init__()
        self.fc1 = nn.Linear(input_size, hidden_size)
        self.fc2 = nn.Linear(hidden_size, hidden_size)
        self.fc3 = nn.Linear(hidden_size, output_size)
        self.relu = nn.ReLU()
        self.tanh = nn.Tanh()

    def forward(self, x):
        out = self.fc1(x)
        out = self.relu(out)
        out = self.fc2(out)
        out = self.relu(out)
        out = self.fc3(out)
        out = self.tanh(out)
        return out

# 定义判别器
class Discriminator(nn.Module):
    def __init__(self, input_size, hidden_size, output_size):
        super(Discriminator, self).__init__()
        self.fc1 = nn.Linear(input_size, hidden_size)
        self.fc2 = nn.Linear(hidden_size, hidden_size)
        self.fc3 = nn.Linear(hidden_size, output_size)
        self.relu = nn.ReLU()
        self.sigmoid = nn.Sigmoid()

    def forward(self, x):
        out = self.fc1(x)
        out = self.relu(out)
        out = self.fc2(out)
        out = self.relu(out)
        out = self.fc3(out)
        out = self.sigmoid(out)
        return out

# 定义超参数
batch_size = 100
learning_rate = 0.0002
num_epochs = 200

# 加载 MNIST 数据集
transform = transforms.Compose([
    transforms.ToTensor(),
    transforms.Normalize(mean=(0.5,), std=(0.5,))
])
train_dataset = dset.MNIST(root='./data', train=True, transform=transform, download=True)
train_loader = DataLoader(train_dataset, batch_size=batch_size, shuffle=True)

# 初始化网络
input_size = 784
hidden_size = 256
output_size = 1
G = Generator(input_size, hidden_size, input_size)
D = Discriminator(input_size, hidden_size, output_size)

# 定义损失函数和优化器
criterion = nn.BCELoss()
G_optimizer = optim.Adam(G.parameters(), lr=learning_rate)
D_optimizer = optim.Adam(D.parameters(), lr=learning_rate)

# 训练网络
for epoch in range(num_epochs):
    for i, (images, _) in enumerate(train_loader):
        # 训练判别器
        real_images = Variable(images.view(-1, input_size))
        real_labels = Variable(torch.ones(batch_size))
        fake_images = Variable(G(torch.randn(batch_size, input_size)))
        fake_labels = Variable(torch.zeros(batch_size))

        D_real_loss = criterion(D(real_images), real_labels)
        D_fake_loss = criterion(D(fake_images), fake_labels)
        D_loss = D_real_loss + D_fake_loss

        D_optimizer.zero_grad()
        D_loss.backward()
        D_optimizer.step()

        # 训练生成器
        fake_images = Variable(G(torch.randn(batch_size, input_size)))
        fake_labels = Variable(torch.ones(batch_size))

        G_loss = criterion(D(fake_images), fake_labels)

        G_optimizer.zero_grad()
        G_loss.backward()
        G_optimizer.step()

    # 打印损失
    print('Epoch [{}/{}], D_loss: {:.4f}, G_loss: {:.4f}'.format(epoch+1, num_epochs, D_loss.data[0], G_loss.data[0]))

# 保存模型
torch.save(G.state_dict(), 'G.pth')
torch.save(D.state_dict(), 'D.pth')

希望这个示例能够帮助你实现一个 GAN 结构。