torch 构造 GAN 网络

GAN（Generative Adversarial Networks）是一种深度学习模型，用于生成具有与训练数据相似的新数据。GAN模型由两个神经网络组成：生成器（Generator）和判别器（Discriminator）。生成器接受一些噪声向量作为输入，并尝试生成新的数据样本，而判别器则接受生成器生成的数据样本和真实数据样本，并尝试区分它们。

下面是一个简单的GAN网络的构造方法，使用PyTorch框架来实现：

import torch
import torch.nn as nn

# 定义生成器模型
class Generator(nn.Module):
    def __init__(self, input_size, output_size):
        super(Generator, self).__init__()

        self.fc1 = nn.Linear(input_size, 128)
        self.fc2 = nn.Linear(128, 256)
        self.fc3 = nn.Linear(256, 512)
        self.fc4 = nn.Linear(512, output_size)

        self.relu = nn.ReLU()
        self.tanh = nn.Tanh()

    def forward(self, x):
        x = self.relu(self.fc1(x))
        x = self.relu(self.fc2(x))
        x = self.relu(self.fc3(x))
        x = self.tanh(self.fc4(x))

        return x

# 定义判别器模型
class Discriminator(nn.Module):
    def __init__(self, input_size):
        super(Discriminator, self).__init__()

        self.fc1 = nn.Linear(input_size, 512)
        self.fc2 = nn.Linear(512, 256)
        self.fc3 = nn.Linear(256, 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

# 定义训练函数
def train(generator, discriminator, data, epochs, batch_size, learning_rate):
    # 定义损失函数
    criterion = nn.BCELoss()

    # 定义优化器
    gen_optimizer = torch.optim.Adam(generator.parameters(), lr=learning_rate)
    dis_optimizer = torch.optim.Adam(discriminator.parameters(), lr=learning_rate)

    # 训练GAN模型
    for epoch in range(epochs):
        for i in range(0, len(data), batch_size):
            # 训练判别器
            real_data = data[i:i+batch_size]
            real_labels = torch.ones((len(real_data), 1))

            noise = torch.randn((len(real_data), 100))
            fake_data = generator(noise).detach()
            fake_labels = torch.zeros((len(fake_data), 1))

            dis_optimizer.zero_grad()

            real_loss = criterion(discriminator(real_data), real_labels)
            fake_loss = criterion(discriminator(fake_data), fake_labels)

            dis_loss = real_loss + fake_loss
            dis_loss.backward()
            dis_optimizer.step()

            # 训练生成器
            noise = torch.randn((len(real_data), 100))
            gen_optimizer.zero_grad()

            gen_loss = criterion(discriminator(generator(noise)), real_labels)
            gen_loss.backward()
            gen_optimizer.step()

        print(f"Epoch [{epoch+1}/{epochs}], Generator loss: {gen_loss.item()}, Discriminator loss: {dis_loss.item()}")

# 定义一些超参数
input_size = 100
output_size = 784
epochs = 50
batch_size = 64
learning_rate = 0.0002

# 加载MNIST数据集
transform = transforms.Compose([transforms.ToTensor(), transforms.Normalize((0.5,), (0.5,))])
trainset = datasets.MNIST('~/.pytorch/MNIST_data/', train=True, download=True, transform=transform)
trainloader = torch.utils.data.DataLoader(trainset, batch_size=batch_size, shuffle=True)

# 实例化生成器和判别器
generator = Generator(input_size, output_size)
discriminator = Discriminator(output_size)

# 训练GAN模型
train(generator, discriminator, trainloader, epochs, batch_size, learning_rate)

在这个例子中，我们定义了一个简单的生成器模型和判别器模型，并使用MNIST数据集训练了GAN模型。在训练过程中，我们使用了交替训练的策略，即先训练判别器，再训练生成器。我们还定义了一些超参数，如输入向量的大小、输出向量的大小、训练周期数、批次大小和学习率等。