使用1*N数据集训练gan模型代码

这里是一个使用PyTorch实现的针对1*N数据集的GAN模型训练代码示例：

import torch
import torch.nn as nn
import torch.optim as optim
from torch.utils.data import DataLoader
from torchvision.datasets import MNIST
from torchvision.transforms import transforms
from torchvision.utils import save_image

# 定义生成器和判别器模型
class Generator(nn.Module):
    def __init__(self, input_dim=100, output_dim=784):
        super(Generator, self).__init__()
        self.fc = nn.Sequential(
            nn.Linear(input_dim, 256),
            nn.ReLU(inplace=True),
            nn.Linear(256, 512),
            nn.ReLU(inplace=True),
            nn.Linear(512, 1024),
            nn.ReLU(inplace=True),
            nn.Linear(1024, output_dim),
            nn.Tanh()
        )

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

class Discriminator(nn.Module):
    def __init__(self, input_dim=784, output_dim=1):
        super(Discriminator, self).__init__()
        self.fc = nn.Sequential(
            nn.Linear(input_dim, 1024),
            nn.ReLU(inplace=True),
            nn.Dropout(p=0.3),
            nn.Linear(1024, 512),
            nn.ReLU(inplace=True),
            nn.Dropout(p=0.3),
            nn.Linear(512, 256),
            nn.ReLU(inplace=True),
            nn.Dropout(p=0.3),
            nn.Linear(256, output_dim),
            nn.Sigmoid()
        )

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

# 定义训练函数
def train_GAN(generator, discriminator, train_loader, device, num_epochs=200):
    generator.to(device)
    discriminator.to(device)

    # 定义损失函数和优化器
    criterion = nn.BCELoss()
    g_optimizer = optim.Adam(generator.parameters(), lr=0.0002)
    d_optimizer = optim.Adam(discriminator.parameters(), lr=0.0002)

    for epoch in range(num_epochs):
        for i, (real_images, _) in enumerate(train_loader):
            # 将真实图像和标签移动到GPU
            real_images = real_images.to(device)

            # 训练判别器
            discriminator.zero_grad()

            # 计算真实图像的判别结果
            real_labels = torch.ones(real_images.size(0), 1).to(device)
            real_outputs = discriminator(real_images)
            d_loss_real = criterion(real_outputs, real_labels)

            # 生成假图像并计算假图像的判别结果
            noise = torch.randn(real_images.size(0), 100).to(device)
            fake_images = generator(noise)
            fake_labels = torch.zeros(real_images.size(0), 1).to(device)
            fake_outputs = discriminator(fake_images.detach())
            d_loss_fake = criterion(fake_outputs, fake_labels)

            # 计算判别器的总损失并进行反向传播优化
            d_loss = d_loss_real + d_loss_fake
            d_loss.backward()
            d_optimizer.step()

            # 训练生成器
            generator.zero_grad()

            # 生成假图像并计算其判别结果
            fake_images = generator(noise)
            fake_outputs = discriminator(fake_images)

            # 计算生成器的损失并进行反向传播优化
            g_loss = criterion(fake_outputs, real_labels)
            g_loss.backward()
            g_optimizer.step()

            if (i+1) % 100 == 0:
                print('Epoch [{}/{}], Step [{}/{}], d_loss: {:.4f}, g_loss: {:.4f}'
                    .format(epoch+1, num_epochs, i+1, len(train_loader), d_loss.item(), g_loss.item()))

        # 保存生成的假图像
        if (epoch+1) % 10 == 0:
            fake_images = generator(noise).reshape(-1, 1, 28, 28)
            save_image(fake_images, 'fake_images-{}.png'.format(epoch+1), normalize=True)

# 加载数据集
transform = transforms.Compose([
    transforms.ToTensor(),
    transforms.Normalize(mean=[0.5], std=[0.5])
])
train_dataset = MNIST(root='./data', train=True, transform=transform, download=True)
train_loader = DataLoader(train_dataset, batch_size=128, shuffle=True)

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

# 创建生成器和判别器模型
generator = Generator()
discriminator = Discriminator()

# 训练GAN模型
train_GAN(generator, discriminator, train_loader, device, num_epochs=200)

这个例子中，我们使用了MNIST数据集作为1*N的数据集，生成器和判别器模型都是基于全连接层的简单网络。在训练GAN模型时，我们需要按照GAN的训练流程，先训练判别器，再训练生成器。在每个epoch结束时，我们将生成器生成的假图像保存下来以供查看。