基于pytorch，编写一段WGAN的代码，该WGAN用来生成时序数据，输入的数据为271行的维度为（1，96）的XLSX文件，生成100个维度为（1，96）的xlsx数据，并每行都用中文详细解释

当然，下面是一个基于PyTorch编写的WGAN代码示例，用于生成时序数据。代码将从一个维度为（1，96）的XLSX文件中读取数据，并生成100个维度为（1，96）的XLSX数据。注释中将使用中文进行详细解释。

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

# 加载数据集
class TimeSeriesDataset(Dataset):
    def __init__(self, data_file):
        self.data = pd.read_excel(data_file)
    
    def __len__(self):
        return len(self.data)
    
    def __getitem__(self, idx):
        sample = self.data.iloc[idx, :].values
        sample = torch.Tensor(sample).unsqueeze(0)  # 转换为（1, 96）的张量
        return sample

# 生成器模型
class Generator(nn.Module):
    def __init__(self, input_dim, output_dim):
        super(Generator, self).__init__()
        self.fc = nn.Linear(input_dim, 128)
        self.relu = nn.ReLU()
        self.fc2 = nn.Linear(128, output_dim)

    def forward(self, x):
        x = self.fc(x)
        x = self.relu(x)
        x = self.fc2(x)
        return x

# 判别器模型
class Critic(nn.Module):
    def __init__(self, input_dim):
        super(Critic, self).__init__()
        self.fc = nn.Linear(input_dim, 128)
        self.relu = nn.ReLU()
        self.fc2 = nn.Linear(128, 1)

    def forward(self, x):
        x = self.fc(x)
        x = self.relu(x)
        x = self.fc2(x)
        return x

# WGAN 训练器
class WGAN:
    def __init__(self, input_dim, output_dim, critic_iterations=5, batch_size=64, learning_rate=0.0001):
        self.generator = Generator(input_dim, output_dim)
        self.critic = Critic(output_dim)

        self.critic_iterations = critic_iterations
        self.batch_size = batch_size

        self.device = torch.device("cuda" if torch.cuda.is_available() else "cpu")

        self.generator.to(self.device)
        self.critic.to(self.device)

        self.generator_optimizer = optim.RMSprop(self.generator.parameters(), lr=learning_rate)
        self.critic_optimizer = optim.RMSprop(self.critic.parameters(), lr=learning_rate)

    def train(self, data_loader, num_epochs):
        for epoch in range(num_epochs):
            for i, real_data in enumerate(data_loader):
                real_data = real_data.to(self.device)

                # 判别器训练
                for _ in range(self.critic_iterations):
                    self.critic_optimizer.zero_grad()

                    noise = torch.randn(self.batch_size, input_dim).to(self.device)
                    fake_data = self.generator(noise)

                    critic_loss = self.critic(fake_data).mean() - self.critic(real_data).mean()
                    critic_loss.backward()

                    self.critic_optimizer.step()

                    # 限制判别器权重
                    for p in self.critic.parameters():
                        p.data.clamp_(-0.01, 0.01)

                # 生成器训练
                self.generator_optimizer.zero_grad()

                noise = torch.randn(self.batch_size, input_dim).to(self.device)
                fake_data = self.generator(noise)

                generator_loss = -self.critic(fake_data).mean()
                generator_loss.backward()

                self.generator_optimizer.step()

                # 打印损失
                if i % 100 == 0:
                    print("[Epoch %d/%d] [Batch %d/%d] Critic Loss: %.4f Generator Loss: %.4f" %
                          (epoch, num_epochs, i, len(data_loader), critic_loss.item(), generator_loss.item()))

# 使用示例
input_dim = 96
output_dim = 96

# 加载数据集并创建 DataLoader
data_file = 'path/to/your/data.xlsx'
dataset = TimeSeriesDataset(data_file)
data_loader = DataLoader(dataset, batch_size=64, shuffle=True)

wgan = WGAN(input_dim, output_dim)
wgan.train(data_loader, num_epochs=10)

请确保根据你的具体任务进行适当的修改和调整，特别是在数据加载和预处理部分。此外，确保使用适当的损失函数和优化器进行训练。