教程 | 用AI生成猫的图片,撸猫人士必备

编译 | 小梁

【AI科技大本营导读】我们身边总是不乏各种各样的撸猫人士,面对朋友圈一波又一波晒猫的浪潮,作为学生狗和工作狗的我们只有羡慕的份,更流传有“吸猫穷三代,撸猫毁一生?”的名言,今天营长就为广大爱猫人士发放一份福利,看看如何用AI来生成猫的图片?

用DCGAN生成的猫图片示例

领军研究员 Yann Lecun 称生成式对抗网络( Generative Adverserial Networks, GAN )是“过去20年里机器学习中最棒的想法”。因为这种网络结构的出现,我们才能在今天搭建一个可以生成栩栩如生的猫图片的 AI 系统。这是不是很令人振奋?

DCGAN的训练过程

完整代码(Github):

https://gist.github.com/simoninithomas/c7d1e80810ef838330d7dab068d6b26f#file-training-py

如果你使用过 Python、Tensorflow,学习过深度学习、CNNs(卷积神经网络),将对理解代码大有裨益。

▌什么是 DCGAN?

深度卷积生成对抗网络(Deep Convolutional Generative Adverserial Networks,DCGAN)是一种深度学习架构,它会生成和训练集中数据相似的结果。

这一模型用卷积层代替了生成对抗网络(GAN)模型中的全连接层。

为了解释 DCGAN 是如何运行的,我们用艺术专家和冒牌专家来做比喻。

冒牌专家( 即“生成器” )企图模仿梵高的画作生成图片并把它当做真实的梵高作品。

而另一边,艺术专家( 即“分类器” )试图利用它们对梵高画作的了解来识别出赝品( 即生成图片 )。

随着时间推移,艺术专家鉴别赝品的技术不断长进,冒牌专家仿作的能力也不断提高。

如我们所见,DCGANs 由两个互相对抗的深度神经网络组成。

  • 生成器是一个仿造者,生成和真实数据相似的结果。它本身不知道真实数据是什么样,但会从另一个模型的反馈信息中学习和调整。
  • 分类器是一个检测者,通过与真实数据比较来确定伪造数据(即模型生成的图片),但尽力不对真实数据报错。这一部分会为生成器的反向传播服务。

DCGAN工作流程示例

  • 生成器会加入随机噪声向量,生成图片;
  • 这张图片被输入给分类器,和训练集进行比较;
  • 最后分类器返回一个 0(伪造图像)和 1(真实图像)之间的数字。

▌让我们来创建 DCGAN 吧!

现在,我们可以准备创建AI了。

在这部分,我们将关注模型的主要元素。若你想看所有代码,请点这里的 notebook(https://github.com/simoninithomas/CatDCGAN/blob/master/Cat%20DCGAN.ipynb)。

输入部分

先创建输入占位符:分类器:inputs_real,生成器:inputs_z。

注意,我们用两个学习率,一个是生成器的学习率,一个是分类器的学习率。

DCGANs 对超参数特别敏感,所以精确调参尤其重要。

def model_inputs(real_dim, z_dim):
    """    Create the model inputs
    :param real_dim: tuple containing width, height and channels
    :param z_dim: The dimension of Z
    :return: Tuple of (tensor of real input images, tensor of z data, learning rate G, learning rate D)
    """    # inputs_real for Discriminator
    inputs_real = tf.placeholder(tf.float32, (None, *real_dim), name='inputs_real')
  
    # inputs_z for Generator
    inputs_z = tf.placeholder(tf.float32, (None, z_dim), name="input_z")
    
    # Two different learning rate : one for the generator, one for the discriminator
    learning_rate_G = tf.placeholder(tf.float32, name="learning_rate_G")
    
    learning_rate_D = tf.placeholder(tf.float32, name="learning_rate_D")
    
    return inputs_real, inputs_z, learning_rate_G, learning_rate_D

分类器和生成器

我们用函数 tf.variable_scope 的原因有两个:

  • 第一,我们想要保证所有变量名称都以 generator 或 discriminator 开头,这将为我们之后训练两个网络提供帮助。
  • 第二,我们要用不同的输入重复训练网络:对于生成器,既要训练它,也要在训练后从生成图像中采样;对于分类器,我们需要在生成图像和真实图像间共用变量。

我们先来创建分类器。记住,要用真实或生成图像作为输入,然后输出分数。

需要注意的技术点:

  • 关键点是在每个卷积层加倍过滤器的尺寸;
  • 不建议进行下采样,我们只用一定步长的卷积层;
  • 每层都使用 batch 标准化(输入层除外),因为它会减小协方差转变。想了解更多信息的话请看这篇文章(https://medium.com/@ageitgey/machine-learning-is-fun-80ea3ec3c471)。
  • 我们用 Leaky ReLU 作为激活函数,因为它能帮助避免梯度消失问题。
def discriminator(x, is_reuse=False, alpha = 0.2):
    ''' Build the discriminator network.
        Arguments
        ---------
        x : Input tensor for the discriminator
        n_units: Number of units in hidden layer
        reuse : Reuse the variables with tf.variable_scope
        alpha : leak parameter for leaky ReLU
        Returns
        -------
        out, logits:
    '''
    with tf.variable_scope("discriminator", reuse = is_reuse):
        # Input layer 128*128*3 --> 64x64x64
        # Conv --> BatchNorm --> LeakyReLU   
        conv1 = tf.layers.conv2d(inputs = x,
                                filters = 64,
                                kernel_size = [5,5],
                                strides = [2,2],
                                padding = "SAME",
                                kernel_initializer=tf.truncated_normal_initializer(stddev=0.02),
                                name='conv1')
        batch_norm1 = tf.layers.batch_normalization(conv1,
                                                   training = True,
                                                   epsilon = 1e-5,
                                                     name = 'batch_norm1')
        conv1_out = tf.nn.leaky_relu(batch_norm1, alpha=alpha, name="conv1_out")
        # 64x64x64--> 32x32x128
        # Conv --> BatchNorm --> LeakyReLU   
        conv2 = tf.layers.conv2d(inputs = conv1_out,
                                filters = 128,
                                kernel_size = [5, 5],
                                strides = [2, 2],
                                padding = "SAME",
                                kernel_initializer=tf.truncated_normal_initializer(stddev=0.02),
                                name='conv2')
        batch_norm2 = tf.layers.batch_normalization(conv2,
                                                   training = True,
                                                   epsilon = 1e-5,
                                                     name = 'batch_norm2')
        conv2_out = tf.nn.leaky_relu(batch_norm2, alpha=alpha, name="conv2_out")
        # 32x32x128 --> 16x16x256
        # Conv --> BatchNorm --> LeakyReLU   
        conv3 = tf.layers.conv2d(inputs = conv2_out,
                                filters = 256,
                                kernel_size = [5, 5],
                                strides = [2, 2],
                                padding = "SAME",
                                kernel_initializer=tf.truncated_normal_initializer(stddev=0.02),
                                name='conv3')
        batch_norm3 = tf.layers.batch_normalization(conv3,
                                                   training = True,
                                                   epsilon = 1e-5,
                                                name = 'batch_norm3')
        conv3_out = tf.nn.leaky_relu(batch_norm3, alpha=alpha, name="conv3_out")
        # 16x16x256 --> 16x16x512
        # Conv --> BatchNorm --> LeakyReLU   
        conv4 = tf.layers.conv2d(inputs = conv3_out,
                                filters = 512,
                                kernel_size = [5, 5],
                                strides = [1, 1],
                                padding = "SAME",
                                kernel_initializer=tf.truncated_normal_initializer(stddev=0.02),
                                name='conv4')
        batch_norm4 = tf.layers.batch_normalization(conv4,
                                                   training = True,
                                                   epsilon = 1e-5,
                                                name = 'batch_norm4')
        conv4_out = tf.nn.leaky_relu(batch_norm4, alpha=alpha, name="conv4_out")
        # 16x16x512 --> 8x8x1024
        # Conv --> BatchNorm --> LeakyReLU   
        conv5 = tf.layers.conv2d(inputs = conv4_out,
                                filters = 1024,
                                kernel_size = [5, 5],
                                strides = [2, 2],
                                padding = "SAME",
                                kernel_initializer=tf.truncated_normal_initializer(stddev=0.02),
                                name='conv5')
        batch_norm5 = tf.layers.batch_normalization(conv5,
                                                   training = True,
                                                   epsilon = 1e-5,
                                                name = 'batch_norm5')
        conv5_out = tf.nn.leaky_relu(batch_norm5, alpha=alpha, name="conv5_out")
        # Flatten it
        flatten = tf.reshape(conv5_out, (-1, 8*8*1024))
        # Logits
        logits = tf.layers.dense(inputs = flatten,
                                units = 1,
                                activation = None)
        out = tf.sigmoid(logits)
        return out, logits

再来创建生成器。记住,用随机噪声向量(z)作为输入,根据转置的卷积层输出生成图像。

其主要思想是在每层将过滤器尺寸减半,而将图片尺寸加倍。研究已经发现,用 tanh 作为输出层的激活函数时,生成器的表现最好。

def generator(z, output_channel_dim, is_train=True):
    ''' Build the generator network.
        Arguments
        ---------
        z : Input tensor for the generator
        output_channel_dim : Shape of the generator output
        n_units : Number of units in hidden layer
        reuse : Reuse the variables with tf.variable_scope
        alpha : leak parameter for leaky ReLU
        Returns
        -------
        out:
    '''
    with tf.variable_scope("generator", reuse= not is_train):
        # First FC layer --> 8x8x1024
        fc1 = tf.layers.dense(z, 8*8*1024)
        # Reshape it
        fc1 = tf.reshape(fc1, (-1, 8, 8, 1024))
        # Leaky ReLU
        fc1 = tf.nn.leaky_relu(fc1, alpha=alpha)
        # Transposed conv 1 --> BatchNorm --> LeakyReLU
        # 8x8x1024 --> 16x16x512
        trans_conv1 = tf.layers.conv2d_transpose(inputs = fc1,
                                  filters = 512,
                                  kernel_size = [5,5],
                                  strides = [2,2],
                                  padding = "SAME",
                                kernel_initializer=tf.truncated_normal_initializer(stddev=0.02),
                                name="trans_conv1")
        # Transposed conv 1 --> BatchNorm --> LeakyReLU
        # 8x8x1024 --> 16x16x512
        trans_conv1 = tf.layers.conv2d_transpose(inputs = fc1,
                                  filters = 512,
                                  kernel_size = [5,5],
                                  strides = [2,2],
                                  padding = "SAME",
                                kernel_initializer=tf.truncated_normal_initializer(stddev=0.02),
                                name="trans_conv1")
        batch_trans_conv1 = tf.layers.batch_normalization(inputs = trans_conv1, training=is_train, epsilon=1e-5, name="batch_trans_conv1")
        trans_conv1_out = tf.nn.leaky_relu(batch_trans_conv1, alpha=alpha, name="trans_conv1_out")
        # Transposed conv 2 --> BatchNorm --> LeakyReLU
        # 16x16x512 --> 32x32x256
        trans_conv2 = tf.layers.conv2d_transpose(inputs = trans_conv1_out,
                                  filters = 256,
                                  kernel_size = [5,5],
                                  strides = [2,2],
                                  padding = "SAME",
                                kernel_initializer=tf.truncated_normal_initializer(stddev=0.02),
                                name="trans_conv2")
        batch_trans_conv2 = tf.layers.batch_normalization(inputs = trans_conv2, training=is_train, epsilon=1e-5, name="batch_trans_conv2")
        trans_conv2_out = tf.nn.leaky_relu(batch_trans_conv2, alpha=alpha, name="trans_conv2_out")
        # Transposed conv 3 --> BatchNorm --> LeakyReLU
        # 32x32x256 --> 64x64x128
        trans_conv3 = tf.layers.conv2d_transpose(inputs = trans_conv2_out,
                                  filters = 128,
                                  kernel_size = [5,5],
                                  strides = [2,2],
                                  padding = "SAME",
                                kernel_initializer=tf.truncated_normal_initializer(stddev=0.02),
                                name="trans_conv3")
        batch_trans_conv3 = tf.layers.batch_normalization(inputs = trans_conv3, training=is_train, epsilon=1e-5, name="batch_trans_conv3")
        trans_conv3_out = tf.nn.leaky_relu(batch_trans_conv3, alpha=alpha, name="trans_conv3_out")
        # Transposed conv 4 --> BatchNorm --> LeakyReLU
        # 64x64x128 --> 128x128x64
        trans_conv4 = tf.layers.conv2d_transpose(inputs = trans_conv3_out,
                                  filters = 64,
                                  kernel_size = [5,5],
                                  strides = [2,2],
                                  padding = "SAME",
                                kernel_initializer=tf.truncated_normal_initializer(stddev=0.02),
                                name="trans_conv4")
        batch_trans_conv4 = tf.layers.batch_normalization(inputs = trans_conv4, training=is_train, epsilon=1e-5, name="batch_trans_conv4")
        trans_conv4_out = tf.nn.leaky_relu(batch_trans_conv4, alpha=alpha, name="trans_conv4_out")
        # Transposed conv 5 --> tanh
        # 128x128x64 --> 128x128x3
        logits = tf.layers.conv2d_transpose(inputs = trans_conv4_out,
                                  filters = 3,
                                  kernel_size = [5,5],
                                  strides = [1,1],
                                  padding = "SAME",
                                kernel_initializer=tf.truncated_normal_initializer(stddev=0.02),
                                name="logits")
        out = tf.tanh(logits, name="out")
        return out

▌分类器和生成器的损失

因为我们是同时训练分类器和生成器,因此,两个网络的损失都需要计算。

我们的目标是使分类器认为图片为真实图片时输出“ 1 ”,认为图片是生成图片时输出“ 0 ”。因此,我们需要设计能够反映这一特点的损失函数。

分类器的损失是真实和生成图片的损失之和:

d_loss = d_loss_real + d_loss_fake  

d_loss_real 是分类器将真实图片错误地预测为生成图片时的损失。它的计算如下:

  • 用 d_logits_real ,所有标签均为1(因为所有数据都是真实的);
  • labels = tf.ones_like(tensor) * (1 - smooth) ,使用标签平滑:也就是略微减小标签,例如从 1.0 变为 0.9 ,从而使分类器泛化地更好。
  • d_loss_fake 是分类器预测一张图片为真实图片、但实际是生成图片时的损失。
  • 用 d_logits_fake ,所有标签都为0.

生成器的损失仍使用分类器中的 d_logits_fake ,但标签均为1,因为生成器要迷惑分类器。

def model_loss(input_real, input_z, output_channel_dim, alpha):
    """
    Get the loss for the discriminator and generator
    :param input_real: Images from the real dataset
    :param input_z: Z input
    :param out_channel_dim: The number of channels in the output image
    :return: A tuple of (discriminator loss, generator loss)
    """   
     # Generator network here    g_model = generator(input_z, output_channel_dim)   
    # g_model is the generator output    
    # Discriminator network here    d_model_real, d_logits_real = discriminator(input_real, alpha=alpha)    d_model_fake, d_logits_fake = discriminator(g_model,is_reuse=True, alpha=alpha)    
    # Calculate losses    d_loss_real = tf.reduce_mean(
                  tf.nn.sigmoid_cross_entropy_with_logits(logits=d_logits_real,                                                          labels=tf.ones_like(d_model_real)))    d_loss_fake = tf.reduce_mean(
                  tf.nn.sigmoid_cross_entropy_with_logits(logits=d_logits_fake,                                                          labels=tf.zeros_like(d_model_fake)))    d_loss = d_loss_real + d_loss_fake
    g_loss = tf.reduce_mean(
             tf.nn.sigmoid_cross_entropy_with_logits(logits=d_logits_fake,                                                     labels=tf.ones_like(d_model_fake)))    
    return d_loss, g_loss

▌优化器

计算损失后,我们需要分别更新生成器和分类器。

要更新生成器和分类器,我们需要在每部分用 tf.trainable_variables() 获取变量,这样便创建了一个包含已在图中定义好的所有变量的列表。

def model_optimizers(d_loss, g_loss, lr_D, lr_G, beta1):
    """
    Get optimization operations
    :param d_loss: Discriminator loss Tensor
    :param g_loss: Generator loss Tensor
    :param learning_rate: Learning Rate Placeholder
    :param beta1: The exponential decay rate for the 1st moment in the optimizer
    :return: A tuple of (discriminator training operation, generator training operation)
    """    
    # Get the trainable_variables, split into G and D parts    t_vars = tf.trainable_variables()
    g_vars = [var for var in t_vars if var.name.startswith("generator")]
    d_vars = [var for var in t_vars if var.name.startswith("discriminator")]
    update_ops = tf.get_collection(tf.GraphKeys.UPDATE_OPS)
    # Generator update    gen_updates = [op for op in update_ops if op.name.startswith('generator')]
    # Optimizers    with tf.control_dependencies(gen_updates):
        d_train_opt = tf.train.AdamOptimizer(learning_rate=lr_D, beta1=beta1).minimize(d_loss, var_list=d_vars)        g_train_opt = tf.train.AdamOptimizer(learning_rate=lr_G, beta1=beta1).minimize(g_loss, var_list=g_vars)        
        return d_train_opt, g_train_opt

▌训练

现在,我们来执行训练函数。

想法很简单:

  • 每迭代5次保存一次模型;
  • 每训练10个 batch 的图片就保存一张;
  • 每迭代15次将 g_loss , d_loss 和生成图片可视化一次。这样做的原因很简单:显示太多图片的话,Jupyter Notebook 可能会出错。
  • 或者,我们也可以直接通过加载保存的模型来查看图片(这样会节省20h的训练时间)。
def train(epoch_count, batch_size, z_dim, learning_rate_D, learning_rate_G, beta1, get_batches, data_shape, data_image_mode, alpha):
    """
    Train the GAN
    :param epoch_count: Number of epochs
    :param batch_size: Batch Size
    :param z_dim: Z dimension
    :param learning_rate: Learning Rate
    :param beta1: The exponential decay rate for the 1st moment in the optimizer
    :param get_batches: Function to get batches
    :param data_shape: Shape of the data
    :param data_image_mode: The image mode to use for images ("RGB" or "L")
    """
    # Create our input placeholders
    input_images, input_z, lr_G, lr_D = model_inputs(data_shape[1:], z_dim)
    # Losses
    d_loss, g_loss = model_loss(input_images, input_z, data_shape[3], alpha)
    # Optimizers
    d_opt, g_opt = model_optimizers(d_loss, g_loss, lr_D, lr_G, beta1)
    i = 0
    version = "firstTrain"
    with tf.Session() as sess:
        sess.run(tf.global_variables_initializer())
        # Saver
        saver = tf.train.Saver()
        num_epoch = 0
        if from_checkpoint == True:
            saver.restore(sess, "./models/model.ckpt")
            show_generator_output(sess, 4, input_z, data_shape[3], data_image_mode, image_path, True, False)
        else:
            for epoch_i in range(epoch_count):        
                num_epoch += 1
                if num_epoch % 5 == 0:
                    # Save model every 5 epochs
                    #if not os.path.exists("models/" + version):
                    #    os.makedirs("models/" + version)
                    save_path = saver.save(sess, "./models/model.ckpt")
                    print("Model saved")
                for batch_images in get_batches(batch_size):
                    # Random noise
                    batch_z = np.random.uniform(-1, 1, size=(batch_size, z_dim))
                    i += 1
                    # Run optimizers
                    _ = sess.run(d_opt, feed_dict={input_images: batch_images, input_z: batch_z, lr_D: learning_rate_D})
                    _ = sess.run(g_opt, feed_dict={input_images: batch_images, input_z: batch_z, lr_G: learning_rate_G})
                    if i % 10 == 0:
                        train_loss_d = d_loss.eval({input_z: batch_z, input_images: batch_images})
                        train_loss_g = g_loss.eval({input_z: batch_z})
                        # Save it
                        image_name = str(i) + ".jpg"
                        image_path = "./images/" + image_name
                        show_generator_output(sess, 4, input_z, data_shape[3], data_image_mode, image_path, True, False)
    return losses, samples

▌怎样运行模型

你不能在自己的笔记本上运行这个模型——除非你有自己的 GPU,或者准备好等个十来年。

因此,你最好用在线 GPU 服务,如 AWS 或者 FloydHub 。我个人训练这个 DCGAN 模型花了 20 个小时,用的是 Microsoft Azure 和他们的深度学习虚拟机。

Deep Learning Virtual Machine:

https://medium.com/@ageitgey/machine-learning-is-fun-80ea3ec3c471

作者 | Thomas Simonini 原文链接 https://medium.freecodecamp.org/how-ai-can-learn-to-generate-pictures-of-cats-ba692cb6eae4

原文发布于微信公众号 - AI科技大本营(rgznai100)

原文发表时间:2018-03-27

本文参与腾讯云自媒体分享计划,欢迎正在阅读的你也加入,一起分享。

发表于

我来说两句

0 条评论
登录 后参与评论

相关文章

来自专栏AI科技大本营的专栏

SVM大解密(附代码和公式)

写在之前 支持向量机(SVM),一个神秘而众知的名字,在其出来就受到了莫大的追捧,号称最优秀的分类算法之一,以其简单的理论构造了复杂的算法,又以其简单的用法实现...

1.1K9
来自专栏大数据挖掘DT机器学习

R语言与机器学习(分类算法)支持向量机

说到支持向量机,必须要提到july大神的《支持向量机通俗导论》,个人感觉再怎么写也不可能写得比他更好的了。这也正如青莲居士见到崔颢的黄鹤楼后也...

3264
来自专栏机器之心

教程 | 百行代码构建神经网络黑白图片自动上色系统

4036
来自专栏深度学习那些事儿

我的模型能跑多快——神经网络模型速度调研(一)

对于神经网络,我们更多谈的是其精度怎么样,有百分之零点几的提升。但是如果谈到速度的话,深度学习神经网络相比于传统的算法来说,速度恐怕没有那么快了。

3831
来自专栏游戏开发那些事

【Unity3d游戏开发】游戏中的贝塞尔曲线以及其在Unity中的实现

  RT,马三最近在参与一款足球游戏的开发,其中涉及到足球的各种运动轨迹和路径,比如射门的轨迹,高吊球,香蕉球的轨迹。最早的版本中马三是使用物理引擎加力的方式实...

4551
来自专栏PPV课数据科学社区

【V课堂】R语言十八讲(十五)—-置换检验和自助法

不知道看到这里,读者有么有发现,前面讲了那么多方法,几大检验,回归分析,方差分析“都有一个共同的特点,那就是有一定的前提假设,只有满足这个假设时,模型才有较好的...

3096
来自专栏新智元

吴恩达斯坦福CS230第一名:图像超级补全,效果惊艳(附代码)

【新智元导读】图像修复(Image inpainting)是一个已经被广泛研究的计算机视觉问题,即恢复图像中缺失的部分。斯坦福大学CS230课程的Mark Sa...

1293
来自专栏小樱的经验随笔

多元回归模型

回归模型 1 基本知识介绍 1.1回归模型的引入 由于客观事物内部规律的复杂性及人们认识程度的限制,无法分析实际对象内在的因果关系,建立合乎机理规律的数学模型。...

3227
来自专栏机器之心

深度 | 可视化LSTM网络:探索「记忆」的形成

选自Medium 作者:Piotr Tempczyk 机器之心编译 参与:陈韵竹、刘晓坤 在卷积神经网络领域中有许多可视化方面的研究,但是对于 LSTM 却没有...

4037
来自专栏CreateAMind

论文:生成模型采样-类比学习应用 代码

之前发的这篇文章(之前内容在文章底部)介绍了生成模型的高效采样及隐变量空间特征特点,最近的How to Train a GAN? Tips and tricks...

1002

扫码关注云+社区