wgan-gp代码

WGAN-GP是一种基于GAN的深度学习模型，它使用了梯度惩罚技术（Gradient Penalty，GP）来解决GAN训练过程中的不稳定性和模式崩溃问题。以下是一个简单的WGAN-GP的PyTorch实现代码：

import torch
import torch.nn as nn
import torch.optim as optim
import numpy as np

# 定义生成器和判别器的网络结构
class Generator(nn.Module):
    def __init__(self, latent_dim=100, img_shape=(1, 28, 28)):
        super(Generator, self).__init__()
        self.latent_dim = latent_dim
        self.img_shape = img_shape

        self.model = nn.Sequential(
            nn.Linear(self.latent_dim, 128),
            nn.LeakyReLU(0.2, inplace=True),
            nn.Linear(128, 256),
            nn.BatchNorm1d(256, 0.8),
            nn.LeakyReLU(0.2, inplace=True),
            nn.Linear(256, 512),
            nn.BatchNorm1d(512, 0.8),
            nn.LeakyReLU(0.2, inplace=True),
            nn.Linear(512, np.prod(self.img_shape)),
            nn.Tanh()
        )

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

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

        self.model = nn.Sequential(
            nn.Linear(np.prod(self.img_shape), 512),
            nn.LeakyReLU(0.2, inplace=True),
            nn.Linear(512, 256),
            nn.LeakyReLU(0.2, inplace=True),
            nn.Linear(256, 1),
        )

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

# 定义WGAN-GP模型
class WGAN_GP(nn.Module):
    def __init__(self, latent_dim=100, img_shape=(1, 28, 28), lambda_gp=10):
        super(WGAN_GP, self).__init__()
        self.generator = Generator(latent_dim, img_shape)
        self.discriminator = Discriminator(img_shape)
        self.lambda_gp = lambda_gp

    def forward(self, z):
        return self.generator(z)

    def gradient_penalty(self, real_images, fake_images):
        batch_size = real_images.size(0)

        # 随机生成采样权重
        alpha = torch.rand(batch_size, 1, 1, 1).cuda()
        alpha = alpha.expand_as(real_images)

        # 生成采样图像
        interpolated = (alpha * real_images) + ((1 - alpha) * fake_images)
        interpolated.requires_grad_(True)

        # 计算插值图像的判别器输出
        prob_interpolated = self.discriminator(interpolated)

        # 计算梯度
        gradients = torch.autograd.grad(outputs=prob_interpolated, inputs=interpolated,
                                        grad_outputs=torch.ones(prob_interpolated.size()).cuda(),
                                        create_graph=True, retain_graph=True)[0]

        # 计算梯度惩罚项
        gradients = gradients.view(batch_size, -1)
        gradient_penalty = ((gradients.norm(2, dim=1) - 1) ** 2).mean() * self.lambda_gp
        return gradient_penalty

# 定义训练函数
def train_wgan_gp(generator, discriminator, dataloader, num_epochs=200, batch_size=64, lr=0.0002, betas=(0.5, 0.999)):
    # 损失函数
    adversarial_loss = torch.nn.MSELoss()

    # 优化器
    optimizer_G = optim.Adam(generator.parameters(), lr=lr, betas=betas)
    optimizer_D = optim.Adam(discriminator.parameters(), lr=lr, betas=betas)

    for epoch in range(num_epochs):
        for i, (imgs, _) in enumerate(dataloader):
            batch_size = imgs.shape[0]

            # 配置设备
            real_imgs = imgs.cuda()

            # 训练判别器
            optimizer_D.zero_grad()

            # 随机生成噪声
            z = torch.randn(batch_size, 100).cuda()

            # 生成假图像
            fake_imgs = generator(z)

            # 计算判别器损失
            loss_D = -torch.mean(discriminator(real_imgs)) + torch.mean(discriminator(fake_imgs))

            # 计算梯度惩罚项
            gp = discriminator.gradient_penalty(real_imgs, fake_imgs)
            loss_D += gp

            # 反向传播和优化
            loss_D.backward()
            optimizer_D.step()

            # 限制判别器的参数范围
            for p in discriminator.parameters():
                p.data.clamp_(-0.01, 0.01)

            # 训练生成器
            optimizer_G.zero_grad()

            # 随机生成噪声
            z = torch.randn(batch_size, 100).cuda()

            # 生成假图像
            fake_imgs = generator(z)

            # 计算生成器损失
            loss_G = -torch.mean(discriminator(fake_imgs))

            # 反向传播和优化
            loss_G.backward()
            optimizer_G.step()

            # 打印损失
            if i % 50 == 0:
                print("[Epoch %d/%d] [Batch %d/%d] [D loss: %f] [G loss: %f]" % (epoch, num_epochs, i, len(dataloader), loss_D.item(), loss_G.item()))

在使用该代码时，需要先准备好数据集并将其转换为PyTorch的DataLoader格式，并调用train_wgan_gp函数进行训练。