对抗生成网络，其实就像周伯通，左手打右手，不用陪练，自己就能练成绝世武功！
先说一个对我学习有很大帮助的故事:
刚参加工作时，顶头上级是跟我年纪相仿的年轻人，据说家里有点关系。
有一天交给我一个任务，让我写个部门工作总结，我这刚参加工作，哪会写这个啊？他说没关系，写完给他看，他帮我。
接下来的一段时间就反复往他办公室跑，每次写完交上去，第二天拿回来时都能给我指出点问题，提出点修改意见，反反复复半个月。好在最终还是写出来了，而且获得了上级的肯定！
多年后，一次闲聊，说起当年写总结。他说那是他也刚参加工作，他也不会写
但是他有往年的存底，每次我拿过去的总结，他都对照往年的看看，有不对的地方给我指出来，让我回去修改，反复修改，直到他觉得跟往年差不多了。
以上故事是现编的。这里的“我”就是 生成器（generator）,我领导就是 判别器(discriminator)，往年的《工作总结》就是 数据集。判别器看了往年的《工作总结》，知道什么好，什么不好，再看我写的，心里就大概有数了，我写的哪里不好，然后提出改进方向。这个过程中，“我“在学习，“领导“其实也在学习。
下面是模仿老师的程序生成的玫瑰，1000个epoch，可以看出效果差很多，可能是因为老师为了能让我们都能跑起来，不敢搞大计算量，设计的cnn太简单。
改过的代码(win7,python3.5,tensorflow1.1.0):
刚参加工作时，顶头上级是跟我年纪相仿的年轻人，据说家里有点关系。
有一天交给我一个任务，让我写个部门工作总结，我这刚参加工作，哪会写这个啊？他说没关系，写完给他看，他帮我。
接下来的一段时间就反复往他办公室跑，每次写完交上去，第二天拿回来时都能给我指出点问题，提出点修改意见，反反复复半个月。好在最终还是写出来了，而且获得了上级的肯定！
多年后，一次闲聊，说起当年写总结。他说那是他也刚参加工作，他也不会写
但是他有往年的存底，每次我拿过去的总结，他都对照往年的看看，有不对的地方给我指出来，让我回去修改，反复修改，直到他觉得跟往年差不多了。
以上故事是现编的。这里的“我”就是 生成器（generator）,我领导就是 判别器(discriminator)，往年的《工作总结》就是 数据集。判别器看了往年的《工作总结》，知道什么好，什么不好，再看我写的，心里就大概有数了，我写的哪里不好，然后提出改进方向。这个过程中，“我“在学习，“领导“其实也在学习。
下面是模仿老师的程序生成的玫瑰，1000个epoch，可以看出效果差很多，可能是因为老师为了能让我们都能跑起来，不敢搞大计算量，设计的cnn太简单。
改过的代码(win7,python3.5,tensorflow1.1.0):
import numpy as np
import tensorflow as tf
import pickle
import matplotlib.pyplot as plt
import os
os.environ["CUDA_VISIBLE_DEVICES"]="0"#gpu参与运算,没有gpu设到"-1"
%matplotlib inline 获得数据
def get_inputs(noise_dim, image_height, image_width, image_depth):
inputs_real = tf.placeholder(tf.float32, [None, image_height, image_width, image_depth], name='inputs_real')
inputs_noise = tf.placeholder(tf.float32, [None, noise_dim], name='inputs_noise')
return inputs_real, inputs_noise 生成器
def get_generator(noise_img, output_dim, is_train=True, alpha=0.01):
# ouput_width = (input_width-filter_width+2*padding)/stride+1
#in=out*(stride+1)+filter-2*padding
#生成器和判别器的卷积得重新设计!!
with tf.variable_scope("generator", reuse=(not is_train)):
# 100 x 1 to 4 x 4 x 512
# 全连接层
layer1 = tf.layers.dense(noise_img, 4*4*512)
layer1 = tf.reshape(layer1, [-1, 4, 4, 512])
# batch normalization
layer1 = tf.layers.batch_normalization(layer1, training=is_train)
# Leaky ReLU
layer1 = tf.maximum(alpha * layer1, layer1)
# dropout
layer1 = tf.nn.dropout(layer1, keep_prob=0.8)
# 4 x 4 x 512 to 8
layer2 = tf.layers.conv2d_transpose(layer1, 1024, 3, strides=2, padding='same')
layer2 = tf.layers.batch_normalization(layer2, training=is_train)
layer2 = tf.maximum(alpha * layer2, layer2)
layer2 = tf.nn.dropout(layer2, keep_prob=0.8)
#8to16
layer21 = tf.layers.conv2d_transpose(layer2, 512, 3, strides=2, padding='same')
layer21 = tf.layers.batch_normalization(layer21, training=is_train)
layer21 = tf.maximum(alpha * layer21, layer21)
layer21 = tf.nn.dropout(layer21, keep_prob=0.8)
#16to 32
layer22 = tf.layers.conv2d_transpose(layer21, 256, 3, strides=2, padding='same')
layer22 = tf.layers.batch_normalization(layer22, training=is_train)
layer22 = tf.maximum(alpha * layer22, layer22)
layer22 = tf.nn.dropout(layer22, keep_prob=0.8)
# 32 x 32x 256 to 64 x 64 x 64
layer3 = tf.layers.conv2d_transpose(layer22, 128, 3, strides=2, padding='same')
layer3 = tf.layers.batch_normalization(layer3, training=is_train)
layer3 = tf.maximum(alpha * layer3, layer3)
layer3 = tf.nn.dropout(layer3, keep_prob=0.8)
# 64 x 64 x 64 to 128 x 128 x 1
logits = tf.layers.conv2d_transpose(layer3, output_dim, 3, strides=2, padding='same')
# MNIST原始数据集的像素范围在0-1，这里的生成图片范围为(-1,1)
# 因此在训练时，记住要把MNIST像素范围进行resize
#print("output_dim:::",output_dim)
outputs = tf.tanh(logits)
#print("Generator---layer1: ",layer1," | layer21",layer21," | layer22",layer22," | logits",logits)
return outputs 判别器
def get_discriminator(inputs_img, reuse=False, alpha=0.01):
with tf.variable_scope("discriminator", reuse=reuse):
# 128 x 128 x 1 to 64 x 64 x 64
# 第一层不加入BN
layer1 = tf.layers.conv2d(inputs_img, 64, 3, strides=2, padding='same')
layer1 = tf.maximum(alpha * layer1, layer1)
layer1 = tf.nn.dropout(layer1, keep_prob=0.8)
# 64 x 64 x 64 to 32 x 32 x 128
layer2 = tf.layers.conv2d(layer1, 128, 3, strides=2, padding='same')
layer2 = tf.layers.batch_normalization(layer2, training=True)
layer2 = tf.maximum(alpha * layer2, layer2)
layer2 = tf.nn.dropout(layer2, keep_prob=0.8)
#32 to 16
layer21 = tf.layers.conv2d(layer2, 256, 3, strides=2, padding='same')
layer21 = tf.layers.batch_normalization(layer21, training=True)
layer21 = tf.maximum(alpha * layer21, layer21)
layer21 = tf.nn.dropout(layer21, keep_prob=0.8)
#16to8
layer22 = tf.layers.conv2d(layer21, 512, 3, strides=2, padding='same')
layer22 = tf.layers.batch_normalization(layer22, training=True)
layer21 = tf.maximum(alpha * layer22, layer22)
layer21 = tf.nn.dropout(layer22, keep_prob=0.8)
#8to4
# 32 x 32 x 128 to 4 x 4 x 512
layer3 = tf.layers.conv2d(layer22, 512, 3, strides=2, padding='same')
layer3 = tf.layers.batch_normalization(layer3, training=True)
layer3 = tf.maximum(alpha * layer3, layer3)
layer3 = tf.nn.dropout(layer3, keep_prob=0.8)
# 4 x 4 x 512 to 4*4*512 x 1
flatten = tf.reshape(layer3, (-1, 4*4*512))
logits = tf.layers.dense(flatten, 1)
outputs = tf.sigmoid(logits)
#print("Discriminator---input: ",inputs_img.shape,"layer1: ",layer1," | layer2",layer2," | layer3",layer3," | logits",logits)
return logits, outputs 目标函数：
def get_loss(inputs_real, inputs_noise, image_depth, smooth=0.1):
g_outputs = get_generator(inputs_noise, image_depth, is_train=True)
d_logits_real, d_outputs_real = get_discriminator(inputs_real)
d_logits_fake, d_outputs_fake = get_discriminator(g_outputs, reuse=True)
# 计算Loss
g_loss = tf.reduce_mean(tf.nn.sigmoid_cross_entropy_with_logits(logits=d_logits_fake,
labels=tf.ones_like(d_outputs_fake)*(1-smooth)))
d_loss_real = tf.reduce_mean(tf.nn.sigmoid_cross_entropy_with_logits(logits=d_logits_real,
labels=tf.ones_like(d_outputs_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_outputs_fake)))
d_loss = tf.add(d_loss_real, d_loss_fake)
return g_loss, d_loss 优化器
def get_optimizer(g_loss, d_loss, beta1=0.4, learning_rate=0.001):
train_vars = tf.trainable_variables()
g_vars = [var for var in train_vars if var.name.startswith("generator")]
d_vars = [var for var in train_vars if var.name.startswith("discriminator")]
# Optimizer
with tf.control_dependencies(tf.get_collection(tf.GraphKeys.UPDATE_OPS)):
g_opt = tf.train.AdamOptimizer(learning_rate).minimize(g_loss, var_list=g_vars)
d_opt = tf.train.AdamOptimizer(learning_rate).minimize(d_loss, var_list=d_vars)
return g_opt, d_opt def plot_images(samples):
fig, axes = plt.subplots(nrows=1, ncols=3, sharex=True, sharey=True, figsize=(50,15))#如果多行,会认为axes是一个numpy
for img, ax in zip(samples, axes):
#print (img.shape,ax,samples.shape)
#ax.imshow(img.reshape((28, 28)), cmap='Greys_r')
ax.imshow(img.reshape((128, 128)), cmap='Greys_r')#可能是cnn计算有误,得不到240*240的
ax.get_xaxis().set_visible(False)
ax.get_yaxis().set_visible(False)
fig.tight_layout(pad=0) def show_generator_output(sess, n_images, inputs_noise, output_dim):
cmap = 'Greys_r'
noise_shape = inputs_noise.get_shape().as_list()[-1]
# 生成噪声图片
examples_noise = np.random.uniform(-1, 1, size=[n_images, noise_shape])
samples = sess.run(get_generator(inputs_noise, output_dim, False),
feed_dict={inputs_noise: examples_noise})
#print("show-output_dim:::",output_dim)
result = np.squeeze(samples, -1)
return result 定义参数
# 定义参数
batch_size = 32#设为64内存溢出,刚开始以为gpu原因,后来关gpu也溢出,所以减少baitch试试
noise_size = 100
epochs = 1000
n_samples = 3
beta1=0.4
learning_rate = 0.001 图片预处理
把所有图片放到一个目录里,供python 读取,转成黑白格式并存成数据集
图片需要统一到128*128大小
from PIL import Image
import os.path
import glob
images=[]
#获得数据,提取每一幅图片,变成灰度图,压缩到0,1之间
#1.获得图像,变成灰度,保存到一个??里(??格式需要先看看batch )print (batch[0].shape) ---->(64, 784) batch[0]是numpy类型
for jpgfile in glob.glob("E:\\lianhua\\*.jpg"):
img=Image.open(jpgfile)
img=img.convert('L')
img=np.array(img)
img=img.reshape(-1,1)
images.append(img)
image=np.array(images)
print(image.shape)
image=image.reshape( -1,16384)#128*128
#2.压缩到0,1之间
image=image/255.0 batch
不使用mnist数据集,需要自己做一个get_batch方法
def getBatch(image,batch_size,steps):
turns=image.shape[0]//batch_size#数据集 一共 有多少个batchs
num=steps%turns#该取第几段了
#print(turns,num)
return image[num:num+batch_size] 训练
def train(noise_size, data_shape, batch_size, n_samples):
# 存储loss
losses = []
steps = 0
inputs_real, inputs_noise = get_inputs(noise_size, data_shape[1], data_shape[2], data_shape[3])
g_loss, d_loss = get_loss(inputs_real, inputs_noise, data_shape[-1])
g_train_opt, d_train_opt = get_optimizer(g_loss, d_loss, beta1, learning_rate)
with tf.Session() as sess:
sess.run(tf.global_variables_initializer())
#try:
# saver=tf.train.Saver()
# saver.restore(sess,'./checkpoints/generator.ckpt')
#except Exception as e:
# print(e)
# sess.run(tf.global_variables_initializer())
# 迭代epoch
for e in range(epochs):
#for batch_i in range(mnist.train.num_examples//batch_size):
for batch_i in range(image.shape[0]//batch_size):# !!!!自己加的,替换上一句 image是全局变量
steps += 1
#batch = mnist.train.next_batch(batch_size)
batch=getBatch(image,batch_size,steps)# !!!!自己加的,替换上一句 image是全局变量
#print(batch.shape)
#batch_images = batch[0].reshape((batch_size, data_shape[1], data_shape[2], data_shape[3]))
batch_images = batch.reshape((batch_size, data_shape[1], data_shape[2], data_shape[3]))#!!!!自己加的,替换上一句 image是全局变量
# scale to -1, 1
batch_images = batch_images * 2 - 1
# noise
batch_noise = np.random.uniform(-1, 1, size=(batch_size, noise_size))
# run optimizer
_ = sess.run(g_train_opt, feed_dict={inputs_real: batch_images,
inputs_noise: batch_noise})
_ = sess.run(d_train_opt, feed_dict={inputs_real: batch_images,
inputs_noise: batch_noise})
if steps % 200 == 0:
train_loss_d = d_loss.eval({inputs_real: batch_images,
inputs_noise: batch_noise})
train_loss_g = g_loss.eval({inputs_real: batch_images,
inputs_noise: batch_noise})
losses.append((train_loss_d, train_loss_g))
# 显示图片
samples = show_generator_output(sess, n_samples, inputs_noise, data_shape[-1])
#print("data_shape[-1]:::",data_shape[-1])
#保存sess
#w1=[2,2]
train_vars = tf.trainable_variables()
g_vars = [var for var in train_vars if var.name.startswith("generator")]
#global saver
saver=tf.train.Saver(var_list=g_vars)
saver.save(sess,'./checkpoints/generator.ckpt')
plot_images(samples)
print("Epoch {}/{}....".format(e+1, epochs),
"Discriminator Loss: {:.4f}....".format(train_loss_d),
"Generator Loss: {:.4f}....". format(train_loss_g)) 万事具备,可以开工了
with tf.Graph().as_default():
train(noise_size, [-1, 128, 128, 1], batch_size, n_samples)# !!!!将28改成128了 运行结果:
Epoch 12/1000…. Discriminator Loss: 0.3733…. Generator Loss: 5.5305….
Epoch 24/1000…. Discriminator Loss: 0.3808…. Generator Loss: 6.1425….
Epoch 36/1000…. Discriminator Loss: 0.3637…. Generator Loss: 5.7996….
Epoch 48/1000…. Discriminator Loss: 0.3698…. Generator Loss: 5.5932….
Epoch 59/1000…. Discriminator Loss: 0.3606…. Generator Loss: 5.5278….
总结：
生成对抗网络如下图所示，其中G网络的loss计算是通过D网络来表征的。
1. 对于G网络，希望其生成的图像A_out，经过D网络的“审判”之后，可以让D网络输出1，也就是真。
因此，G_loss = D_out_A与1之间的交叉熵
2. 对于D网络，可以看做是两个部分，第一个，有图像B输入网络，输出D_out_B，第二个是图像A_out输入，输出D_out_A。对于第一部分loss的计算是D_out_B与1之间的交叉熵，原因分析：图像B本来就是目标图像，图像A是噪音。第二部分，loss为D_out_A与0之间的交叉熵，原因分析：D网络就是认为图像A_out不是目标图像。
2109
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
