1 分类问题
之前我们 认知了神经网络、初步体验了模型训练、模型推理，但我们的研究问题貌似主要局限在「分类问题」上。即给定一个输入，机器通过神经网络模型将它分到一个特定的类别。无论是 数字识别的0~9十个数组的十分类；还是 OCR识别字符的6000分类。
然而，分类网络是无法解决很多实际问题的：它无法帮助我们将一批数据点进行拟合（回归问题）；无法将一批数据自主进行归为若干类（聚类问题）；无法识别摄像头中的行人（目标检测问题）；无法“阅读”一篇文章然后回答问题（NLP自然语言处理问题），也无法「创造」（生成问题）……
2 生成问题
创造，从其效果上，大家已经有了很普及的认知，生成人脸、生成宣传卡片。生成任务，最直观的理解即为通过学习一批数据对象（比如100万张人脸图片，又或50万张小猫的图片）的特征，来实现对应类型数据对象（人脸、小猫）的生成（凭空创造）。用一句古话来形容生成问题就是：“熟读唐诗三百首,不会作诗也会吟。” 读得多了，自然也会了模仿和创造。
2.1 GAN-对抗生成网络
用AI解决生成问题的神经网络称之为GAN，即：Generative Adversarial Networks，即：对抗生成网络。小伙伴们或许会好奇，生成就生成，跟对抗有个毛毛关系呢？原来，生成任务的训练过程中是有两个网络同时参与协调训练的，即「鉴别网路」和「生成网络」，这两个网络在训练过程中互相「对抗」。
2.2 鉴别网络
「鉴别网络」是一个“测假仪”👇
如图，鉴别网络被期望可以分别一张图片是否是有生成网络生成出来的。(1代表真，代表鉴别网络认为输入的图片是“真”图，不是生成网络“生成的”；0代表假，表示鉴别网络成功鉴别了生成网络生成的“假图”）
2.3 生成网络
「生成网络」是一个“造假者”👇
如图，生成网络期望生成尽量接近真实的图片，达到「欺骗」鉴别网络的目的。
2.4 对抗生成要能「持续」对抗
对抗，要保持对抗的持续性，即「生成网络」创造的“赝品”当持续不能完全欺骗鉴别网络（全部被鉴别为1），也不能完全被鉴别网络鉴别（全部被鉴别为0）。
2.4.1 鉴别网络过于强大，无法继续对抗
如果……鉴别网络可以100%地 将生成数据鉴别为假。
那么，针对鉴别网络，它发现生成网络黔驴技穷，他的欺骗策略都是“100年前”的小儿科策略，它学不到新的鉴别策略。
而针对生成网络，它发现鉴别网络是 像神一般的存在，任何的欺骗行为都轻松地被识破，它根本不知道可以在哪一种欺骗方向上再进行挖掘和增强。就好像欺骗的种子还没发芽，就被鉴别网络连根拔起。
2.4.2 欺骗网络过于强大，无法继续对抗
这时，欺骗网络变成了神一般的存在，我们拿出一张真图和一张假图，告诉鉴别网络这是真图、这是假图。但对鉴别网络而言，却像是在玩一局超出能力范围的找不同游戏……
真&假的差异在哪里？……，TA无法有效提取「真」与「假」的有效特征来强化自己的鉴别能力。
3. 感知：对抗的成果
之前的篇章，我们已经了解到，网络的训练过程是一个循环学习的过程，将训练集的所有数据学习一遍，我们称之为「训练一轮」。那么让我们直观地看看在对抗训练了不同轮次之后，生成网络的进步吧！👇
4 实践：亲自跑代码
对抗生成网络的训练是一项很困难的任务，笔者资讯了组内对该任务有过前沿研究的老曹。老曹的建议是，对抗生成任务的上手与体验一定要在一个Demo的基础上。任何一个细节训练参数（batch_size、learning_rate、loss_function等）的变化都很有可能造成生成任务的训练失败（不收敛）。看看，网友们为了能训练好GAN，专门搞了个git页面来分享训练技巧：How to Train a GAN? Tips and tricks to make GANs work。
以下是一份笔者亲自尝试可用的基于MNIST的对抗生成训练demo，原版是GPU版本的，笔者调整成了CPU版本。在mac book的CPU上跑了近20个小时，终于完成了 1000轮 的训练任务……这也就是玩神经网络应用一定要用 GPU 的原因，如此简单的任务都需要 20小时，而GPU相对CPU的提速一般在10~100倍。
# coding=utf-8
import torch.autograd
import torch.nn as nn
from torch.autograd import Variable
from torchvision import transforms
from torchvision import datasets
from torchvision.utils import save_image
import os
milestonGenPath = './img3';
# 创建文件夹
if not os.path.exists(milestonGenPath):
os.mkdir(milestonGenPath)
def to_img(x):
out = 0.5 * (x + 1)
out = out.clamp(0, 1) # Clamp函数可以将随机变化的数值限制在一个给定的区间[min, max]内：
out = out.view(-1, 1, 28, 28) # view()函数作用是将一个多行的Tensor,拼接成一行
return out
batch_size = 128
num_epoch = 1000
z_dimension = 50
# 图像预处理
img_transform = transforms.Compose([
transforms.ToTensor(),
transforms.Normalize((0.1,), (0.5,))
])
# mnist dataset mnist数据集下载，没有下载的将download改成True
mnist = datasets.MNIST(
root='./mnist/', train=True, transform=img_transform, download=True
)
# data loader 数据载入
dataloader = torch.utils.data.DataLoader(
dataset=mnist, batch_size=batch_size, shuffle=True
)
# 定义判别器 #####Discriminator######使用多层网络来作为判别器
# 将图片28x28展开成784，然后通过多层感知器，中间经过斜率设置为0.2的LeakyReLU激活函数，
# 最后接sigmoid激活函数得到一个0到1之间的概率进行二分类。
class discriminator(nn.Module):
def __init__(self):
super(discriminator, self).__init__()
self.dis = nn.Sequential(
nn.Linear(784, 512), # 输入特征数为784，输出为512
nn.BatchNorm1d(512),
nn.LeakyReLU(0.2), # 进行非线性映射
nn.Linear(512, 256), # 进行一个线性映射
nn.BatchNorm1d(256),
nn.LeakyReLU(0.2),
nn.Linear(256, 1),
nn.Sigmoid() # 也是一个激活函数，二分类问题中，
# sigmoid可以班实数映射到【0,1】，作为概率值，
# 多分类用softmax函数
)
def forward(self, x):
x = self.dis(x)
return x
####### 定义生成器 Generator #####
# 输入一个50维的0～1之间的高斯分布，然后通过第一层线性变换将其映射到256维,
# 然后通过LeakyReLU激活函数，接着进行一个线性变换，再经过一个LeakyReLU激活函数，
# 然后经过线性变换将其变成784维，最后经过Tanh激活函数是希望生成的假的图片数据分布
# 能够在-1～1之间。
class generator(nn.Module):
def __init__(self):
super(generator, self).__init__()
self.gen = nn.Sequential(
nn.Linear(50, 128),
nn.LeakyReLU(0.2),
nn.Linear(128, 256),
nn.BatchNorm1d(256),
nn.LeakyReLU(0.2),
nn.Linear(256, 512),
nn.BatchNorm1d(512),
nn.LeakyReLU(0.2),
nn.Linear(512, 1024),
nn.BatchNorm1d(1024),
nn.LeakyReLU(0.2),
nn.Linear(1024, 784),
nn.Tanh()
)
def forward(self, x):
x = self.gen(x)
return x
# 创建对象
D = discriminator()
G = generator()
#########判别器训练train#####################
# 分为两部分：1、真的图像判别为真；2、假的图像判别为假
# 此过程中，生成器参数不断更新
# 首先需要定义loss的度量方式 （二分类的交叉熵）
# 其次定义 优化函数,优化函数的学习率为0.0003
criterion = nn.BCELoss() # 是单目标二分类交叉熵函数
d_optimizer = torch.optim.Adam(D.parameters(), lr=0.0003)
g_optimizer = torch.optim.Adam(G.parameters(), lr=0.0003)
###########################进入训练##判别器的判断过程#####################
for epoch in range(num_epoch): # 进行多个epoch的训练
for i, (img, _) in enumerate(dataloader):
num_img = img.size(0)
# view()函数作用是将一个多行的Tensor,拼接成一行
# 第一个参数是要拼接的tensor,第二个参数是-1
# =============================训练判别器==================
img = img.view(num_img, -1) # 将图片展开为28*28=784
real_img = Variable(img) # 将tensor变成Variable放入计算图中
real_label = Variable(torch.ones(num_img)) # 定义真实的图片label为1
fake_label = Variable(torch.zeros(num_img)) # 定义假的图片的label为0
# 计算真实图片的损失
real_out = D(real_img) # 将真实图片放入判别器中
d_loss_real = criterion(real_out, real_label) # 得到真实图片的loss
real_scores = real_out # 得到真实图片的判别值，输出的值越接近1越好
# 计算假的图片的损失
z = Variable(torch.randn(num_img, z_dimension)) # 随机生成一些噪声
fake_img = G(z) # 随机噪声放入生成网络中，生成一张假的图片
fake_out = D(fake_img) # 判别器判断假的图片
d_loss_fake = criterion(fake_out, fake_label) # 得到假的图片的loss
fake_scores = fake_out # 得到假图片的判别值，对于判别器来说，假图片的损失越接近0越好
# 损失函数和优化
d_loss = d_loss_real + d_loss_fake # 损失包括判真损失和判假损失
d_optimizer.zero_grad() # 在反向传播之前，先将梯度归0
d_loss.backward() # 将误差反向传播
d_optimizer.step() # 更新参数
# ==================训练生成器============================
################################生成网络的训练###############################
# 原理：目的是希望生成的假的图片被判别器判断为真的图片，
# 在此过程中，将判别器固定，将假的图片传入判别器的结果与真实的label对应，
# 反向传播更新的参数是生成网络里面的参数，
# 这样可以通过更新生成网络里面的参数，来训练网络，使得生成的图片让判别器以为是真的
# 这样就达到了对抗的目的
# 计算假的图片的损失
z = Variable(torch.randn(num_img, z_dimension)) # 得到随机噪声
fake_img = G(z) # 随机噪声输入到生成器中，得到一副假的图片
#
output = D(fake_img) # 经过判别器得到的结果
g_loss = criterion(output, real_label) # 得到的假的图片与真实的图片的label的loss
# bp and optimize
g_optimizer.zero_grad() # 梯度归0
g_loss.backward() # 进行反向传播
g_optimizer.step() # .step()一般用在反向传播后面,用于更新生成网络的参数
# 打印中间的损失
if (i + 1) % 100 == 0:
print('Epoch[{}/{}],d_loss:{:.6f},g_loss:{:.6f} '
'D real: {:.6f},D fake: {:.6f}'.format(
epoch, num_epoch, d_loss.data.item(), g_loss.data.item(),
real_scores.data.mean(), fake_scores.data.mean() # 打印的是真实图片的损失均值
))
if epoch == 0 and i==len(dataloader)-1:
real_images = to_img(real_img.data)
save_image(real_images, './img3/real_images.png')
if i==len(dataloader)-1:
fake_images = to_img(fake_img.data)
save_image(fake_images, './img3/fake_images-{}.png'.format(epoch + 1))
# 保存模型
torch.save(G.state_dict(), './generator.pth')
torch.save(D.state_dict(), './discriminator.pth')
自己试试看吧~
往期回顾
将AI拉下神坛（一）：黑白纸片摆出的神经网络
将AI拉下神坛（二）：重复的学习居然真的有效！来来，先将课文抄写100遍！
将AI拉下神坛（三）：从OCR的应用过程到模型推理抽象
