GAN在图像生成领域的应用

    import torch
    import torch.nn as nn
    import torch.optim as optim
    from torchvision.datasets import MNIST
    from torchvision.transforms import Compose, ToTensor
    from torchvision.utils import save_image
    
    # 定义生成器网络
    class Generator(nn.Module):
    def __init__(self, latent_dim=100, img_shape=(1, 28, 28)):
        super(Generator, self).__init__()
        self.img_shape = img_shape
        self.net = nn.Sequential(
            nn.Linear(latent_dim, 256),
            nn.LeakyReLU(0.2, inplace=True),
            nn.Linear(256, 512),
            nn.LeakyReLU(0.2, inplace=True),
            nn.Linear(512, 1024),
            nn.LeakyReLU(0.2, inplace=True),
            nn.Linear(1024, int(np.prod(img_shape))),
            nn.Tanh()
        )
    
    def forward(self, z):
        img = self.net(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.net = nn.Sequential(
            nn.Linear(int(np.prod(img_shape)), 512),
            nn.LeakyReLU(0.2, inplace=True),
            nn.Linear(512, 256),
            nn.LeakyReLU(0.2, inplace=True),
            nn.Linear(256, 1),
            nn.Sigmoid()
        )
    
    def forward(self, img):
        img_flat = img.view(img.size(0), -1)
        validity = self.net(img_flat)
        return validity
    
    # 训练GAN
    def train_gan(epochs=200, batch_size=64, lr=0.0002):
    # 加载MNIST数据集
    transform = Compose([ToTensor()])
    dataset = MNIST(root='data/', transform=transform, download=True)
    dataloader = torch.utils.data.DataLoader(dataset, batch_size=batch_size, shuffle=True)
    
    # 初始化生成器和判别器
    generator = Generator()
    discriminator = Discriminator()
    generator.cuda()
    discriminator.cuda()
    
    # 定义优化器和损失函数
    g_optimizer = optim.Adam(generator.parameters(), lr=lr)
    d_optimizer = optim.Adam(discriminator.parameters(), lr=lr)
    adversarial_loss = nn.BCELoss()
    
    for epoch in range(epochs):
        for i, (real_imgs, _) in enumerate(dataloader):
            # 训练判别器
            real_imgs = real_imgs.cuda()
            z = torch.randn(real_imgs.size(0), 100).cuda()
            fake_imgs = generator(z)
    
            real_validity = discriminator(real_imgs)
            fake_validity = discriminator(fake_imgs)
    
            d_real_loss = adversarial_loss(real_validity, torch.ones_like(real_validity))
            d_fake_loss = adversarial_loss(fake_validity, torch.zeros_like(fake_validity))
            d_loss = (d_real_loss + d_fake_loss) / 2
    
            d_optimizer.zero_grad()
            d_loss.backward()
            d_optimizer.step()
    
            # 训练生成器
            z = torch.randn(real_imgs.size(0), 100).cuda()
            fake_imgs = generator(z)
            fake_validity = discriminator(fake_imgs)
    
            g_loss = adversarial_loss(fake_validity, torch.ones_like(fake_validity))
    
            g_optimizer.zero_grad()
            g_loss.backward()
            g_optimizer.step()
    
            # 打印训练信息
            print(f'Epoch [{epoch+1}/{epochs}], Step [{i+1}/{len(dataloader)}], D_loss: {d_loss.item():.4f}, G_loss: {g_loss.item():.4f}')
    
        # 保存生成的图像样本
        z = torch.randn(64, 100).cuda()
        gen_imgs = generator(z)
        save_image(gen_imgs.data, f'images/sample_{epoch+1}.png', nrow=8, normalize=True)
    
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
    
    代码解读