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 torch.utils.data import DataLoader
    import matplotlib.pyplot as plt
    
    # 定义生成器网络
    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.model = nn.Sequential(
            nn.Linear(latent_dim, 256),
            nn.LeakyReLU(0.2, inplace=True),
            nn.BatchNorm1d(256),
            nn.Linear(256, 512),
            nn.LeakyReLU(0.2, inplace=True),
            nn.BatchNorm1d(512),
            nn.Linear(512, 1024),
            nn.LeakyReLU(0.2, inplace=True),
            nn.BatchNorm1d(1024),
            nn.Linear(1024, int(np.prod(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.model = nn.Sequential(
            nn.Linear(int(np.prod(img_shape)), 512),
            nn.LeakyReLU(0.2, inplace=True),
            nn.Dropout(0.3),
            nn.Linear(512, 256),
            nn.LeakyReLU(0.2, inplace=True),
            nn.Dropout(0.3),
            nn.Linear(256, 1),
            nn.Sigmoid()
        )
    
    def forward(self, img):
        img_flat = img.view(img.size(0), -1)
        validity = self.model(img_flat)
        return validity
    
    # 训练GAN
    def train_gan(epochs=100, batch_size=64, lr=0.0002):
    # 加载MNIST数据集
    transform = Compose([ToTensor()])
    dataset = MNIST(root='./data', train=True, download=True, transform=transform)
    dataloader = DataLoader(dataset, batch_size=batch_size, shuffle=True)
    
    # 初始化生成器和判别器
    generator = Generator().to(device)
    discriminator = Discriminator().to(device)
    
    # 定义优化器和损失函数
    g_optimizer = optim.Adam(generator.parameters(), lr=lr, betas=(0.5, 0.999))
    d_optimizer = optim.Adam(discriminator.parameters(), lr=lr, betas=(0.5, 0.999))
    adversarial_loss = nn.BCELoss()
    
    for epoch in range(epochs):
        for i, (real_imgs, _) in enumerate(dataloader):
            batch_size = real_imgs.size(0)
            real_imgs = real_imgs.to(device)
    
            # 训练判别器
            d_optimizer.zero_grad()
            real_validity = discriminator(real_imgs)
            real_loss = adversarial_loss(real_validity, torch.ones_like(real_validity))
    
            noise = torch.randn(batch_size, 100).to(device)
            fake_imgs = generator(noise)
            fake_validity = discriminator(fake_imgs.detach())
            fake_loss = adversarial_loss(fake_validity, torch.zeros_like(fake_validity))
            d_loss = 0.5 * (real_loss + fake_loss)
            d_loss.backward()
            d_optimizer.step()
    
            # 训练生成器
            g_optimizer.zero_grad()
            fake_validity = discriminator(fake_imgs)
            g_loss = adversarial_loss(fake_validity, torch.ones_like(fake_validity))
            g_loss.backward()
            g_optimizer.step()
    
            if (i+1) % 100 == 0:
                print(f'Epoch [{epoch+1}/{epochs}], Step [{i+1}/{len(dataloader)}], D_loss: {d_loss.item():.4f}, G_loss: {g_loss.item():.4f}')
    
    return generator, discriminator
    
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
    
    代码解读