生成对抗网络（Generative Adversarial Network，简称 GAN）

最新推荐文章于 2024-09-13 14:20:18 发布

先天无极编程圣体

最新推荐文章于 2024-09-13 14:20:18 发布

阅读量1.2k

点赞数 33

文章标签：生成对抗网络人工智能神经网络

本文链接：https://blog.csdn.net/qq_43689451/article/details/142067996

版权

生成对抗网络（Generative Adversarial Network，简称 GAN）是由Ian Goodfellow等人于2014年提出的一种深度学习模型架构，广泛用于图像生成、文本生成等生成任务。GAN由两个相互对抗的神经网络组成：生成器（Generator）和判别器（Discriminator），它们彼此博弈，共同提高生成数据的质量。

GAN的基本概念

生成器 (Generator)：生成器是一个神经网络，旨在从随机噪声中生成看起来像真实数据的伪数据。其输入通常是一个随机向量（例如，从标准正态分布中采样的噪声），输出是生成的伪数据（如生成图像）。
判别器 (Discriminator)：判别器也是一个神经网络，用于区分生成器生成的伪数据和真实数据。它的任务是最大化区分真实数据和伪数据的能力，输出是一个概率值，表示输入数据为真实数据的概率。

GAN的工作原理

生成器和判别器之间的博弈可以理解为一个“零和博弈”：

生成器试图通过生成逼真的伪数据来欺骗判别器，使其无法分辨生成的数据是伪造的还是真实的。
判别器的任务是准确判断输入数据是来自真实样本还是生成器的伪造样本。

在训练过程中，生成器的目标是最小化判别器对其生成数据的判断错误，而判别器的目标是最大化对真实数据和生成数据的区分能力。最终，GAN达到一个纳什均衡状态，此时生成器生成的伪数据质量非常接近于真实数据，判别器无法轻松区分两者。

GAN的损失函数基于最小-最大博弈的公式定义：

[
\min_G \max_D V(D, G) = \mathbb{E}{x \sim p{\text{data}}(x)} [\log D(x)] + \mathbb{E}_{z \sim p_z(z)} [\log(1 - D(G(z)))]
]

( G(z) )：生成器的输出，输入是随机噪声 ( z )。
( D(x) )：判别器对真实数据 ( x ) 的判断。
( \mathbb{E}{x \sim p{\text{data}}(x)} )：表示真实数据的期望。
( \mathbb{E}_{z \sim p_z(z)} )：表示生成数据的期望。

GAN的实现

以下是一个简单的GAN实现示例，使用PyTorch构建生成器和判别器网络，并在MNIST数据集上进行训练。

import torch
import torch.nn as nn
import torch.optim as optim
import torchvision
import torchvision.transforms as transforms

# 定义生成器
class Generator(nn.Module):
    def __init__(self, input_size, hidden_size, output_size):
        super(Generator, self).__init__()
        self.main = nn.Sequential(
            nn.Linear(input_size, hidden_size),
            nn.ReLU(True),
            nn.Linear(hidden_size, hidden_size),
            nn.ReLU(True),
            nn.Linear(hidden_size, output_size),
            nn.Tanh()  # Tanh激活函数将输出范围限制在[-1,1]
        )

    def forward(self, x):
        return self.main(x)

# 定义判别器
class Discriminator(nn.Module):
    def __init__(self, input_size, hidden_size, output_size):
        super(Discriminator, self).__init__()
        self.main = nn.Sequential(
            nn.Linear(input_size, hidden_size),
            nn.LeakyReLU(0.2, inplace=True),
            nn.Linear(hidden_size, hidden_size),
            nn.LeakyReLU(0.2, inplace=True),
            nn.Linear(hidden_size, output_size),
            nn.Sigmoid()  # Sigmoid输出一个概率值
        )

    def forward(self, x):
        return self.main(x)

# 超参数
batch_size = 100
image_size = 784  # MNIST 28x28 图像
hidden_size = 256
latent_size = 64   # 噪声向量的维度
learning_rate = 0.0002
num_epochs = 50

# MNIST数据集
transform = transforms.Compose([
    transforms.ToTensor(),
    transforms.Normalize(mean=(0.5,), std=(0.5,))  # 将像素值归一化到[-1, 1]之间
])

mnist = torchvision.datasets.MNIST(root='./data', train=True, transform=transform, download=True)
dataloader = torch.utils.data.DataLoader(dataset=mnist, batch_size=batch_size, shuffle=True)

# 初始化生成器和判别器
G = Generator(input_size=latent_size, hidden_size=hidden_size, output_size=image_size)
D = Discriminator(input_size=image_size, hidden_size=hidden_size, output_size=1)

# 损失函数和优化器
criterion = nn.BCELoss()
optimizer_G = optim.Adam(G.parameters(), lr=learning_rate)
optimizer_D = optim.Adam(D.parameters(), lr=learning_rate)

# 训练GAN
for epoch in range(num_epochs):
    for i, (images, _) in enumerate(dataloader):
        # 真实数据标签为1，伪造数据标签为0
        real_labels = torch.ones(batch_size, 1)
        fake_labels = torch.zeros(batch_size, 1)

        # 将真实图像展开为一维向量
        images = images.view(batch_size, -1)

        # ========== 训练判别器 ==========
        outputs = D(images)
        d_loss_real = criterion(outputs, real_labels)
        real_score = outputs

        # 生成假数据
        z = torch.randn(batch_size, latent_size)
        fake_images = G(z)
        outputs = D(fake_images)
        d_loss_fake = criterion(outputs, fake_labels)
        fake_score = outputs

        # 总的判别器损失
        d_loss = d_loss_real + d_loss_fake

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

        # ========== 训练生成器 ==========
        z = torch.randn(batch_size, latent_size)
        fake_images = G(z)
        outputs = D(fake_images)

        # 希望判别器判断生成的数据为真，即希望生成器骗过判别器
        g_loss = criterion(outputs, real_labels)

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

        if (i+1) % 200 == 0:
            print(f'Epoch [{epoch}/{num_epochs}], Step [{i+1}/{len(dataloader)}], d_loss: {d_loss.item():.4f}, g_loss: {g_loss.item():.4f}, D(x): {real_score.mean().item():.4f}, D(G(z)): {fake_score.mean().item():.4f}')