你能不能用pytorch框架写一个条件生成对抗网络的示例程序，其中输入和输出以及条件均是一个一维向量

可以的，以下是示例程序：

import torch
import torch.nn as nn
import torch.optim as optim
import numpy as np

# 定义生成器
class Generator(nn.Module):
    def __init__(self, input_dim, output_dim, condition_dim):
        super(Generator, self).__init__()
        self.input_dim = input_dim
        self.output_dim = output_dim
        self.condition_dim = condition_dim
        self.fc1 = nn.Linear(input_dim + condition_dim, 128)
        self.fc2 = nn.Linear(128, 256)
        self.fc3 = nn.Linear(256, output_dim)

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

# 定义判别器
class Discriminator(nn.Module):
    def __init__(self, input_dim, condition_dim):
        super(Discriminator, self).__init__()
        self.input_dim = input_dim
        self.condition_dim = condition_dim
        self.fc1 = nn.Linear(input_dim + condition_dim, 128)
        self.fc2 = nn.Linear(128, 64)
        self.fc3 = nn.Linear(64, 1)

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

# 定义训练函数
def train_GAN(generator, discriminator, data, conditions, num_epochs=10000, batch_size=128, lr=0.0002):
    criterion = nn.BCELoss()
    optimizer_G = optim.Adam(generator.parameters(), lr=lr)
    optimizer_D = optim.Adam(discriminator.parameters(), lr=lr)

    for epoch in range(num_epochs):
        # 训练判别器
        for i in range(len(data) // batch_size):
            real_data = data[i*batch_size:(i+1)*batch_size]
            real_conditions = conditions[i*batch_size:(i+1)*batch_size]
            fake_data = generator(torch.randn(batch_size, generator.input_dim), real_conditions)
            real_labels = torch.ones