提出问题
为了学习并且掌握GAN网络的基本知识，先用GAN网络实现MNIST图片生成，但是不仅仅是随机数字生成，我想实现指定数字生成。输入数字，生成对应图片。
提出方案
方案一：分别训练多个网络
一共有0~9共十个数字，分别训练十个网络。再根据输入数字不同，选择各自网络生成图片。应该更容易实现，但是图片多样性和网络复杂度可能比较差。
方案二：一个网络
generator的输入端为随机噪声图和输入数字，将生成的数字图和数字one-hot作为输出；标准图有图片信息和one-hot编码，同时最为输出。由discriminator对图片真假进行判别，同时，对图片内容进行辨识；反向传播中，对G奖励D判真的情况，同时奖励图片内容辨识正确的情况。对D真假有奖惩，同时判对内容也有奖励。这里只有判真的情况对内容判断有奖惩。
个人倾向第二种。
网络上的MNIST_GAN程序理解
在知乎上看到有人做了MNIST_GAN的代码，全部代码粘贴如下，其中迭代次数被我稍微改了，今天主要是认识这个代码的主要功能。这里附上原文链接：生成对抗网络（GAN）之MNIST数据生成
原博主把整体结构和思路讲的很清楚了，但无奈我是个新人，有些被认为是共识而忽略掉的部分我需要自己四处查询补充记录下来。
先分块理解阐述，最后会献上完整源程序。
导入库
首先按照惯例导入库。本程序环境为：python3.6版本，需要tensorflow库，我用的是1.13.1。还需要random库，numpy库，这些应该在tensorflow安装时都会顺便安装，还有matplotlib绘图。
# -*- # -*- coding: utf-8 -*-
import tensorflow as tf
import random
import numpy as np
import pickle
import matplotlib.pyplot as plt
导入数据
导入MNIST数据库，并随机选一个训练集数据绘图。训练数据为2828大小55000个。
from tensorflow.examples.tutorials.mnist import input_data
mnist = input_data.read_data_sets("../MNIST_data/", one_hot=True)
img = mnist.train.images[random.randint(0,55000-1)]
plt.imshow(img.reshape((28,28))) #,cmap='Greys_r'
绘图结果如下图所示。
构建网络结构
这里原博主写的浅显易懂，我就不再赘述了。
输入数据
占位符生成real_img和noise_img两个张量，张量形状是n*图片大小。
生成器
判别器
这里关于激活函数（Leaky ReLU、tanh和sigmoid）、logits的概念还是查了好久，这里需要记录巩固一下。
首先，激活函数是为了在网络中引入非线性能力，提高网络的可变程度，这一点是明确的，也很容易找到很多说明的文章。但是，我一直没有搞懂，激活函数在迭代过程中，具体是如何生效的，这里还需要进一步查询。
还有中间计算出的logits，这个其实就是还没有经过maxsoft函数归一化前的分布概率。
def get_inputs(real_size, noise_size):
real_img = tf.placeholder(tf.float32, [None, real_size], name='real_img')
noise_img = tf.placeholder(tf.float32, [None, noise_size], name='noise_img')
return real_img, noise_img
def get_generator(noise_img, n_unit, out_dim, reuse=False, alpha=0.01):
with tf.variable_scope("generator", reuse=reuse):
hidden1 = tf.layers.dense(noise_img, n_unit)
hidden1 = tf.maximum(alpha*hidden1, hidden1)
hidden1 = tf.layers.dropout(hidden1, rate=0.2)
logits = tf.layers.dense(hidden1, out_dim)
outputs = tf.tanh(logits)
return logits, outputs
def get_discriminator(img, n_units, reuse=False, alpha=0.01):
with tf.variable_scope("discriminator", reuse=reuse):
hidden1 = tf.layers.dense(img, n_units)
hidden1 = tf.maximum(alpha * hidden1, hidden1)
logits = tf.layers.dense(hidden1, 1)
outputs = tf.sigmoid(logits)
return logits, outputs
参数定义
这里img_size尺寸就是MNIST图大小，28*28；
noise_size影响的生成器第一层全连接层复杂度，做过几个尝试，noise_size=1，5,10,100，发现等于1的时候效果很差，5的时候次之，等于10,100几乎没有区别；
g_units和d_units就是甚至隐层参数个数的。没进行过改动尝试。
alpha是leaky ReLU的参数，其实就是小于〇时的斜率。如果未来忘记了可以去：AI常用激活函数分析4，Relu函数与Leaky Relu函数复习一下。
# 定义参数
# 真实图像的size
img_size = mnist.train.images[0].shape[0]
# 传入给generator的噪声size
noise_size = 100
# 生成器隐层参数
g_units = 128
# 判别器隐层参数
d_units = 128
# leaky ReLU的参数
alpha = 0.01
# learning_rate
learning_rate = 0.001
# label smoothing
smooth = 0.1
绘图
tf.reset_default_graph()
real_img, noise_img = get_inputs(img_size, noise_size)
# generator
g_logits, g_outputs = get_generator(noise_img, g_units, img_size)
# discriminator
d_logits_real, d_outputs_real = get_discriminator(real_img, d_units)
d_logits_fake, d_outputs_fake = get_discriminator(g_outputs, d_units, reuse=True)
# discriminator的loss
# 识别真实图片
d_loss_real = tf.reduce_mean(tf.nn.sigmoid_cross_entropy_with_logits(logits=d_logits_real,
labels=tf.ones_like(d_logits_real)) * (1 - smooth))
# 识别生成的图片
d_loss_fake = tf.reduce_mean(tf.nn.sigmoid_cross_entropy_with_logits(logits=d_logits_fake,
labels=tf.zeros_like(d_logits_fake)))
# 总体loss
d_loss = tf.add(d_loss_real, d_loss_fake)
# generator的loss
g_loss = tf.reduce_mean(tf.nn.sigmoid_cross_entropy_with_logits(logits=d_logits_fake,
labels=tf.ones_like(d_logits_fake)) * (1 - smooth))
train_vars = tf.trainable_variables()
# generator中的tensor
g_vars = [var for var in train_vars if var.name.startswith("generator")]
# discriminator中的tensor
d_vars = [var for var in train_vars if var.name.startswith("discriminator")]
# optimizer
d_train_opt = tf.train.AdamOptimizer(learning_rate).minimize(d_loss, var_list=d_vars)
g_train_opt = tf.train.AdamOptimizer(learning_rate).minimize(g_loss, var_list=g_vars)
首先，分别用G网络和D网络得到生成图片、logits和判别器的真假输出、logits。其中，要区分判别器输入内容是真假的输出。以logits与全1（真）或全0（假）的交叉熵作为判别器输出loss函数；同时，以判别器判断假的logits和全1交叉熵作为生成器的损失函数。在迭代中，使这两个损失函数分别最小，即得到良好的生成器。
开始迭代
# batch_size
batch_size = 64
# 训练迭代轮数
epochs = 100
# 抽取样本数
n_sample = 25
# 存储测试样例
samples = []
# 存储loss
losses = []
# 保存生成器变量
saver = tf.train.Saver(var_list = g_vars)
# 开始训练
with tf.Session() as sess:
sess.run(tf.global_variables_initializer())
for e in range(epochs):
for batch_i in range(mnist.train.num_examples//batch_size):
batch = mnist.train.next_batch(batch_size)
batch_images = batch[0].reshape((batch_size, 784))
# 对图像像素进行scale，这是因为tanh输出的结果介于(-1,1),real和fake图片共享discriminator的参数
batch_images = batch_images*2 - 1
# generator的输入噪声
batch_noise = np.random.uniform(-1, 1, size=(batch_size, noise_size))
# Run optimizers
_ = sess.run(d_train_opt, feed_dict={real_img: batch_images, noise_img: batch_noise})
_ = sess.run(g_train_opt, feed_dict={noise_img: batch_noise})
# 每一轮结束计算loss
train_loss_d = sess.run(d_loss,
feed_dict = {real_img: batch_images,
noise_img: batch_noise})
# real img loss
train_loss_d_real = sess.run(d_loss_real,
feed_dict = {real_img: batch_images,
noise_img: batch_noise})
# fake img loss
train_loss_d_fake = sess.run(d_loss_fake,
feed_dict = {real_img: batch_images,
noise_img: batch_noise})
# generator loss
train_loss_g = sess.run(g_loss,
feed_dict = {noise_img: batch_noise})
print("Epoch {}/{}...".format(e+1, epochs),
"Discriminator Loss: {:.4f}(Real: {:.4f} + Fake: {:.4f})...".format(train_loss_d, train_loss_d_real, train_loss_d_fake),
"Generator Loss: {:.4f}".format(train_loss_g))
# 记录各类loss值
losses.append((train_loss_d, train_loss_d_real, train_loss_d_fake, train_loss_g))
# 抽取样本后期进行观察
sample_noise = np.random.uniform(-1, 1, size=(n_sample, noise_size))
gen_samples = sess.run(get_generator(noise_img, g_units, img_size, reuse=True),
feed_dict={noise_img: sample_noise})
samples.append(gen_samples)
# 存储checkpoints
saver.save(sess, './checkpoints/generator.ckpt')
将训练集数据，噪声数据输入到图中，进行迭代训练，训练过程中修改两个网络中的参数。并对迭代过程中的loss值进行记录。最后打印并存储。这里没有什么特别需要说的，源码的注释解释的很好了。
以下为最终输出结果和迭代过程输出结果：
通过通篇详读源码，这是第一个稍微复杂一点的tensorflow源码，终于对tensorflow的运行机制，包括loss函数的作用机制有了一点的概念，接下来就需要以目标为前提对源码进行针对的改动，实现我的目的了。
以下为源码完整版本，可以直接copy。这里需要重申，源码转自知乎：生成对抗网络（GAN）之MNIST数据生成
# -*- # -*- coding: utf-8 -*-
import tensorflow as tf
import random
import numpy as np
import pickle
import matplotlib.pyplot as plt
from tensorflow.examples.tutorials.mnist import input_data
mnist = input_data.read_data_sets("../MNIST_data/", one_hot=True)
img = mnist.train.images[random.randint(0,55000-1)]
plt.imshow(img.reshape((28,28))) #,cmap='Greys_r'
def get_inputs(real_size, noise_size):
real_img = tf.placeholder(tf.float32, [None, real_size], name='real_img')
noise_img = tf.placeholder(tf.float32, [None, noise_size], name='noise_img')
return real_img, noise_img
def get_generator(noise_img, n_unit, out_dim, reuse=False, alpha=0.01):
with tf.variable_scope("generator", reuse=reuse):
hidden1 = tf.layers.dense(noise_img, n_unit)
hidden1 = tf.maximum(alpha*hidden1, hidden1)
hidden1 = tf.layers.dropout(hidden1, rate=0.2)
logits = tf.layers.dense(hidden1, out_dim)
outputs = tf.tanh(logits)
return logits, outputs
def get_discriminator(img, n_units, reuse=False, alpha=0.01):
with tf.variable_scope("discriminator", reuse=reuse):
hidden1 = tf.layers.dense(img, n_units)
hidden1 = tf.maximum(alpha * hidden1, hidden1)
logits = tf.layers.dense(hidden1, 1)
outputs = tf.sigmoid(logits)
return logits, outputs
# 定义参数
# 真实图像的size
img_size = mnist.train.images[0].shape[0]
# 传入给generator的噪声size
noise_size = 100
# 生成器隐层参数
g_units = 128
# 判别器隐层参数
d_units = 128
# leaky ReLU的参数
alpha = 0.01
# learning_rate
learning_rate = 0.001
# label smoothing
smooth = 0.1
tf.reset_default_graph()
real_img, noise_img = get_inputs(img_size, noise_size)
# generator
g_logits, g_outputs = get_generator(noise_img, g_units, img_size)
# discriminator
d_logits_real, d_outputs_real = get_discriminator(real_img, d_units)
d_logits_fake, d_outputs_fake = get_discriminator(g_outputs, d_units, reuse=True)
# discriminator的loss
# 识别真实图片
d_loss_real = tf.reduce_mean(tf.nn.sigmoid_cross_entropy_with_logits(logits=d_logits_real,
labels=tf.ones_like(d_logits_real)) * (1 - smooth))
# 识别生成的图片
d_loss_fake = tf.reduce_mean(tf.nn.sigmoid_cross_entropy_with_logits(logits=d_logits_fake,
labels=tf.zeros_like(d_logits_fake)))
# 总体loss
d_loss = tf.add(d_loss_real, d_loss_fake)
# generator的loss
g_loss = tf.reduce_mean(tf.nn.sigmoid_cross_entropy_with_logits(logits=d_logits_fake,
labels=tf.ones_like(d_logits_fake)) * (1 - smooth))
train_vars = tf.trainable_variables()
# generator中的tensor
g_vars = [var for var in train_vars if var.name.startswith("generator")]
# discriminator中的tensor
d_vars = [var for var in train_vars if var.name.startswith("discriminator")]
# optimizer
d_train_opt = tf.train.AdamOptimizer(learning_rate).minimize(d_loss, var_list=d_vars)
g_train_opt = tf.train.AdamOptimizer(learning_rate).minimize(g_loss, var_list=g_vars)
# batch_size
batch_size = 64
# 训练迭代轮数
epochs = 300
# 抽取样本数
n_sample = 25
# 存储测试样例
samples = []
# 存储loss
losses = []
# 保存生成器变量
saver = tf.train.Saver(var_list = g_vars)
# 开始训练
with tf.Session() as sess:
sess.run(tf.global_variables_initializer())
for e in range(epochs):
for batch_i in range(mnist.train.num_examples//batch_size):
batch = mnist.train.next_batch(batch_size)
batch_images = batch[0].reshape((batch_size, 784))
# 对图像像素进行scale，这是因为tanh输出的结果介于(-1,1),real和fake图片共享discriminator的参数
batch_images = batch_images*2 - 1
# generator的输入噪声
batch_noise = np.random.uniform(-1, 1, size=(batch_size, noise_size))
# Run optimizers
_ = sess.run(d_train_opt, feed_dict={real_img: batch_images, noise_img: batch_noise})
_ = sess.run(g_train_opt, feed_dict={noise_img: batch_noise})
# 每一轮结束计算loss
train_loss_d = sess.run(d_loss,
feed_dict = {real_img: batch_images,
noise_img: batch_noise})
# real img loss
train_loss_d_real = sess.run(d_loss_real,
feed_dict = {real_img: batch_images,
noise_img: batch_noise})
# fake img loss
train_loss_d_fake = sess.run(d_loss_fake,
feed_dict = {real_img: batch_images,
noise_img: batch_noise})
# generator loss
train_loss_g = sess.run(g_loss,
feed_dict = {noise_img: batch_noise})
print("Epoch {}/{}...".format(e+1, epochs),
"Discriminator Loss: {:.4f}(Real: {:.4f} + Fake: {:.4f})...".format(train_loss_d, train_loss_d_real, train_loss_d_fake),
"Generator Loss: {:.4f}".format(train_loss_g))
# 记录各类loss值
losses.append((train_loss_d, train_loss_d_real, train_loss_d_fake, train_loss_g))
# 抽取样本后期进行观察
sample_noise = np.random.uniform(-1, 1, size=(n_sample, noise_size))
gen_samples = sess.run(get_generator(noise_img, g_units, img_size, reuse=True),
feed_dict={noise_img: sample_noise})
samples.append(gen_samples)
# 存储checkpoints
saver.save(sess, './checkpoints/generator.ckpt')
# 将sample的生成数据记录下来
with open('train_samples.pkl', 'wb') as f:
pickle.dump(samples, f)
fig, ax = plt.subplots(figsize=(20,7))
losses = np.array(losses)
plt.plot(losses.T[0], label='Discriminator Total Loss')
plt.plot(losses.T[1], label='Discriminator Real Loss')
plt.plot(losses.T[2], label='Discriminator Fake Loss')
plt.plot(losses.T[3], label='Generator')
plt.title("Training Losses")
plt.legend()
# Load samples from generator taken while training
with open('train_samples.pkl', 'rb') as f:
samples = pickle.load(f)
def view_samples(epoch, samples):
"""
epoch代表第几次迭代的图像
samples为我们的采样结果
"""
fig, axes = plt.subplots(figsize=(7,7), nrows=5, ncols=5, sharey=True, sharex=True)
for ax, img in zip(axes.flatten(), samples[epoch][1]): # 这里samples[epoch][1]代表生成的图像结果，而[0]代表对应的logits
ax.xaxis.set_visible(False)
ax.yaxis.set_visible(False)
im = ax.imshow(img.reshape((28,28)), cmap='Greys_r')
return fig, axes
_ = view_samples(-1, samples) # 显示最后一轮的outputs
# 指定要查看的轮次
epoch_idx = [0, 5, 10, 20, 40, 60, 80, 100, 150, 250] # 一共300轮，不要越界
show_imgs = []
for i in epoch_idx:
show_imgs.append(samples[i][1])
# 指定图片形状
rows, cols = 10, 25
fig, axes = plt.subplots(figsize=(30,12), nrows=rows, ncols=cols, sharex=True, sharey=True)
idx = range(0, epochs, int(epochs/rows))
for sample, ax_row in zip(show_imgs, axes):
for img, ax in zip(sample[::int(len(sample)/cols)], ax_row):
ax.imshow(img.reshape((28,28)), cmap='Greys_r')
ax.xaxis.set_visible(False)
ax.yaxis.set_visible(False)
# 加载我们的生成器变量
saver = tf.train.Saver(var_list=g_vars)
with tf.Session() as sess:
saver.restore(sess, tf.train.latest_checkpoint('checkpoints'))
sample_noise = np.random.uniform(-1, 1, size=(25, noise_size))
gen_samples = sess.run(get_generator(noise_img, g_units, img_size, reuse=True),
feed_dict={noise_img: sample_noise})
_ = view_samples(0, [gen_samples])
386
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
