pytorch 实现 LSGAN

LSGAN，全称为 Least Squares Generative Adversarial Networks，是一种生成对抗网络（GAN）的变体，它使用最小二乘损失函数来代替传统的交叉熵损失函数，从而提高了生成器的稳定性和输出质量。

下面是使用 PyTorch 实现 LSGAN 的基本步骤：

1. 导入所需的库

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

2. 定义生成器和判别器网络

class Generator(nn.Module):
    def __init__(self, latent_dim=100, img_channels=1, img_size=28):
        super(Generator, self).__init__()
        self.img_size = img_size

        self.model = nn.Sequential(
            nn.Linear(latent_dim, 128),
            nn.ReLU(inplace=True),
            nn.Linear(128, img_size * img_size * img_channels),
            nn.Tanh()
        )

    def forward(self, z):
        img = self.model(z)
        img = img.view(img.size(0), 1, self.img_size, self.img_size)
        return img


class Discriminator(nn.Module):
    def __init__(self, img_channels=1, img_size=28):
        super(Discriminator, self).__init__()

        self.model = nn.Sequential(
            nn.Linear(img_size * img_size * img_channels, 128),
            nn.LeakyReLU(0.2, inplace=True),
            nn.Linear(128, 1)
        )

    def forward(self, img):
        img = img.view(img.size(0), -1)
        validity = self.model(img)
        return validity

3. 定义损失函数和优化器

adversarial_loss = nn.MSELoss()
generator = Generator()
discriminator = Discriminator()
optimizer_G = optim.Adam(generator.parameters(), lr=0.0002, betas=(0.5, 0.999))
optimizer_D = optim.Adam(discriminator.parameters(), lr=0.0002, betas=(0.5, 0.999))

4. 训练模型

for epoch in range(num_epochs):
    for i, (imgs, _) in enumerate(dataloader):

        # 训练判别器
        optimizer_D.zero_grad()

        real_imgs = imgs.cuda()
        z = torch.randn(batch_size, latent_dim).cuda()
        fake_imgs = generator(z)

        real_validity = discriminator(real_imgs)
        fake_validity = discriminator(fake_imgs.detach())

        d_loss_real = adversarial_loss(real_validity, torch.ones(batch_size, 1).cuda())
        d_loss_fake = adversarial_loss(fake_validity, torch.zeros(batch_size, 1).cuda())
        d_loss = 0.5 * (d_loss_real + d_loss_fake)

        d_loss.backward()
        optimizer_D.step()

        # 训练生成器
        optimizer_G.zero_grad()

        z = torch.randn(batch_size, latent_dim).cuda()
        fake_imgs = generator(z)
        fake_validity = discriminator(fake_imgs)

        g_loss = adversarial_loss(fake_validity, torch.ones(batch_size, 1).cuda())

        g_loss.backward()
        optimizer_G.step()

5. 生成样本

# 生成样本
z = torch.randn(num_samples, latent_dim).cuda()
samples = generator(z)

这就是使用 PyTorch 实现 LSGAN 的基本步骤。你可以根据自己的需求进行调整和优化。