小晨
2023/03/12阅读：10主题：默认主题
【陈锐1】理解 Generative Adversarial Networks (GAN)
理解 Generative Adversarial Networks (GAN)
介绍
生成式对抗网络 (GAN) 是 Ian Goodfellow 和他的同事在 2014 年 6 月设计的一类机器学习框架。GAN 是隐式的生成模型，可以拟合数据的真实分布。
现在我们对生成大小为 像素的黑白正方形狗的图像感兴趣。我们可以将每个数据重塑为 维向量 (通过将所有列堆叠起来)，这样狗的图像就可以用一个向量表示。然而，这并不意味着任意的向量都代表被重塑过的一只狗！因此，看起来像狗的 维向量是根据整个 维向量空间 (空间的一些点) 上的一个非常特定的概率分布。那么，生成狗的新图像的问题等价于在N维向量空间上按照“狗的概率分布”生成一个新向量的问题。在这一点上，提到了两件重要的事情。首先，我们提到的“狗概率分布”是一个在非常大的空间上非常复杂的分布。其次，即使我们可以假设存在这样的潜在分布，我们显然不知道如何明确地表达这种分布。上述两点使得从这个分布生成随机变量的过程相当困难。GAN 尝试解决了这个问题。
GAN 通过一个神经网络 (生成器) 来建模转换函数，该神经网络将一个简单的 维均匀随机变量作为输入，并将另一个 维随机变量作为输出，该 维随机变量应该在训练后遵循正确的“狗概率分布”。
同时，还有一个神经网络 (判别器) 作为下游任务来区分真实样本和生成样本。因此，在GAN架构中，我们有一个判别器，它从真实的和生成的数据中提取样本，并尽可能地对它们进行分类，还有一个经过训练的生成器，它可以尽可能地欺骗鉴别器。下图展示两者的博弈过程，橙色是生成器拟合的分布，蓝色代表真实分布，曲线表示判别器输入对应数据输出的置信度，最终变为了 0.5。
生成器和判别器以相反的目标 (同时) 联合训练:
-
生成器的目标是欺骗判别器，因此生成网络被训练为最大化最终判别器的分类错误
-
鉴别器的目标是检测虚假生成数据，因此判别网络被训练为最小化最终分类错误
这种相反的目标和两个网络对抗性训练的隐含概念解释了“对抗性网络”的名称。它们之间的竞争使得这两个网络朝着各自的目标“前进”。从博弈论的角度来看，我们可以把这个设定看作是一个极大极小的两方博弈，其中均衡状态对应于这样的情况：生成器从精确的目标分布中产生数据，判别器无法判断“真”或”假“，对于所有输入都以 50% 的随机概率进行判别。(尽管这很难实现)。
数学推导
两个度量用于量化两个概率分布之间的相似性：
KL (Kullback-Leibler) 散度度量一个概率分布 偏离第二个期望概率分布 的程度：
当 时， 达到最小值 0. KL散度是不对称的。当想测量两个同样重要的分布之间的相似性且 接近 0 时，它可能会导致错误的结果。
JS (Jensen-Shannon) 散度是两个概率分布之间相似性的另一种度量，取值在 [0, 1] 之间。JS 散度是对称的并且更加平滑。
GAN 的优化函数：
判别器 D 的最优值为固定 G 时， 的导数为 0 的时候：
当生成器 G 训练到最优时，即 ，
全局最优：当 G 和 D 都处于最优值时，我们有 和
此时 与 JS 散度有如下的关系：
所以，GAN的损失函数本质上是在判别器最优时通过 JS 散度量化生成数据分布与真实样本分布之间的相似性。当最优的 代替上式时，
代码实现
import argparse
import os
import numpy as np
import math
import torchvision.transforms as transforms
from torchvision.utils import save_image
from torch.utils.data import DataLoader
from torchvision import datasets
from torch.autograd import Variable
import torch.nn as nn
import torch.nn.functional as F
import torch
os.makedirs("images", exist_ok=True)
parser = argparse.ArgumentParser()
parser.add_argument("--n_epochs", type=int, default=200, help="number of epochs of training")
parser.add_argument("--batch_size", type=int, default=64, help="size of the batches")
parser.add_argument("--lr", type=float, default=0.0002, help="adam: learning rate")
parser.add_argument("--b1", type=float, default=0.5, help="adam: decay of first order momentum of gradient")
parser.add_argument("--b2", type=float, default=0.999, help="adam: decay of first order momentum of gradient")
parser.add_argument("--n_cpu", type=int, default=8, help="number of cpu threads to use during batch generation")
parser.add_argument("--latent_dim", type=int, default=100, help="dimensionality of the latent space")
parser.add_argument("--img_size", type=int, default=28, help="size of each image dimension")
parser.add_argument("--channels", type=int, default=1, help="number of image channels")
parser.add_argument("--sample_interval", type=int, default=400, help="interval betwen image samples")
opt = parser.parse_args()
print(opt)
img_shape = (opt.channels, opt.img_size, opt.img_size)
cuda = True if torch.cuda.is_available() else False
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(opt.latent_dim, 128, normalize=False),
*block(128, 256),
*block(256, 512),
*block(512, 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), *img_shape)
return img
class Discriminator(nn.Module):
def __init__(self):
super(Discriminator, self).__init__()
self.model = nn.Sequential(
nn.Linear(int(np.prod(img_shape)), 512),
nn.LeakyReLU(0.2, inplace=True), # 判别器使用 LeakyReLU 效果更好
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
# 损失函数
adversarial_loss = torch.nn.BCELoss()
generator = Generator()
discriminator = Discriminator()
if cuda:
generator.cuda()
discriminator.cuda()
adversarial_loss.cuda()
# 数据集
os.makedirs("../../data/mnist", exist_ok=True)
dataloader = torch.utils.data.DataLoader(
datasets.MNIST(
"../../data/mnist",
train=True,
download=True,
transform=transforms.Compose(
[transforms.Resize(opt.img_size), transforms.ToTensor(),
transforms.Normalize([0.5], [0.5])]
),
),
batch_size=opt.batch_size,
shuffle=True,
)
optimizer_G = torch.optim.Adam(generator.parameters(), lr=opt.lr, betas=(opt.b1, opt.b2))
optimizer_D = torch.optim.Adam(discriminator.parameters(), lr=opt.lr, betas=(opt.b1, opt.b2))
Tensor = torch.cuda.FloatTensor if cuda else torch.FloatTensor
for epoch in range(opt.n_epochs):
for i, (imgs, _) in enumerate(dataloader):
# 准备标签
valid = Variable(Tensor(imgs.size(0), 1).fill_(1.0), requires_grad=False)
fake = Variable(Tensor(imgs.size(0), 1).fill_(0.0), requires_grad=False)
real_imgs = Variable(imgs.type(Tensor))
optimizer_G.zero_grad()
# 使用了从正态分布采样的噪声
z = Variable(Tensor(np.random.normal(0, 1, (imgs.shape[0], opt.latent_dim))))
# 生成批量图片
gen_imgs = generator(z)
# G 的目标是让判别器认为生成的图片是真的
g_loss = adversarial_loss(discriminator(gen_imgs), valid)
g_loss.backward()
optimizer_G.step()
optimizer_D.zero_grad()
# D 的目标是区分出真实图片和生成图片
real_loss = adversarial_loss(discriminator(real_imgs), valid)
fake_loss = adversarial_loss(discriminator(gen_imgs.detach()), fake)
d_loss = (real_loss + fake_loss) / 2
d_loss.backward()
optimizer_D.step()
print(
"[Epoch %d/%d] [Batch %d/%d] [D loss: %f] [G loss: %f]"
% (epoch, opt.n_epochs, i, len(dataloader), d_loss.item(), g_loss.item())
)
batches_done = epoch * len(dataloader) + i
if batches_done % opt.sample_interval == 0:
save_image(gen_imgs.data[:25], "images/%d.png" % batches_done, nrow=5, normalize=True)
参考和引用链接：
作者介绍