【技术博客】GAN入门实际
作者：梅昊铭
1. 原理介绍
GAN全称是 Generative Adversarial Network，即生成反抗网络。Generative 学习一个生成式模型；Adversarial 应用反抗的办法训练；Networks 应用神经网络。GAN 模型是一种通过反抗的形式去学习数据分布的生成式模型，其核心思想就是通过生成式网络G（Generator）和判断网络D（Discriminator）一直博弈，来达到生成真数据的目标。
Ge
GAN的思维启发自博弈论中的零和游戏，蕴含一个生成网络 G 和一个判断网络 D：
- G是一个生成式的网络，它接管一个随机的噪声 Z，通过 Generator 生成假数据
- D是一个判断网络，判断输出数据的真实性。它的输出是X，输入D(X)代表X为实在数据的概率
- 训练过程中，生成网络G的指标是尽量生成实在的数据去坑骗判断网络D。而D的指标就是尽量分别出G生成的假数据和真数据。这个博弈过程最终的平衡点是纳什均衡点
2. 入门实际
2.1 筹备工作
本教程利用Pytorch来搭建一个简略GAN网络来生成MINIST数据。试验中采纳的本地环境配置为 python == 3.7.7，torch.__version__==1.6.1。采纳的线上人工智能建模平台是 Mo。请在试验前配置好本地的Python环境，或者间接应用线上平台。
我的项目地址：https://momodel.cn/workspace/5f8914daed01547e8804ede7/app
2.2 GAN网络的Pytorch实现
2.2.1 预处理阶段
首先，咱们导入相应的Python包，并配置试验的设施环境。
# 导包import torchimport torch.nn as nnimport torch.nn.functional as Fimport torch.optim as optimfrom torchvision import datasets, transformsfrom torch.autograd import Variablefrom torchvision.utils import save_image# 设施配置device = torch.device('cuda' if torch.cuda.is_available() else 'cpu')2.2.2 MINIST数据集
加载MINIST数据集，同时做transform预处理。
bs = 128# 加（下）载 MNIST 数据集transform = transforms.Compose([ transforms.ToTensor(), transforms.Normalize(mean=(0.5,), std=(0.5,))])train_dataset = datasets.MNIST(root='./mnist_data/', train=True, transform=transform, download=True)test_dataset = datasets.MNIST(root='./mnist_data/', train=False, transform=transform, download=False)# Data Loadertrain_loader = torch.utils.data.DataLoader(dataset=train_dataset, batch_size=bs, shuffle=True)test_loader = torch.utils.data.DataLoader(dataset=test_dataset, batch_size=bs, shuffle=False)2.2.3 生成器
定义生成器G 类, 该生成器由四个全连贯层组成；此处亦可应用卷积层、池化层、BatchNormalize层等创立判断器，留神输入输出的向量维度即可。
class Generator(nn.Module): # 生成器由四个全连贯层组成 def __init__(self, g_input_dim, g_output_dim): super(Generator, self).__init__() self.fc1 = nn.Linear(g_input_dim, 256) self.fc2 = nn.Linear(self.fc1.out_features, self.fc1.out_features*2) self.fc3 = nn.Linear(self.fc2.out_features, self.fc2.out_features*2) self.fc4 = nn.Linear(self.fc3.out_features, g_output_dim) # 定义前向流传 def forward(self, x): x = F.leaky_relu(self.fc1(x), 0.2) x = F.leaky_relu(self.fc2(x), 0.2) x = F.leaky_relu(self.fc3(x), 0.2) return torch.tanh(self.fc4(x))2.2.4 判断器
定义判断器D 类，该判断器由四个全连贯组成；同理，此处也可采纳卷积池化层来创立判断器，读者可自行尝试。
class Discriminator(nn.Module): # 判断器由四个全连贯层组成 def __init__(self, d_input_dim): super(Discriminator, self).__init__() self.fc1 = nn.Linear(d_input_dim, 1024) self.fc2 = nn.Linear(self.fc1.out_features, self.fc1.out_features//2) self.fc3 = nn.Linear(self.fc2.out_features, self.fc2.out_features//2) self.fc4 = nn.Linear(self.fc3.out_features, 1) # 定义前向流传 def forward(self, x): x = F.leaky_relu(self.fc1(x), 0.2) x = F.dropout(x, 0.3) x = F.leaky_relu(self.fc2(x), 0.2) x = F.dropout(x, 0.3) x = F.leaky_relu(self.fc3(x), 0.2) x = F.dropout(x, 0.3) return torch.sigmoid(self.fc4(x))2.2.4 创立实例
利用上述定义好的生成器、判断器类，创立生成器和判断器实例。
# 噪声维度z_dim = 100# train_data.size(): (-1, 28, 28)mnist_dim = train_dataset.train_data.size(1) * train_dataset.train_data.size(2)G = Generator(g_input_dim = z_dim, g_output_dim = mnist_dim).to(device)D = Discriminator(mnist_dim).to(device)2.2.5 反抗生成训练
在训练模型之前，咱们须要先确定的损失函数和优化器，这里采纳穿插熵作为损失函数，应用Adam优化器。
# 定义穿插熵损失函数criterion = nn.BCELoss() # 定义优化器lr = 0.0002 G_optimizer = optim.Adam(G.parameters(), lr = lr)D_optimizer = optim.Adam(D.parameters(), lr = lr)定义判断器的训练过程。判断器的训练过程由两局部组成，一部分为实在数据产生的Loss， 一部分为反抗样本产生的数据。咱们心愿判断器D可能精确地区分出实在数据和反抗样本。所以咱们将实在数据的标签设置为1， 反抗样本的标签设置为0，别离计算两局部的Loss，求和作为判断器的Loss并优化。
def D_train(x): # ================================================================== # # 训练判断模型 # # ================================================================== # D.zero_grad() # 实在数据，标签为1 x_real, y_real = x.view(-1, mnist_dim), torch.ones(bs, 1) x_real, y_real = Variable(x_real.to(device)), Variable(y_real.to(device)) # 计算real_损失 # 应用公式 BCE_Loss(x, y): - y * log(D(x)) - (1-y) * log(1 - D(x))，来计算realimage的判断损失 # 其中第二项永远为零，因为real_labels == 1 D_output = D(x_real) D_real_loss = criterion(D_output, y_real) D_real_score = D_output # 在反抗样本，标签为0 z = Variable(torch.randn(bs, z_dim).to(device)) # 生成模型依据随机输出生成fake_images（反抗样本） x_fake, y_fake = G(z), Variable(torch.zeros(bs, 1).to(device)) # 应用公式 BCE_Loss(x, y): - y * log(D(x)) - (1-y) * log(1 - D(x))，来计算fakeImage的判断损失 # 其中第二项永远为零，因为fake_labels == 0 D_output = D(x_fake) D_fake_loss = criterion(D_output, y_fake) D_fake_score = D_output # 反向流传和优化 D_loss = D_real_loss + D_fake_loss D_loss.backward() D_optimizer.step() return D_loss.data.item()定义生成器的训练过程。首先由生成器G，产生一个反抗样本z。咱们心愿判断器D对该样本的是判断后果D(z) = 1,所以这里咱们将z的标签设置为1，计算生成器的Loss并优化。
def G_train(x): # ================================================================== # # 训练生成模型 # # ================================================================== # G.zero_grad() # 生成模型依据随机输出生成fake_images（标签为1）,而后判断模型进行判断 z = Variable(torch.randn(bs, z_dim).to(device)) y = Variable(torch.ones(bs, 1).to(device)) G_output = G(z) D_output = D(G_output) G_loss = criterion(D_output, y) # 反向流传和优化 G_loss.backward() G_optimizer.step() return G_loss.data.item()2.2.6 模型训练
具体的训练过程为，先训练一次判断器D，再训练一次生成器G，而后循环。
n_epoch = 10loss_file = open("loss.txt", 'w')for epoch in range(1, n_epoch+1): D_losses, G_losses = [], [] for batch_idx, (x, _) in enumerate(train_loader): # 抛弃不满整个batch_size的数据 if(len(x) != bs): continue D_losses.append(D_train(x)) G_losses.append(G_train(x)) loss_file.write('[{}/{}]: loss_d: {:.3f}, loss_g: {:.3f}\n'.format((epoch), n_epoch, torch.mean(torch.FloatTensor(D_losses)), torch.mean(torch.FloatTensor(G_losses))))loss_file.close()3. 参考资料
- Goodfellow, Ian, et al. "Generative Adversarial Networks": https://arxiv.org/pdf/1406.2661.pdf
- Github我的项目：https://github.com/lyeoni/pytorch-mnist-GAN
- 博客：https://shenxiaohai.me/2018/10/20/pytorch-tutorial-advanced-01/
- Pytorch文档：https://pytorch.apachecn.org/