基于pytorch的条件生成对抗神经网络用于生成新数据的代码

以下是基于PyTorch的条件生成对抗神经网络（Conditional Generative Adversarial Network，CGAN）用于生成新数据的示例代码：

import torch
import torch.nn as nn
import torch.optim as optim
from torchvision import datasets, transforms
from torch.autograd import Variable

# 定义判别器模型
class Discriminator(nn.Module):
    def __init__(self):
        super(Discriminator, self).__init__()
        self.fc1 = nn.Linear(784, 512)
        self.fc2 = nn.Linear(512, 256)
        self.fc3 = nn.Linear(256, 1)

    def forward(self, x, y):
        x = x.view(-1, 784)
        y = y.view(-1, 10)
        x = torch.cat([x, y], 1)
        x = nn.functional.relu(self.fc1(x))
        x = nn.functional.relu(self.fc2(x))
        x = nn.functional.sigmoid(self.fc3(x))
        return x

# 定义生成器模型
class Generator(nn.Module):
    def __init__(self):
        super(Generator, self).__init__()
        self.fc1 = nn.Linear(110, 256)
        self.fc2 = nn.Linear(256, 512)
        self.fc3 = nn.Linear(512, 784)

    def forward(self, x, y):
        x = torch.cat([x, y], 1)
        x = nn.functional.relu(self.fc1(x))
        x = nn.functional.relu(self.fc2(x))
        x = nn.functional.tanh(self.fc3(x))
        return x

# 定义训练数据集
train_dataset = datasets.MNIST(root='./data/',
                               train=True,
                               transform=transforms.ToTensor(),
                               download=True)

# 定义数据加载器
batch_size = 100
train_loader = torch.utils.data.DataLoader(dataset=train_dataset,
                                           batch_size=batch_size,
                                           shuffle=True)

# 定义CGAN模型
discriminator = Discriminator()
generator = Generator()

# 定义优化器和损失函数
optimizer_d = optim.Adam(discriminator.parameters(), lr=0.0002)
optimizer_g = optim.Adam(generator.parameters(), lr=0.0002)
criterion = nn.BCELoss()

# 定义训练过程
num_epochs = 200
for epoch in range(num_epochs):
    for i, (images, labels) in enumerate(train_loader):
        # 训练判别器
        images = Variable(images)
        labels = Variable(torch.eye(10)[labels])
        real_labels = Variable(torch.ones(batch_size, 1))
        fake_labels = Variable(torch.zeros(batch_size, 1))

        discriminator.zero_grad()
        outputs = discriminator(images, labels)
        d_loss_real = criterion(outputs, real_labels)

        z = Variable(torch.randn(batch_size, 100))
        fake_images = generator(z, labels)
        outputs = discriminator(fake_images, labels)
        d_loss_fake = criterion(outputs, fake_labels)

        d_loss = d_loss_real + d_loss_fake
        d_loss.backward()
        optimizer_d.step()

        # 训练生成器
        generator.zero_grad()
        z = Variable(torch.randn(batch_size, 100))
        fake_images = generator(z, labels)
        outputs = discriminator(fake_images, labels)
        g_loss = criterion(outputs, real_labels)
        g_loss.backward()
        optimizer_g.step()

        # 输出训练结果
        if (i+1) % 100 == 0:
            print("