请给出一个参考代码范例

以下是一个使用PyTorch实现的一维信号GAN生成的参考代码范例：

import torch
import torch.nn as nn
import torch.optim as optim
from torch.utils.data import DataLoader

# 定义生成器网络
class Generator(nn.Module):
    def __init__(self, input_size, output_size, hidden_size):
        super(Generator, self).__init__()
        self.fc1 = nn.Linear(input_size, hidden_size)
        self.fc2 = nn.Linear(hidden_size, hidden_size)
        self.fc3 = nn.Linear(hidden_size, output_size)

    def forward(self, x):
        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_size, hidden_size):
        super(Discriminator, self).__init__()
        self.fc1 = nn.Linear(input_size, hidden_size)
        self.fc2 = nn.Linear(hidden_size, hidden_size)
        self.fc3 = nn.Linear(hidden_size, 1)

    def forward(self, x):
        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(generator, discriminator, train_loader, num_epochs, learning_rate):
    # 定义损失函数和优化器
    criterion = nn.BCELoss()
    g_optimizer = optim.Adam(generator.parameters(), lr=learning_rate)
    d_optimizer = optim.Adam(discriminator.parameters(), lr=learning_rate)

    # 开始训练
    for epoch in range(num_epochs):
        for i, real_data in enumerate(train_loader):
            # 训练判别器
            discriminator.zero_grad()
            real_data = real_data.view(-1, 1)
            real_labels = torch.ones(real_data.size(0), 1)
            fake_labels = torch.zeros(real_data.size(0), 1)
            real_pred = discriminator(real_data)
            d_real_loss = criterion(real_pred, real_labels)
            d_real_loss.backward()

            noise = torch.randn(real_data.size(0), 100)
            fake_data = generator(noise)
            fake_pred = discriminator(fake_data.detach())
            d_fake_loss = criterion(fake_pred, fake_labels)
            d_fake_loss.backward()

            d_optimizer.step()

            # 训练生成器
            generator.zero_grad()
            noise = torch.randn(real_data.size(0), 100)
            fake_data = generator(noise)
            fake_pred = discriminator(fake_data)
            g_loss = criterion(fake_pred, real_labels)
            g_loss.backward()

            g_optimizer.step()

            # 输出训练状态
            if i % 100 == 0:
                print("Epoch [{}/{}], Step [{}/{}], d_real_loss: {:.4f}, d_fake_loss: {:.4f}, g_loss: {:.4f}"
                      .format(epoch, num_epochs, i, len(train_loader), d_real_loss.item(), d_fake_loss.item(), g_loss.item()))

# 训练数据集
train_data = torch.randn(1000, 1)

# 创建数据加载器
train_loader = DataLoader(train_data, batch_size=50, shuffle=True)

# 创建生成器和判别器
generator = Generator(100, 1, 128)
discriminator = Discriminator(1, 128)

# 训练GAN模型
train(generator, discriminator, train_loader, 20, 0.001)

# 生成新的一维信号
noise = torch.randn(1000, 100)
generated_data = generator(noise)

这个代码范例使用一个简单的全连接网络作为生成器和判别器，并使用BCE损失函数和Adam优化器进行训练。在训练完成后，使用生成器网络生成了1000个新的一维信号数据。