听说GAN很高大上,其实就这么简单

本文使用的tensorflow版本:1.4 tensorflow安装:pip install tensorflow

1、先来目睹一下效果吧

这篇文章讲解了如何使用GAN来生成我们的手写数字,我们首先来看看生成的效果吧: 10轮:

50轮:

100轮:

200轮:

可以看到,在10轮的时候,我们的Generator生成的图片非常模糊,几乎是无法用肉眼来分别数字的,到了第50轮的时候,已经初见雏形了,有一些数字比如1、4、5这些都可以很清楚的分辨出来,不过还并不是十分完美。到了100轮的时候,像数字8和9这些也基本能准确的生成了,而到200轮的时候,除去个别的以外,基本上都能正确的手写出来了,由于时间的原因,没有继续训练下去,如果大家感兴趣,可以训练更多轮,看看更好的效果。

2、思路解析

设定参数 本文设定的参数是,图片的大小是28*28,这是mnist图片的标准大小,后面是一些保存模型的设定。我们总共的训练轮数是500轮。在我们的Generator和Discriminator中,我们设定的是一个简单的有两层隐藏层的全链接神经网络。对于Generator来说,输入的的大小是[batch_size,z_size],第一个隐藏层有150个神经元,第二个隐藏层有300个神经元,输出的大小就是图片的size28*28。而对于Discriminator来说,我们的输入的大小是[batch_size * 2,img_size],因为我们要掺杂真实的img和Generator生成的img。第一个隐藏层有300个神经元,第二个隐藏层有150个神经元,输出层只有1个数,表示该图片为真实图片的概率。关于神经网络的结构我们会在后面详细讲解。

img_height = 28img_width = 28img_size = img_height * img_width

to_train = Trueto_restore = Falseoutput_path = "output"# 总迭代次数500max_epoch = 500h1_size = 150h2_size = 300z_size = 100batch_size = 256

创建Generator 刚才也讲到了,对于Generator来说,输入的的大小是[batch_size,z_size],第一个隐藏层有150个神经元,第二个隐藏层有300个神经元,输出的大小就是图片的size28*28。总的来说,经过Generator,由[batch_size,z_size] 变为 [batch_size,img_size]

# generate (model 1)def build_generator(z_prior):
    w1 = tf.Variable(tf.truncated_normal([z_size, h1_size], stddev=0.1), name="g_w1", dtype=tf.float32)
    b1 = tf.Variable(tf.zeros([h1_size]), name="g_b1", dtype=tf.float32)
    h1 = tf.nn.relu(tf.matmul(z_prior, w1) + b1)
    w2 = tf.Variable(tf.truncated_normal([h1_size, h2_size], stddev=0.1), name="g_w2", dtype=tf.float32)
    b2 = tf.Variable(tf.zeros([h2_size]), name="g_b2", dtype=tf.float32)
    h2 = tf.nn.relu(tf.matmul(h1, w2) + b2)
    w3 = tf.Variable(tf.truncated_normal([h2_size, img_size], stddev=0.1), name="g_w3", dtype=tf.float32)
    b3 = tf.Variable(tf.zeros([img_size]), name="g_b3", dtype=tf.float32)
    h3 = tf.matmul(h2, w3) + b3
    x_generate = tf.nn.tanh(h3)
    g_params = [w1, b1, w2, b2, w3, b3]    return x_generate, g_params

创建Discrminator 而对于Discriminator来说,我们的输入的大小是[batch_size * 2,img_size],因为我们要掺杂真实的img和Generator生成的img。第一个隐藏层有300个神经元,第二个隐藏层有150个神经元,输出层只有1个数,表示该图片为真实图片的概率。要注意,我们的输入和输出是严格对应的,所以对于输出成的输出h3来说,前batch_size个代表着对真实图片的判别概率,而后batch_size代表着对Generator生成的图片的判别概率。这里是用了一个tf.slice()函数,之前没有接触过,故在这里做一下记录: 1,函数原型 tf.slice(inputs,begin,size,name='') 2,用途:从inputs中抽取部分内容 inputs:可以是list,array,tensor begin:n维列表,begin[i] 表示从inputs中第i维抽取数据时,相对0的起始偏移量,也就是从第i维的begin[i]开始抽取数据 size:n维列表,size[i]表示要抽取的第i维元素的数目 所以可以看到,最终y_data保存的是真实图片的判别概率,这些值要越接近于1越好,而y_generated保存的是Generator生成的图片的判别概率,这些值要越接近于0越好。

def build_discriminator(x_data, x_generated, keep_prob):
    # tf.concat
    x_in = tf.concat([x_data, x_generated], 0)
    w1 = tf.Variable(tf.truncated_normal([img_size, h2_size], stddev=0.1), name="d_w1", dtype=tf.float32)
    b1 = tf.Variable(tf.zeros([h2_size]), name="d_b1", dtype=tf.float32)
    h1 = tf.nn.dropout(tf.nn.relu(tf.matmul(x_in, w1) + b1), keep_prob)
    w2 = tf.Variable(tf.truncated_normal([h2_size, h1_size], stddev=0.1), name="d_w2", dtype=tf.float32)
    b2 = tf.Variable(tf.zeros([h1_size]), name="d_b2", dtype=tf.float32)
    h2 = tf.nn.dropout(tf.nn.relu(tf.matmul(h1, w2) + b2), keep_prob)
    w3 = tf.Variable(tf.truncated_normal([h1_size, 1], stddev=0.1), name="d_w3", dtype=tf.float32)
    b3 = tf.Variable(tf.zeros([1]), name="d_b3", dtype=tf.float32)
    h3 = tf.matmul(h2, w3) + b3
    y_data = tf.nn.sigmoid(tf.slice(h3, [0, 0], [batch_size, -1], name=None))
    y_generated = tf.nn.sigmoid(tf.slice(h3, [batch_size, 0], [-1, -1], name=None))
    d_params = [w1, b1, w2, b2, w3, b3]    return y_data, y_generated, d_params

保存图片 关于保存图片的代码,我们这里就不讲了,这也不是重点,大家有兴趣的话可以研究下:

def show_result(batch_res, fname, grid_size=(8, 8), grid_pad=5):
    batch_res = 0.5 * batch_res.reshape((batch_res.shape[0], img_height, img_width)) + 0.5
    img_h, img_w = batch_res.shape[1], batch_res.shape[2]
    grid_h = img_h * grid_size[0] + grid_pad * (grid_size[0] - 1)
    grid_w = img_w * grid_size[1] + grid_pad * (grid_size[1] - 1)
    img_grid = np.zeros((grid_h, grid_w), dtype=np.uint8)    for i, res in enumerate(batch_res):        if i >= grid_size[0] * grid_size[1]:            break
        img = (res) * 255
        img = img.astype(np.uint8)
        row = (i // grid_size[0]) * (img_h + grid_pad)
        col = (i % grid_size[1]) * (img_w + grid_pad)
        img_grid[row:row + img_h, col:col + img_w] = img
    imsave(fname, img_grid)

设定训练目标 对于Discriminator来说,他希望能够使二分类的结果越准确越好,即越能准确判别真实图片和Generator生成的图片越好,所以我们这里使用类似于逻辑回归中的损失函数,而对于Generator来说,它希望的是Discriminator无法分辨它生成的图片,所以它希望Discriminator能将它生成的图片越多的分类为真实图片,所以我们设定的训练目标如下:

  # 损失函数的设置
    d_loss = - (tf.log(y_data) + tf.log(1 - y_generated))
    g_loss = - tf.log(y_generated)

    optimizer = tf.train.AdamOptimizer(0.0001)

    # 两个模型的优化函数
    d_trainer = optimizer.minimize(d_loss, var_list=d_params)
    g_trainer = optimizer.minimize(g_loss, var_list=g_params)

训练 训练其实很简单,每次得到batch_size大小的样本,先训练一次Discriminator,然后再训练我们的Generator

z_sample_val = np.random.normal(0, 1, size=(batch_size, z_size)).astype(np.float32)

    steps = 60000 / batch_size    for i in range(sess.run(global_step), max_epoch):        for j in np.arange(steps):            #         for j in range(steps):
            print("epoch:%s, iter:%s" % (i, j))            # 每一步迭代,我们都会加载256个训练样本,然后执行一次train_step
            x_value, _ = mnist.train.next_batch(batch_size)
            x_value = 2 * x_value.astype(np.float32) - 1
            z_value = np.random.normal(0, 1, size=(batch_size, z_size)).astype(np.float32)            # 执行生成
            sess.run(d_trainer,
                     feed_dict={x_data: x_value, z_prior: z_value, keep_prob: np.sum(0.7).astype(np.float32)})            # 执行判别
            if j % 1 == 0:
                sess.run(g_trainer,
                         feed_dict={x_data: x_value, z_prior: z_value, keep_prob: np.sum(0.7).astype(np.float32)})        

3、完整代码

本文涉及到的完整代码如下:

import tensorflow as tffrom tensorflow.examples.tutorials.mnist import input_dataimport numpy as npfrom skimage.io import imsaveimport osimport shutil

img_height = 28img_width = 28img_size = img_height * img_width

to_train = Trueto_restore = Falseoutput_path = "output"# 总迭代次数500max_epoch = 500h1_size = 150h2_size = 300z_size = 100batch_size = 256# generate (model 1)def build_generator(z_prior):
    w1 = tf.Variable(tf.truncated_normal([z_size, h1_size], stddev=0.1), name="g_w1", dtype=tf.float32)
    b1 = tf.Variable(tf.zeros([h1_size]), name="g_b1", dtype=tf.float32)
    h1 = tf.nn.relu(tf.matmul(z_prior, w1) + b1)
    w2 = tf.Variable(tf.truncated_normal([h1_size, h2_size], stddev=0.1), name="g_w2", dtype=tf.float32)
    b2 = tf.Variable(tf.zeros([h2_size]), name="g_b2", dtype=tf.float32)
    h2 = tf.nn.relu(tf.matmul(h1, w2) + b2)
    w3 = tf.Variable(tf.truncated_normal([h2_size, img_size], stddev=0.1), name="g_w3", dtype=tf.float32)
    b3 = tf.Variable(tf.zeros([img_size]), name="g_b3", dtype=tf.float32)
    h3 = tf.matmul(h2, w3) + b3
    x_generate = tf.nn.tanh(h3)
    g_params = [w1, b1, w2, b2, w3, b3]    return x_generate, g_params# discriminator (model 2)def build_discriminator(x_data, x_generated, keep_prob):
    # tf.concat
    x_in = tf.concat([x_data, x_generated], 0)
    w1 = tf.Variable(tf.truncated_normal([img_size, h2_size], stddev=0.1), name="d_w1", dtype=tf.float32)
    b1 = tf.Variable(tf.zeros([h2_size]), name="d_b1", dtype=tf.float32)
    h1 = tf.nn.dropout(tf.nn.relu(tf.matmul(x_in, w1) + b1), keep_prob)
    w2 = tf.Variable(tf.truncated_normal([h2_size, h1_size], stddev=0.1), name="d_w2", dtype=tf.float32)
    b2 = tf.Variable(tf.zeros([h1_size]), name="d_b2", dtype=tf.float32)
    h2 = tf.nn.dropout(tf.nn.relu(tf.matmul(h1, w2) + b2), keep_prob)
    w3 = tf.Variable(tf.truncated_normal([h1_size, 1], stddev=0.1), name="d_w3", dtype=tf.float32)
    b3 = tf.Variable(tf.zeros([1]), name="d_b3", dtype=tf.float32)
    h3 = tf.matmul(h2, w3) + b3
    y_data = tf.nn.sigmoid(tf.slice(h3, [0, 0], [batch_size, -1], name=None))
    y_generated = tf.nn.sigmoid(tf.slice(h3, [batch_size, 0], [-1, -1], name=None))
    d_params = [w1, b1, w2, b2, w3, b3]    return y_data, y_generated, d_params#def show_result(batch_res, fname, grid_size=(8, 8), grid_pad=5):
    batch_res = 0.5 * batch_res.reshape((batch_res.shape[0], img_height, img_width)) + 0.5
    img_h, img_w = batch_res.shape[1], batch_res.shape[2]
    grid_h = img_h * grid_size[0] + grid_pad * (grid_size[0] - 1)
    grid_w = img_w * grid_size[1] + grid_pad * (grid_size[1] - 1)
    img_grid = np.zeros((grid_h, grid_w), dtype=np.uint8)    for i, res in enumerate(batch_res):        if i >= grid_size[0] * grid_size[1]:            break
        img = (res) * 255
        img = img.astype(np.uint8)
        row = (i // grid_size[0]) * (img_h + grid_pad)
        col = (i % grid_size[1]) * (img_w + grid_pad)
        img_grid[row:row + img_h, col:col + img_w] = img
    imsave(fname, img_grid)def train():
    # load data(mnist手写数据集)
    mnist = input_data.read_data_sets('MNIST_data', one_hot=True)

    x_data = tf.placeholder(tf.float32, [batch_size, img_size], name="x_data")
    z_prior = tf.placeholder(tf.float32, [batch_size, z_size], name="z_prior")
    keep_prob = tf.placeholder(tf.float32, name="keep_prob")
    global_step = tf.Variable(0, name="global_step", trainable=False)    # 创建生成模型
    x_generated, g_params = build_generator(z_prior)    # 创建判别模型
    y_data, y_generated, d_params = build_discriminator(x_data, x_generated, keep_prob)    # 损失函数的设置
    d_loss = - (tf.log(y_data) + tf.log(1 - y_generated))
    g_loss = - tf.log(y_generated)

    optimizer = tf.train.AdamOptimizer(0.0001)    # 两个模型的优化函数
    d_trainer = optimizer.minimize(d_loss, var_list=d_params)
    g_trainer = optimizer.minimize(g_loss, var_list=g_params)

    init = tf.global_variables_initializer()

    saver = tf.train.Saver()    # 启动默认图
    sess = tf.Session()    # 初始化
    sess.run(init)    if to_restore:
        chkpt_fname = tf.train.latest_checkpoint(output_path)
        saver.restore(sess, chkpt_fname)    else:        if os.path.exists(output_path):
            shutil.rmtree(output_path)
        os.mkdir(output_path)

    z_sample_val = np.random.normal(0, 1, size=(batch_size, z_size)).astype(np.float32)

    steps = 60000 / batch_size    for i in range(sess.run(global_step), max_epoch):        for j in np.arange(steps):            #         for j in range(steps):
            print("epoch:%s, iter:%s" % (i, j))            # 每一步迭代,我们都会加载256个训练样本,然后执行一次train_step
            x_value, _ = mnist.train.next_batch(batch_size)
            x_value = 2 * x_value.astype(np.float32) - 1
            z_value = np.random.normal(0, 1, size=(batch_size, z_size)).astype(np.float32)            # 执行生成
            sess.run(d_trainer,
                     feed_dict={x_data: x_value, z_prior: z_value, keep_prob: np.sum(0.7).astype(np.float32)})            # 执行判别
            if j % 1 == 0:
                sess.run(g_trainer,
                         feed_dict={x_data: x_value, z_prior: z_value, keep_prob: np.sum(0.7).astype(np.float32)})
        x_gen_val = sess.run(x_generated, feed_dict={z_prior: z_sample_val})
        show_result(x_gen_val, "output/sample{0}.jpg".format(i))
        z_random_sample_val = np.random.normal(0, 1, size=(batch_size, z_size)).astype(np.float32)
        x_gen_val = sess.run(x_generated, feed_dict={z_prior: z_random_sample_val})
        show_result(x_gen_val, "output/random_sample{0}.jpg".format(i))
        sess.run(tf.assign(global_step, i + 1))
        saver.save(sess, os.path.join(output_path, "model"), global_step=global_step)if __name__ == '__main__':
    train()

原文发布于微信公众号 - 小小挖掘机(wAIsjwj)

原文发表时间:2018-01-24

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

发表于

我来说两句

0 条评论
登录 后参与评论

相关文章

来自专栏量化投资与机器学习

深度学习Matlab工具箱代码注释之cnnbp.m

%%========================================================================= %...

2275
来自专栏人工智能

深入机器学习系列12-高斯混合模型

高斯混合模型   现有的高斯模型有单高斯模型()和高斯混合模型()两种。从几何上讲,单高斯分布模型在二维空间上近似于椭圆,在三维空间上近似于椭球。在很多情况下,...

2429
来自专栏郭耀华‘s Blog

1×1卷积的用途(Network in Network)

1×1卷积,又称为Network in Network ? 如果卷积的输出输入都只是一个平面,那么1x1卷积核并没有什么意义,它是完全不考虑像素与周边其他像...

1.2K7
来自专栏Petrichor的专栏

深度学习: 参数初始化

好的开始是成功的一半。 为了让你的模型跑赢在起跑线 ε=ε=ε=(~ ̄▽ ̄)~ ,请慎重对待参数初始化。

3453
来自专栏青青天空树

趣味问题:画图(c++实现)

描述:在一个定义了直角坐标系的纸上,画一个(x1,y1)到(x2,y2)的矩形指将横坐标范围从x1到x2,纵坐标范围从y1到y2之间的区域涂上颜色。下图给出了一...

1084
来自专栏机器学习、深度学习

人脸检测-- Face R-FCN + Face R-CNN

Detecting Faces Using Region-based Fully Convolutional Networks 本文使用 R-FCN 来进行人脸...

4796
来自专栏杨熹的专栏

详解 LSTM

今天的内容有: LSTM 思路 LSTM 的前向计算 LSTM 的反向传播 关于调参 ---- LSTM 长短时记忆网络(Long Short Term Mem...

4725
来自专栏ATYUN订阅号

一文带你认识深度学习中不同类型的卷积

卷积(convolution)现在可能是深度学习中最重要的概念。靠着卷积和卷积神经网络(CNN),深度学习超越了几乎其它所有的机器学习手段。 ? 这篇文章将简要...

4469
来自专栏IT派

机器学习算法KNN简介及实现

KNN(K近邻算法)是一种不需要学习任何参数同时也非常简单的机器学习算法,既可以用来解决分类问题也可以用来解决回归问题。直观解释这个算法就是'近朱者赤,近墨者黑...

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

TensorFlow基本操作 实现卷积和池化

之前已经提到过图像卷积的操作和意义,并且用OpenCV中的filter2D函数实现了一些例子。OpenCV中的filter2D函数仅仅是用一个卷积核去卷积单个的...

992

扫码关注云+社区

领取腾讯云代金券