完善基于PyTorch的条件生成对抗网络（CGAN）的代码框架

CGAN是一种生成对抗网络，它可以基于给定的条件生成合成数据。以下是基于PyTorch的CGAN代码框架的一个示例：

import torch
import torch.nn as nn
import torch.optim as optim
from torch.utils.data import DataLoader
from torchvision import datasets, transforms

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

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

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

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

# 定义CGAN模型
class CGAN(nn.Module):
    def __init__(self, generator, discriminator):
        super(CGAN, self).__init__()
        self.generator = generator
        self.discriminator = discriminator

    def forward(self, z, c):
        x_fake = self.generator(torch.cat([z, c], dim=1))
        x_real = torch.cat([x_fake, c], dim=1)
        y_fake = self.discriminator(x_fake)
        y_real = self.discriminator(x_real)
        return y_fake, y_real

# 定义训练函数
def train_cgan(generator, discriminator, cgan, data_loader, num_epochs, device):
    generator.to(device)
    discriminator.to(device)
    cgan.to(device)

    criterion = nn.BCELoss()
    optimizer_g = optim.Adam(generator.parameters(), lr=0.0002, betas=(0.5, 0.999))
    optimizer_d = optim.Adam(discriminator.parameters(), lr=0.0002, betas=(0.5, 0.999))

    for epoch in range(num_epochs):
        for i, (x_real, c) in enumerate(data_loader):
            x_real = x_real.to(device)
            c = c.to(device)

            # 训练判别器
            optimizer_d.zero_grad()
            z = torch.randn(x_real.size(0), 100).to(device)
            y_fake, y_real = cgan(z, c)
            loss_d = criterion(y_real, torch.ones_like(y_real)) + criterion(y_fake, torch.zeros_like(y_fake))
            loss_d.backward(retain_graph=True)
            optimizer_d.step()

            # 训练生成器
            optimizer_g.zero_grad()
            z = torch.randn(x_real.size(0), 100).to(device)
            y_fake, _ = cgan(z, c)
            loss