深度学习（PyTorch）——生成对抗网络（GAN)

一、GAN的基本概念

GAN是由Ian Goodfellow于2014年首次提出，学习GAN的初衷，即生成不存在于真实世界的数据。类似于AI具有创造力和想象力。

GAN有两大护法G和D:

G是generator，生成器: 负责凭空捏造数据出来

D是discriminator，判别器: 负责判断数据是不是真数据

这样可以简单看作是两个网络的博弈过程。在原始的GAN论文里面，G和D都是两个多层感知机网络。GAN操作的数据不一定非是图像数据，在此用图像数据为例解释以下GAN：

上图中，z是随机噪声（随机生成的一些数，也是GAN生成图像的源头）。D通过真图和假图的数据，进行一个二分类神经网络训练。G根据一串随机数就可以捏造出一个"假图像"出来，用这些假图去欺骗D，D负责辨别这是真图还是假图，会给出一个score。比如，G生成了一张图，在D这里评分很高，说明G生成能力是很成功的；若D给出的评分不高，可以有效区分真假图，则G的效果还不太好，需要调整参数。

二、GAN的基本原理

GAN的训练在同一轮梯度反转的过程中可以细分为2步：(1)先训练D；(2)再训练G。注意，不是等所有的D训练好了才开始训练G，因为D的训练也需要上一轮梯度反转中的G的输出值作为输入。

当训练D的时候：上一轮G产生的图片和真实图片，直接拼接在一起作为x。然后按顺序摆放成0和1，假图对应0，真图对应1。然后就可以通过D，x输入生成一个score（从0到1之间的数），通过score和y组成的损失函数，就可以进行梯度反传了。（我在图片上举的例子是batch = 1，len(y)=2*batch，训练时通常可以取较大的batch）

当训练G的时候：需要把G和D当作一个整体，这里取名叫做’D_on_G’。这个整体(简称DG系统)的输出仍然是score。输入一组随机向量z，就可以在G生成一张图，通过D对生成的这张图进行打分得到score，这就是DG系统的前向过程。score=1就是DG系统需要优化的目标，score和y=1之间的差异可以组成损失函数，然后可以采用反向传播梯度。注意，这里的D的参数是不可训练的。这样就能保证G的训练是符合D的打分标准的。这就好比：如果你参加考试，你别指望能改变老师的评分标准。

GAN模型的目标函数如下：

在这里，训练网络D使得最大概率地分对训练样本的标签（最大化log D(x)和log(1—D(G(z))))，训练网络G最小化log(1-D(G(z))），即最大化D的损失。而训练过程中固定一方，更新另一个网络的参数，交替迭代，使得对方的错误最大化，最终，G 能估测出样本数据的分布，也就是生成的样本更加的真实。

三、案例、用GAN对输入的随机数生成手写字体的图片

程序如下：

import torch
import torch.nn as nn
import torch.optim as optim
import torch.nn.functional as F
import numpy as np
import matplotlib.pyplot as plt
import torchvision
from torchvision import transforms
import os
import pandas
os.environ["KMP_DUPLICATE_LIB_OK"]="TRUE"
#对数据做归一化（-1 --- 1）
tranform = transforms.Compose([
    transforms.ToTensor(),             # 0-1归一化：channel,high,width
    transforms.Normalize(0.5,0.5),     #均值，方差均为0.5
])
 
train_ds = torchvision.datasets.MNIST("data",train = True,transform = tranform,download=True)
 
dataloader = torch.utils.data.DataLoader(train_ds,batch_size = 64,shuffle = True)
 
imgs, _ =next(iter(dataloader))
print(imgs.shape)  #torch.Size([64, 1, 28, 28])
 
# batch_size=64 图片大小：1,28,28
# 定义生成器
# 输入是长度为100的噪声（正态分布随机数）
# 输出为（1,28,28）的图片
 
# linear1:100---256
# linear2:256---512
# linear1:512---28*28
# linear2:28*28---(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()
        )
 
    def forward(self,x):  # x表示长度为100的噪声输入
        img = self.main(x)
        img = img.view(-1,28,28)
        return img
 
# 定义判别器
# 输入为（1,28,28）的图片，输出为二分类的概率值，输出使用sigmoid激活
# BCELose计算交叉熵损失
# nn.LeakyReLU  f(x):x>0,输出x，如果x<0,输出a*x，a表示一个很小的斜率，比如0.1
#判别器中一般推荐使用nn.LeakyReLU
class Discriminator(nn.Module):
    def __init__(self):
        super(Discriminator, self).__init__()
        self.main = nn.Sequential(
            nn.Linear(28*28,512),
            nn.LeakyReLU(),
            nn.Linear(512,256),
            nn.LeakyReLU(),
            nn.Linear(256, 1),
            nn.Sigmoid()
        )
 
    def forward(self,x):
        x = x.view(-1,28*28)
        x = self.main(x)
        return x
 
# device = 'cuda' if torch.cuda.is_available() else 'cpu'
device = 'cuda' if 0 else 'cpu'
gen = Generator().to(device)
dis = Discriminator().to(device)
d_optim = torch.optim.Adam(dis.parameters(),lr=0.0001)
g_optim = torch.optim.Adam(gen.parameters(),lr=0.0001)
 
loss_fn = torch.nn.BCELoss()
 
def gen_img_plot(model,test_input):
    prediction = np.squeeze(model(test_input).detach().cpu().numpy())
# detach()截断梯度,np.squeeze可以去掉维度为1
    fig = plt.figure(figsize=(4,4))
    for i in range(16):  # prediction.size(0)=16
        plt.subplot(4,4,i+1)
        plt.imshow((prediction[i]+1)/2)  # tanh 得到的是-1 - 1之间，-》0-1之间
        plt.axis("off")
    plt.show()
 
test_input = torch.randn(16,100,device=device)  # 16个长度为100的正态随机数
 
# print(test_input)
 
D_loss = []
G_loss = []
 
# 训练循环
for epoch in range(20):
    d_epoch_loss = 0
    g_epoch_loss = 0
    count = len(dataloader)  # len(dataloader)返回批次数
                             # len(dataset)返回样本数
    for step,(img,_) in enumerate(dataloader):
        img = img.to(device)
        size = img.size(0)
        random_noise = torch.randn(size,100,device=device)
 
        d_optim.zero_grad()
        real_output = dis(img)  # 对判别器输入真实图片 real_output对真实图片的预测结果
        #得到判别器在真实图像上面的损失
        d_real_loss = loss_fn(real_output,torch.ones_like(real_output))
 
        d_real_loss.backward()
 
        gen_img = gen(random_noise)
        #detach()截断生成器梯度，更新判别器梯度
        fake_output = dis(gen_img.detach())  # 判别器输入生成图片。fake_output对生成图片的预测
        # 得到判别器在生成图像上面的损失
        d_fake_loss = loss_fn(fake_output,torch.zeros_like(fake_output))
 
        d_fake_loss.backward()
 
        d_loss = d_fake_loss + d_real_loss
        d_optim.step()
 
        g_optim.zero_grad()
        fake_output = dis(gen_img)
        # 得到生成器的损失
        g_loss = loss_fn(fake_output,torch.ones_like(fake_output))
 
        g_loss.backward()
        g_optim.step()
 
        with torch.no_grad():
            d_epoch_loss +=d_loss
            g_epoch_loss +=g_loss
 
    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)