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

好的，我可以为你提供一个基于PyTorch的CGAN代码框架。首先，让我们定义一些必要的库和参数：

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

# Define hyperparameters
batch_size = 128
lr = 0.0002
z_dim = 100
num_epochs = 50
device = torch.device('cuda' if torch.cuda.is_available() else 'cpu')

接下来，我们定义生成器和判别器网络：

class Generator(nn.Module):
    def __init__(self, z_dim=100, img_dim=784, hidden_dim=256):
        super(Generator, self).__init__()
        self.fc1 = nn.Linear(z_dim, hidden_dim)
        self.fc2 = nn.Linear(hidden_dim, hidden_dim)
        self.fc3 = nn.Linear(hidden_dim, img_dim)
        self.relu = nn.ReLU()
        self.sigmoid = nn.Sigmoid()
        
    def forward(self, z):
        x = self.relu(self.fc1(z))
        x = self.relu(self.fc2(x))
        x = self.sigmoid(self.fc3(x))
        return x
    
class Discriminator(nn.Module):
    def __init__(self, img_dim=784, hidden_dim=256):
        super(Discriminator, self).__init__()
        self.fc1 = nn.Linear(img_dim, hidden_dim)
        self.fc2 = nn.Linear(hidden_dim, hidden_dim)
        self.fc3 = nn.Linear(hidden_dim, 1)
        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

然后，我们定义损失函数和优化器：

criterion = nn.BCELoss()

G = Generator(z_dim).to(device)
D = Discriminator().to(device)

g_optimizer = optim.Adam(G.parameters(), lr=lr)
d_optimizer = optim.Adam(D.parameters(), lr=lr)

接下来，我们定义训练循环：

def train_GAN(dataloader, num_epochs):
    G.train()
    D.train()
    
    for epoch in range(num_epochs):
        for i, (real_imgs, _) in enumerate(dataloader):
            real_imgs = real_imgs.to(device)
            batch_size = real_imgs.size(0)
            
            # Train discriminator
            d_optimizer.zero_grad()
            
            # Train on real data
            real_labels = torch.ones(batch_size, 1).to(device)
            real_outputs = D(real_imgs)
            d_loss_real = criterion(real_outputs, real_labels)
            
            # Train on fake data
            z = torch.randn(batch_size, z_dim).to(device)
            fake_imgs = G(z)
            fake_labels = torch.zeros(batch_size, 1).to(device)
            fake_outputs = D(fake_imgs)
            d_loss_fake = criterion(fake_outputs, fake_labels)
            
            d_loss = d_loss_real + d_loss_fake
            d_loss.backward()
            d_optimizer.step()
            
            # Train generator
            g_optimizer.zero_grad()
            
            z = torch.randn(batch_size, z_dim).to(device)
            fake_imgs = G(z)
            fake_labels = torch.ones(batch_size, 1).to(device)
            fake_outputs = D(fake_imgs)
            g_loss = criterion(fake_outputs, fake_labels)
            
            g_loss.backward()
            g_optimizer.step()
            
            if i % 100 == 0:
                print("Epoch [{}/{}], Step [{}/{}], Discriminator Loss: {:.4f}, Generator Loss: {:.4f}"
                      .format(epoch, num_epochs, i, len(dataloader), d_loss.item(), g_loss.item()))

最后，我们加载数据集并开始训练：

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

train_dataset = MNIST(root='./data', train=True, download=True, transform=transform)
train_dataloader = DataLoader(train_dataset, batch_size=batch_size, shuffle=True, drop_last=True)

train_GAN(train_dataloader, num_epochs)

这是一个简单的CGAN代码框架，你可以根据自己的需求进行修改和扩展。