G1 GAN生成MNIST手写数字图像

🍨 本文为🔗365天深度学习训练营中的学习记录博客
🍖 原作者：K同学啊

G1 GAN生成MNIST手写数字图像

1. 生成对抗网络 (GAN) 简介

生成对抗网络 (GAN) 是一种通过"对抗性"学习生成数据的深度学习模型，通常用于生成图像、视频等数据。GAN 由两个网络组成：

生成器 (Generator)：用于生成假的数据样本，试图让判别器无法分辨其为假的。
判别器 (Discriminator)：用于区分输入的数据是真实的还是生成器生成的。

GAN 的核心思想是，生成器和判别器通过相互对抗学习，生成器逐渐提高生成逼真数据的能力，而判别器逐渐提高区分真假数据的能力。最后，生成器生成的样本与真实样本之间的差异会越来越小。

GAN 的基本流程

判别器输入真实数据，判别器输出一个接近1的值，表示为真；
生成器生成假的数据，并试图欺骗判别器；
判别器输出接近0的值，表示为假；
生成器通过更新自身的参数，试图让判别器认为生成的数据是真实的。

GAN 的目标是使得生成器生成的假数据，能骗过判别器。

GAN 的损失函数

GAN 的训练目标是让生成器和判别器进行对抗训练，其损失函数分为两个部分：生成器损失和判别器损失。生成器的目标是最大化判别器判断生成数据为真的概率，判别器的目标是最大化正确判断真实数据和生成数据的概率。

判别器的损失函数定义为：

L D = − $E x ∼ p data \[ log ⁡ D ( x )$ + E z ∼ p z $log ( 1 - D ( G ( z ) ) )$ ] \mathcal{L}D = - \left $\\mathbb{E}_{x \\sim p_{\\text{data}}} \\left\[ \\log D(x) \\right$ + \mathbb{E}{z \sim p_z} \left $\\log (1 - D(G(z))) \\right$ \right] LD=− $Ex∼pdata\[logD(x)$ +Ez∼pz $log(1-D(G(z)))$ ]

生成器的损失函数定义为：

L G = − E z ∼ p z $log D ( G ( z ) )$ \mathcal{L}G = - \mathbb{E}{z \sim p_z} \left $\\log D(G(z)) \\right$ LG=−Ez∼pz $logD(G(z))$

其中：

( D(x) ) 表示判别器对真实数据 ( x ) 判别为真的概率；
( G(z) ) 是生成器通过噪声 ( z ) 生成的假数据；
( D(G(z)) ) 表示判别器对生成器生成数据的输出（希望趋向于1）。

2. PyTorch 实现

下面使用 PyTorch 实现 GAN 生成 MNIST 手写数字图像。

2.1 导入库与超参数设置

python 复制代码

import os
import numpy as np
import torch
import torch.nn as nn
from torchvision import datasets, transforms
from torch.utils.data import DataLoader
from torchvision.utils import save_image

# 创建文件夹
os.makedirs('./output/images/', exist_ok=True)

# 超参数设置
n_epochs = 50
batch_size = 64
lr = 0.0002
latent_dim = 100
img_size = 28
channels = 1
img_shape = (channels, img_size, img_size)
img_area = np.prod(img_shape)

cuda = True if torch.cuda.is_available() else False

2.2 数据预处理

使用 torchvision.datasets.MNIST 下载并处理 MNIST 数据集。数据会被标准化到 $-1, 1$ 区间，并通过 DataLoader 转化为可迭代数据集。

python 复制代码

# 下载MNIST数据集并进行预处理
mnist = datasets.MNIST(root='./data', train=True, download=True,
                       transform=transforms.Compose([
                           transforms.Resize(img_size),
                           transforms.ToTensor(),
                           transforms.Normalize([0.5], [0.5])
                       ]))

dataloader = DataLoader(mnist, batch_size=batch_size, shuffle=True)

2.3 定义生成器模型

生成器接受一个随机噪声向量 ( z )，通过多层线性变换和激活函数逐步生成一个 28x28 的图像。

python 复制代码

class Generator(nn.Module):
    def __init__(self):
        super(Generator, self).__init__()
        def block(in_feat, out_feat, normalize=True):
            layers = [nn.Linear(in_feat, out_feat)]
            if normalize:
                layers.append(nn.BatchNorm1d(out_feat, 0.8))
            layers.append(nn.LeakyReLU(0.2, inplace=True))
            return layers

        self.model = nn.Sequential(
            *block(latent_dim, 128, normalize=False),
            *block(128, 256),
            *block(256, 512),
            *block(512, 1024),
            nn.Linear(1024, img_area),
            nn.Tanh()
        )

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

2.4 定义判别器模型

判别器是一个二分类网络，输入一个 28x28 的图像，输出一个表示真假概率的值。

python 复制代码

class Discriminator(nn.Module):
    def __init__(self):
        super(Discriminator, self).__init__()
        self.model = nn.Sequential(
            nn.Linear(img_area, 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.model(img_flat)
        return validity

2.5 定义优化器与损失函数

python 复制代码

generator = Generator()
discriminator = Discriminator()

# 定义损失函数
criterion = nn.BCELoss()

# 定义生成器和判别器的优化器
optimizer_G = torch.optim.Adam(generator.parameters(), lr=lr, betas=(0.5, 0.999))
optimizer_D = torch.optim.Adam(discriminator.parameters(), lr=lr, betas=(0.5, 0.999))

if cuda:
    generator.cuda()
    discriminator.cuda()
    criterion.cuda()

2.6 训练过程

2.6.1 训练判别器

判别器需要区分真实图像和生成的假图像，通过两个损失值相加，更新判别器的参数。

python 复制代码

real_img = Variable(imgs.type(torch.cuda.FloatTensor))
real_label = Variable(torch.ones(imgs.size(0), 1).cuda())
fake_label = Variable(torch.zeros(imgs.size(0), 1).cuda())

real_out = discriminator(real_img)
loss_real = criterion(real_out, real_label)

z = Variable(torch.randn(imgs.size(0), latent_dim).cuda())
fake_img = generator(z).detach()
fake_out = discriminator(fake_img)
loss_fake = criterion(fake_out, fake_label)

loss_D = loss_real + loss_fake
optimizer_D.zero_grad()
loss_D.backward()
optimizer_D.step()

2.6.2 训练生成器

生成器的目标是让判别器认为生成的数据是真实的，因此生成器的损失是判别器对假图像的输出。

python 复制代码

z = Variable(torch.randn(imgs.size(0), latent_dim).cuda())
fake_img = generator(z)
output = discriminator(fake_img)

loss_G = criterion(output, real_label)
optimizer_G.zero_grad()
loss_G.backward()
optimizer_G.step()

2.7 保存与可视化生成图像

python 复制代码

if batches_done % sample_interval == 0:
    save_image(fake_img.data[:25], "./output/images/%d.png" % batches_done, nrow=5, normalize=True)

4. 总结

这周学习了如何使用 PyTorch 实现生成对抗网络 (GAN) 来生成 MNIST 手写数字图像。GAN 通过生成器与判别器之间的对抗学习，不断提升生成图像的质量，是一种非常强大的生成模型。可以在论文中将其作为数据增强的一种方式。

复制代码