GAN基础知识及代码

GAN也叫做生成对抗网络，分为两部分，一个是生成网络G，一个是对抗网络D。生成网络和对抗网络进行竞争，生成模型可以被认为是造假者，他们试图制造假币并在不被发现的情况下使用它，而鉴别模型类似于警察，视图发现假币。在这个游戏中，竞争促使两个团队改进他们的方法，直到冒充的产品和正品无法区分。

生成模型和判别模型都是多层感知器。

噪声就是随机生成的数，通过生成器随机生成一张图。（所以生成器只能随机生成图像，不能指定一些条件）

判别器的作用是尽可能的把真实数据集和生成数据集区分开，对于真实数据希望输出1，对于生成数据希望输出0。

相反，生成器希望判别器读入生成数据，输出1。

损失函数：

简化一点就是 D(x) +（ 1-D(G(z)) ) ， log是单调递增函数，此处的作用是放大损失。

对于生成器G，希望这个函数尽可能小，即D(x)接近0，1-D(G(z))接近0，即D(G(z))接近1.  事实上生成器不管D(x)是否是0，只要确保D(G(z))接近1，即生成的图像判别器判成了真实图像。

标准代码 - （pytorch）

在MNIST手写数字数据集上训练。

import torch.nn as nn
import torch.nn.functional as F
import torch.optim as optim
import numpy as np
import matplotlib.pyplot as plt
import torchvision
from torchvision import transforms

1. 数据准备

对真实数据做归一化（-1，1）,gan要求的,因为生成器生成的数据是（-1，1），保持两个数据分布一样

transform = transforms.Compose([
    transforms.ToTensor(),     # 归一化为0~1
    transforms.Normalize(0.5,0.5) # 归一化为-1~1
])
train_ds = torchvision.datasets.MNIST('datasets',  # 下载到那个目录下
                                      train=True,
                                      transform=transform,
                                      download=True)
dataloader = torch.utils.data.DataLoader(train_ds, batch_size=64,shuffle=True)
imgs,_ = next(iter(dataloader))
imgs.shape
# torch.Size([64, 1, 28, 28])

2. 定义生成器

输入是长度100的噪声z（正态分布随机数）
输出为（1，28，28）的图片，和MNIST数据集保持一致
Linear1: 100->256
Linear2: 256->512
Linear3: 512->2828
reshape: 2828->(1,28,28)

class Generator(nn.Module):
    def __init__(self):
        super(Generator, self).__init__() # 继承父类
        self.main = nn.Sequential(
            nn.Linear(100,256), nn.ReLU(),
            nn.Linear(256,512), nn.ReLU(),
            nn.Linear(512,28*28), 
            nn.Tanh()  # 最后必须用tanh，把数据分布到（-1，1）之间
        )
    def forward(self, x):  # x表示长度为100的噪声输入
        img = self.main(x)
        img = img.view(-1,28,28,1) # 方便等会绘图
        return img

3. 定义判别器

输入为（1，28，28）的mnist图片
输出为二分类的概率，使用sigmoid激活，范围为0~1
BCEloss计算交叉熵损失
判别器推荐使用LeakReLU激活

class Discriminator(nn.Module):
    def __init__(self):
        super(Discriminator,self).__init__()
        self.main = nn.Sequential(
            nn.Linear(28*28,512),
            nn.LeakyReLU(), # x小于零是是一个很小的值不是0，x大于0是还是x
            nn.Linear(512,256),
            nn.LeakyReLU(),
            nn.Linear(256,1),
            nn.Sigmoid() # 保证输出范围为（0，1）的概率
        )
    def forward(self, x): # x表示28*28的mnist图片
        img = x.view(-1,28*28)
        img = self.main(img)
        return img

4. 初始化模型、优化器、损失函数

device = 'cuda' if torch.cuda.is_available() else 'cpu'
print('training on ',device)
# 模型
gen = Generator().to(device)
dis = Discriminator().to(device)
# 优化器
g_opt = torch.optim.Adam(gen.parameters(),lr=0.0001)
d_opt = torch.optim.Adam(dis.parameters(),lr=0.0001)
# 损失
loss = torch.nn.BCELoss()

5. 绘图函数

随时看到生成器生成的图像

def gen_img_plot(model, test_input):
    prediction = np.squeeze(model(test_input).detach().cpu().numpy())
    fig = plt.figure(figsize=(4,4))
    for i in range(16):
        plt.subplot(4,4,i+1) # 四行四列的第一个
        # imshow函数绘图的输入是（0，1）的float，或者（1，256）的int
        # 但prediction是tanh出来的范围是[-1，1]没法绘图，需要转成0~1(即加1除2)。
        plt.imshow( (prediction[i]+1)/2 )
        plt.axis('off')
    plt.show()
test_input = torch.randn(16, 100, device=device)

6. GAN训练

D_loss = []
G_loss = []
epochs = 40
for epoch in range(epochs):
    d_epoch_loss = 0
    g_epoch_loss = 0
    count = len(dataloader) # 一个epoch的大小
    for step, (img, _) in enumerate(dataloader):
        img = img.to(device) # 一个批次的图片
        size = img.size(0)   # 和和图片对应的原始噪音
        random_noise = torch.randn(size, 100, device=device)
        gen_img = gen(random_noise) # 生成的图像
 
        d_opt.zero_grad()
        real_output = dis(img)  # 判别器输入真实图片，对真实图片的预测结果，希望是1
        # 判别器在真实图像上的损失
        d_real_loss = loss(real_output, torch.ones_like(real_output)) # size一样全一的tensor
        d_real_loss.backward()
 
        g_opt.zero_grad()
        # 记得切断生成器的梯度
        fake_output = dis(gen_img.detach()) # 判别器输入生成图片，对生成图片的预测结果，希望是0
        # 判别器在生成图像上的损失
        d_fake_loss = loss(fake_output, torch.zeros_like(fake_output)) # size一样全一的tensor
        d_fake_loss.backward()
        
        d_loss = d_real_loss + d_fake_loss
        d_opt.step()
        
        
        # 生成器的损失
        g_opt.zero_grad()
        fake_output = dis(gen_img) # 希望被判定为1
        g_loss = loss(fake_output, torch.ones_like(fake_output))
        g_loss.backward()
        g_opt.step()
        
        # 每个epoch内的loss累加，循环外再除epoch大小，得到平均loss
        with torch.no_grad():
            d_epoch_loss += d_loss
            g_epoch_loss += g_loss
    # 一个epoch训练完成
    with torch.no_grad():
        d_epoch_loss /= count
        g_epoch_loss /= count
        D_loss.append(d_epoch_loss)
        G_loss.append(g_epoch_loss)
        print('Epoch: ',epoch)
        gen_img_plot(gen, test_input)

结果：

 

 可以看到效果还算可以，这是2014年提出的最基础的GAN，后续要有若干改进的工作，效果更好，有机会再学。