基于pytorch，帮我编写一个生成时序数据的GAN模型，噪声Z为正态分布的噪声，真实数据X为xlsx文件1里的271行96列的时序数据作为数据集，条件值C为xlsx文件里的1行96列的时序数据并转换为[1,96]的张量C.先训练判别器再训练生成器，训练判别器时，并将数据集里每个样本[1,96]张量和张量C纵向拼接为[2,96]张量XC且生成器生成的虚假样本X1张量[1,96]和张量C纵向拼接为[2,96]张量X1C，并将张量XC和张量X1C作为判别器的输入。训练生成器时，将噪声Z和条件C纵向拼接为[2,

96]的张量ZC，并将生成器生成的虚假样本X1张量[1,96]和条件C纵向拼接为[2,96]张量X1C，将张量ZC和张量X1C作为判别器的输入。以下是示例代码：

import torch
import torch.nn as nn
import torch.optim as optim
import pandas as pd
from torch.utils.data import Dataset, DataLoader

# 定义数据集类
class TimeSeriesDataset(Dataset):
    def __init__(self, data_file):
        self.data = pd.read_excel(data_file).values
    
    def __len__(self):
        return len(self.data)
    
    def __getitem__(self, idx):
        x = torch.tensor(self.data[idx], dtype=torch.float32)
        c = torch.tensor(self.data[0], dtype=torch.float32) # 条件值
        return x, c

# 定义判别器
class Discriminator(nn.Module):
    def __init__(self):
        super(Discriminator, self).__init__()
        self.model = nn.Sequential(
            nn.Linear(194, 128),
            nn.LeakyReLU(0.2),
            nn.Linear(128, 64),
            nn.LeakyReLU(0.2),
            nn.Linear(64, 1),
            nn.Sigmoid()
        )
    
    def forward(self, x, c):
        xc = torch.cat([x, c], dim=1)
        validity = self.model(xc)
        return validity

# 定义生成器
class Generator(nn.Module):
    def __init__(self):
        super(Generator, self).__init__()
        self.model = nn.Sequential(
            nn.Linear(98, 128),
            nn.LeakyReLU(0.2),
            nn.BatchNorm1d(128, 0.8),
            nn.Linear(128, 256),
            nn.LeakyReLU(0.2),
            nn.BatchNorm1d(256, 0.8),
            nn.Linear(256, 96),
            nn.Tanh()
        )
    
    def forward(self, z, c):
        zc = torch.cat([z, c], dim=1)
        x = self.model(zc)
        return x

# 定义训练函数
def train(generator, discriminator, dataloader, optimizer_G, optimizer_D, device):
    adversarial_loss = nn.BCELoss()
    
    for epoch in range(num_epochs):
        for i, (x, c) in enumerate(dataloader):
            # 训练判别器
            discriminator.zero_grad()
            
            # 真实数据
            x = x.to(device)
            c = c.to(device)
            valid = torch.ones(x.size(0), 1).to(device)
            fake = torch.zeros(x.size(0), 1).to(device)
            xc = torch.cat([x, c.repeat(x.size(0), 1)], dim=1)
            validity_real = discriminator(xc)
            loss_real = adversarial_loss(validity_real, valid)
            
            # 生成虚假数据
            z = torch.randn(x.size(0), 1).to(device)
            zc = torch.cat([z, c.repeat(z.size(0), 1)], dim=1)
            fake_samples = generator(z, c).detach()
            xc_fake = torch.cat([fake_samples, c.repeat(fake_samples.size(0), 1)], dim=1)
            validity_fake = discriminator(xc_fake)
            loss_fake = adversarial_loss(validity_fake, fake)
            
            # 计算总损失并反向传播
            d_loss = (loss_real + loss_fake) / 2
            d_loss.backward()
            optimizer_D.step()
            
            # 训练生成器
            generator.zero_grad()
            
            z = torch.randn(x.size(0), 1).to(device)
            zc = torch.cat([z, c.repeat(z.size(0), 1)], dim=1)
            fake_samples = generator(z, c)
            xc_fake = torch.cat([fake_samples, c.repeat(fake_samples.size(0), 1)], dim=1)
            validity = discriminator(xc_fake)
            g_loss = adversarial_loss(validity, valid)
            g_loss.backward()
            optimizer_G.step()
            
            # 输出训练信息
            print("[Epoch %d/%d] [Batch %d/%d] [D loss: %f] [G loss: %f]" % (epoch, num_epochs, i, len(dataloader), d_loss.item(), g_loss.item()))

# 定义超参数
data_file = "data.xlsx"
num_epochs = 200
batch_size = 64
lr = 0.0002
b1 = 0.5
b2 = 0.999
latent_dim = 1

# 准备数据
dataset = TimeSeriesDataset(data_file)
dataloader = DataLoader(dataset, batch_size=batch_size, shuffle=True)

# 定义设备
device = torch.device("cuda" if torch.cuda.is_available() else "cpu")

# 初始化网络和优化器
generator = Generator().to(device)
discriminator = Discriminator().to(device)
optimizer_G = optim.Adam(generator.parameters(), lr=lr, betas=(b1, b2))
optimizer_D = optim.Adam(discriminator.parameters(), lr=lr, betas=(b1, b2))

# 训练模型
train(generator, discriminator, dataloader, optimizer_G, optimizer_D, device)

以上代码仅供参考，具体实现可能需要根据数据集的特点进行调整。