乐趣区

关于人工智能:技术博客GAN入门实践

【技术博客】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 torch
import torch.nn as nn
import torch.nn.functional as F
import torch.optim as optim
from torchvision import datasets, transforms
from torch.autograd import Variable
from 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 Loader
train_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 = 10
loss_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. 参考资料

  1. Goodfellow, Ian, et al. “Generative Adversarial Networks”: https://arxiv.org/pdf/1406.2661.pdf
  2. Github 我的项目:https://github.com/lyeoni/pytorch-mnist-GAN
  3. 博客:https://shenxiaohai.me/2018/10/20/pytorch-tutorial-advanced-01/
  4. Pytorch 文档:https://pytorch.apachecn.org/
退出移动版