生成对抗网络在创意中的应用

    import torch
    import torch.nn as nn
    import torch.optim as optim
    from torchvision.datasets import MNIST
    from torchvision import transforms
    from torch.utils.data import DataLoader
    
    # 定义生成器网络
    class Generator(nn.Module):
    def __init__(self, latent_dim=100):
        super(Generator, self).__init__()
        self.main = nn.Sequential(
            nn.Linear(latent_dim, 256),
            nn.ReLU(True),
            nn.Linear(256, 512),
            nn.ReLU(True),
            nn.Linear(512, 1024),
            nn.ReLU(True),
            nn.Linear(1024, 784),
            nn.Tanh()
        )
    
    def forward(self, input):
        return self.main(input)
    
    # 定义判别器网络
    class Discriminator(nn.Module):
    def __init__(self):
        super(Discriminator, self).__init__()
        self.main = nn.Sequential(
            nn.Linear(784, 1024),
            nn.LeakyReLU(0.2, inplace=True),
            nn.Dropout(0.3),
            nn.Linear(1024, 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, input):
        return self.main(input.view(input.size(0), -1))
    
    # 训练过程
    latent_dim = 100
    batch_size = 64
    num_epochs = 100
    
    dataset = MNIST(root='./data', download=True, transform=transforms.ToTensor())
    dataloader = DataLoader(dataset, batch_size=batch_size, shuffle=True)
    
    device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
    
    generator = Generator(latent_dim).to(device)
    discriminator = Discriminator().to(device)
    
    g_optimizer = optim.Adam(generator.parameters(), lr=0.0002, betas=(0.5, 0.999))
    d_optimizer = optim.Adam(discriminator.parameters(), lr=0.0002, betas=(0.5, 0.999))
    
    for epoch in range(num_epochs):
    for i, (real_samples, _) in enumerate(dataloader):
        # 训练判别器
        real_samples = real_samples.to(device)
        d_optimizer.zero_grad()
        real_output = discriminator(real_samples)
        real_loss = -torch.mean(torch.log(real_output))
    
        latent_samples = torch.randn(batch_size, latent_dim, device=device)
        fake_samples = generator(latent_samples)
        fake_output = discriminator(fake_samples.detach())
        fake_loss = -torch.mean(torch.log(1 - fake_output))
    
        d_loss = real_loss + fake_loss
        d_loss.backward()
        d_optimizer.step()
    
        # 训练生成器
        g_optimizer.zero_grad()
        latent_samples = torch.randn(batch_size, latent_dim, device=device)
        fake_samples = generator(latent_samples)
        fake_output = discriminator(fake_samples)
        g_loss = -torch.mean(torch.log(fake_output))
        g_loss.backward()
        g_optimizer.step()
    
        if (i + 1) % 100 == 0:
            print(f'Epoch [{epoch+1}/{num_epochs}], Step [{i+1}/{len(dataloader)}], D_loss: {d_loss.item()}, G_loss: {g_loss.item()}')
    
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
    
    代码解读