【生成对抗网络】GAN入门与代码实现(一)

文章目录

    • 1. 生成对抗网络介绍
    • 2. 基于TensorFlow2的GAN的简单实现
      • 2.1 导包与参数设置
      • 2.2 生成器
      • 2.3 判别器
      • 2.4 搭建生成对抗网络
      • 2.5 数据准备与预处理
      • 2.6 主训练方法
      • 2.7 绘图函数
      • 2.8 开始训练
      • 2.9 loss与acc绘图
      • 2.10 结果

生成对抗网络系列
【生成对抗网络】GAN入门与代码实现(一)
【生成对抗网络】GAN入门与代码实现(二)
【生成对抗网络】基于DCGAN的二次元人物头像生成(TensorFlow2)
【生成对抗网络】ACGAN的代码实现

1. 生成对抗网络介绍

生成对抗网络(Generative Adversarial Network)于2014年被Goodfellow等人提出,然后迅速流行。GAN能通过学习特定领域知识创造出新的图像、文本等。2016年,GAN热潮席卷人工智能领域顶级会议,从ICLR到NIPS,大量论文被发表和探讨。Yann LeCun曾评价GAN是“20年来机器学习领域最酷的想法”。

在GAN中主要由生成器G(generator)与判别器D(discriminator)构成。其中生成器用于生成逼真的假数据、判别器则需要在判别出真实数据与假数据,生成器与判别器相互博弈,在能力上有所提升,生成器生成的数据越来越像是真实的数据,判别器则能更好地将两者分辨出来,直到两者达到一种平衡。

假如以小狗图片作为生成的目标:

  • 生成器:接收一个随机噪声(随机变量)作为输入,输出一个小狗的图片(假图片)。
  • 判别器:将原真实的小狗图片和生成器生成的小狗图片两者区分出来,判断谁真谁假。

在模型训练的过程中:

​ 生成器:学习如何更好的将生成的小狗图片更加像真实,从而让判别器误认为是真实的。

​ 判别器:不断地将生成器生成的图片与真实的图片用于判别器模型的训练,提高自己的判别准确率。

GAN的整个训练过程如下:

  1. ​ 生成器接收随机噪声,并生成假图像;
  2. ​ 判别器接收假图像和真实图像组合的数据,学习如何判别真假图像;
  3. ​ 生成器生成新的图像,并使用判别器来判别真假,同时通过判别器来判别此次造假的水平;
  4. ​ 重复步骤 1-3。

2. 基于TensorFlow2的GAN的简单实现

我们以手写数据集MNIST为例进行演示。让GAN学习生成一些新的手写数字图片,每张图片的尺寸为28*28。
【生成对抗网络】GAN入门与代码实现(一)_第1张图片

代码实现步骤如下:

  1. 定义生成器,接收随机噪声,输出图像张量
  2. 定义判别器,接收图像张量,输出真假张量
  3. 定义生成对抗网络,接收随机噪声,输出真假张量。生成对抗网络由前面定义的生成器的模型层和判别器的模型创建( 它们共享权重),同时需要冻结判别器的权重。
  4. 将随机噪声输入生成器,生成一批图像
  5. 使用生成的图像与真实图像训练判别器(假图像的目标为0,真图像的目标为1)
  6. 使用新随机噪声输入生成对抗网络,输出真假(使生成的假图像判别为1),提高“造假”水平
  7. 重复4-6步骤

2.1 导包与参数设置

import numpy as np # 用于数据处理
import tensorflow as tf # 版本2.0及以上
from tensorflow import keras # 主要使用keras实现
import tqdm # 进度条,使用pip install tqdm安装
import matplotlib.pyplot as plt # 绘图函数库
%matplotlib inline
LATENT_DTM = 100 # 随机噪声的长度
IMAGE_SHAPE = (28,28,1) # 手写数字图片的尺寸与通道数

2.2 生成器

生成器接收随机向量,然后通过模型生成一张手写数字图片。

关键点:

  • 使用随机噪声作为输入,保证模型具有一定的随机性
  • 使用tanh作为最后一层的激活函数,可以获得更好的效果
  • 使用LeakyReLU激活函数来代替ReLU激活函数
generator_net = [
    keras.layers.Input(shape=(LATENT_DTM,)), # 输入为长度100点随机向量
    keras.layers.Dense(256),
    keras.layers.LeakyReLU(alpha = 0.2),
    keras.layers.BatchNormalization(momentum = 0.8),
    keras.layers.Dense(512),
    keras.layers.LeakyReLU(alpha = 0.2),
    keras.layers.BatchNormalization(momentum = 0.8),
    keras.layers.Dense(1024),
    keras.layers.LeakyReLU(alpha = 0.2),
    keras.layers.BatchNormalization(momentum = 0.8),
    keras.layers.Dense(np.prod(IMAGE_SHAPE),activation='tanh'),
    keras.layers.Reshape(IMAGE_SHAPE) #  将向量重塑shape为(28,28,1),输出图片
]
generator = keras.models.Sequential(generator_net)

2.3 判别器

判别器是一个二分类问题,接收一个图片,输出真假。

discriminator_net =[
    keras.layers.Input(shape=IMAGE_SHAPE),
    keras.layers.Flatten(),
    keras.layers.Dense(512),
    keras.layers.LeakyReLU(alpha = 0.2),
    keras.layers.Dense(256),
    keras.layers.LeakyReLU(alpha = 0.2),
    keras.layers.Dense(1,activation='sigmoid')
]
discriminator = keras.models.Sequential(discriminator_net)

优化器:

optimizer = keras.optimizers.Adam(0.0002,0.5)

模型编译:

discriminator.compile(loss=keras.losses.binary_crossentropy,optimizer=optimizer,metrics=['acc'])

2.4 搭建生成对抗网络

将生成器与判别器组合在一起,同时冻结判别器的权重。

该过程将生成器生成的图片直接送入判别器模型,从而直接输出结果。在该网络中,需要冻结判别器的权重,因为我们需要在此过程中训练生成器,让判别器的结果输出为“真”,从而不断完善生成器生成图像的水平,所以只需要训练生成器的层。

# 生成对抗网络使用生成器模型层和判别器模型层,它们共享权重。
adversarial_net = generator_net + discriminator_net

# 冻结判别器的层的权重
# trainable 属性只有编译后才生效,所以之前的判别器中同样的层还是可以训练的
for layer in discriminator_net:
    layer.trainable = False
adversarial = keras.models.Sequential(adversarial_net)

优化器:

optimizer = keras.optimizers.Adam(0.0002,0.5) # 优化器

模型编译:

adversarial.compile(loss=keras.losses.binary_crossentropy,optimizer=optimizer,metrics=['acc']) # 模型编译

2.5 数据准备与预处理

加载keras中内置的手写数据集

(image_set,_),_ = keras.datasets.mnist.load_data() # 加载数据集
image_set = image_set/127.5 - 1 # shape为(60000,28,28)
image_set = image_set.reshape((image_set.shape[0],28,28,1)) # shape为(60000,28,28,1)

准备训练过程中可视化的随机向量seed

num_example_to_generate = 6 # 用于绘图过程中生成图片的数量

seed = np.random.normal(0,1,(num_example_to_generate,LATENT_DTM)) # 生成6个长度为100的随机向量

用于记录训练过程中的准确率与损失

# 损失
g_loss_list = [] # 生成器
d_loss_list = [] # 判别器
# 准确率
g_acc_list = [] # 生成器
d_acc_list = [] # 判别器

2.6 主训练方法

def train(batch = 30000,batch_size = 300):
    # 准备batch_size大小的真假数据标签
    valid = np.ones((batch_size)) # 全是1
    fake = np.zeros((batch_size)) # 全是0
    
    # 使用进度条tqdm库
    batch_tqdm = tqdm.trange(batch)
    for index in batch_tqdm:
        
        # 随机选择batch_size数量的数据作为训练数据
        idx = np.random.randint(0,image_set.shape[0],batch_size)
        imgs = image_set[idx] 
        
        # 生成噪声数据并作为生成器的输入
        noise = np.random.normal(0,1,(batch_size,LATENT_DTM))
        
        # 使用生成器生成图像
        gen_imgs = generator.predict(noise)
        
        # 训练判别器
        # 使用真实图像和生成图像训练判别器,真实图像的标签全部为1,生成图像的标签全部为0
        d_state_real = discriminator.train_on_batch(imgs,valid) # 返回的是loss和acc
        d_state_fake = discriminator.train_on_batch(gen_imgs,fake)
        # 判别器在生成图像与真实图像两者的结果取平局值
        d_state = 0.5*(np.add(d_state_real,d_state_fake))
        
        # 训练判别器
        noise = np.random.normal(0,1,(batch_size,LATENT_DTM))
        # 训练生成对抗网络,目标是生成判别器人物真实的图像,因此标签为1
        # 因为生成对抗网络中的判别器的层都冻结了,所以实际上在训练生成器,不断生成更加逼真的图像
        adv_state = adversarial.train_on_batch(noise,valid)
        
        # 更新进度条后缀文本,用于输出训练进度
        state = f"[D loss:{d_state[0]:.4f} acc: {d_state[1]:.4f}]" \
                f"[G loss:{adv_state[0]:.4f} acc: {adv_state[1]:.4f}]"
        batch_tqdm.set_postfix(state=state)
        # 存储损失值和准确率
        g_loss_list.append(adv_state[0])
        g_acc_list.append(adv_state[1])
        d_loss_list.append(d_state[0])
        d_acc_list.append(d_state[1])
        
        if index%500 == 0: # 每500次绘图一次
            generate_plot_image(seed) # 绘图函数,每次都用同一个随机噪声seed生成图片,可以看到数字的变化

注意model的train_on_batch方法的使用。

2.7 绘图函数

用固定的noise绘制6张图片,以便观察训练效果。

# 画图函数
def generate_plot_image(test_noise):

    pre_image = generator(test_noise,training = False) # 用生成器,生成手写图片
    # print(pre_image.shape) # (6,28,28,1)
    fig = plt.figure(figsize=(16,3)) # figsize:指定figure的宽和高,单位为英寸
    for i in range(pre_image.shape[0]):   # pre_image的shape的第一个维度就是个数,这里是6
        plt.subplot(1,6,i+1) # 几行几列的 第i+1个图片(从1开始)
        plt.imshow((pre_image[i,:,:,:] + 1)/2) # 加1除2: 将生成的-1~1的图片弄到0-1之间,
        plt.axis('off') # 不要坐标
    plt.show()

2.8 开始训练

训练30000个batch,每个batch随机拿出300个图片用于训练。

batch = 30000
batch_size = 300
train(batch,batch_size)

2.9 loss与acc绘图

损失Loss:

plt.plot(range(1, batch+1), g_loss_list, label='g_loss')
plt.plot(range(1, batch+1), d_loss_list, label='d_loss')
plt.legend()

准确率Acc:

plt.plot(range(1, batch+1), g_acc_list, label='g_acc')
plt.plot(range(1, batch+1), d_acc_list, label='d_acc')
plt.legend()

2.10 结果

可以看到生成器生成图片的效果越来越好

【生成对抗网络】GAN入门与代码实现(一)_第2张图片
【生成对抗网络】GAN入门与代码实现(一)_第3张图片
【生成对抗网络】GAN入门与代码实现(一)_第4张图片
【生成对抗网络】GAN入门与代码实现(一)_第5张图片
【生成对抗网络】GAN入门与代码实现(一)_第6张图片

loss:

【生成对抗网络】GAN入门与代码实现(一)_第7张图片

acc:

【生成对抗网络】GAN入门与代码实现(一)_第8张图片

更新GAN的另一种实现方法:使用TensorFlow2中求导机制进行自定义训练的GAN代码实现,可对比进行学习。
博客链接:【生成对抗网络】GAN入门与代码实现(二)

参考文献:《TensorFlow2实战》艾力

你可能感兴趣的:(TensorFlow2,Python,机器学习与深度学习,python,tensorflow,生成对抗网络,深度学习)