TensorFlow实现DCGAN

    DCGAN叫做深层卷积生成对抗网络，它是在GAN的基础上把GAN的生成模型和判别模型用CNN 实现，而不是简单的多层感知机。此外，论文还对CNN 进行改进，去掉了了CNN 中的全连接层，批量归一化处理，使用了反卷积操作，以及使用了LReLu激活函数等等。参考论文：《Unsupervised Representation Learning with Deep Convolutional Generative Adversarial Networks》，Github代码地址：https://github.com/carpedm20/DCGAN-tensorflow。在作者源码的基础上稍作修改，使之用于mnist数据集，收敛速度很快，代码如下：

#coding=utf-8
import tensorflow as tf
import pickle
import os 
import numpy as np
from scipy.misc import imsave
import matplotlib.gridspec as gridspec
import shutil
import math

# 定义一个mnist数据集的类
class mnistReader():  
    def __init__(self,mnistPath,onehot=True):  
        self.mnistPath=mnistPath
        self.onehot=onehot  
        self.batch_index=0
        print ('read:',self.mnistPath)
        fo = open(self.mnistPath, 'rb')
        self.train_set,self.valid_set,self.test_set = pickle.load(fo,encoding='bytes')
        fo.close()        
        self.data_label_train=list(zip(self.train_set[0],self.train_set[1]))
        np.random.shuffle(self.data_label_train)       
             

    # 获取下一个训练集的batch
    def next_train_batch(self,batch_size=100):
        if self.batch_index < int(len(self.data_label_train)/batch_size):  
            # print ("batch_index:",self.batch_index )
            datum=self.data_label_train[self.batch_index*batch_size:(self.batch_index+1)*batch_size]  
            self.batch_index+=1  
            return self._decode(datum,self.onehot)  
        else:  
            self.batch_index=0  
            np.random.shuffle(self.data_label_train)  
            datum=self.data_label_train[self.batch_index*batch_size:(self.batch_index+1)*batch_size]  
            self.batch_index+=1  
            return self._decode(datum,self.onehot)    
    
    # 获取样本标签，作为生成图片的条件
    def get_sample_label(self,batch_size=64):
    	sample=self.train_set[1][0:batch_size]
    	rlabel=list()
    	for index in sample:
    		hot=np.zeros(10)
    		hot[int(index)]=1
    		rlabel.append(hot)
    	return rlabel

    # 把label变成one-hot向量
    def _decode(self,datum,onehot):  
        rdata=list()     # batch训练数据
        rlabel=list()  
        if onehot:  
            for d,l in datum:  
                rdata.append(np.reshape(d,[28,28,1]))   
                hot=np.zeros(10)    
                hot[int(l)]=1          # label设为10维的one-hot向量
                rlabel.append(hot)  
        else:  
            for d,l in datum:  
                rdata.append(np.reshape(d,[28,28,1]))  
                rlabel.append(int(l))  
        return rdata,rlabel  

# 批量归一化类的定义
class batch_norm(object):
	def __init__(self, epsilon=1e-5, momentum = 0.9, name="batch_norm"):
		with tf.variable_scope(name):
			self.epsilon  = epsilon
			self.momentum = momentum
			self.name = name

	def __call__(self, x, train=True):
		return tf.contrib.layers.batch_norm(x,\
		decay=self.momentum, \
		updates_collections=None,\
		epsilon=self.epsilon, \
		scale=True, \
		is_training=train,\
		scope=self.name)


input_height=28       # 输入图像高度
input_width=28        # 输入图像宽度
output_height=28      # 输出图像高度
output_width=28       # 输出图像宽度

max_epoch=100        # 最大的迭代次数
batch_size=64        # batch块大小

y_dim=10            # 条件向量的维度,如果不用可以设置为 None
z_dim=100            # 噪声向量的维度
gf_dim=64            # 生成器的第一层卷积层卷积核个数
df_dim=64            # 判别器的第一层卷积层卷积核个数
gfc_dim=1024         # 全连接层单元数
dfc_dim=1024         # 全连接层单元数
c_dim=1              # 图片的通道数
output_path="DCGAN"   # 保存路径


# 定义判别器，batch_size=64，image的维度为[64 28 28 1]，y的维度是[64 10]，
def discriminator(image, y=None, reuse=False):
	# 定义变量的命名空间
	with tf.variable_scope("discriminator") as scope:
		if reuse:
			scope.reuse_variables()  # 表示复用命名空间内的变量

		d_bn1 = batch_norm(name='d_bn1')
		d_bn2 = batch_norm(name='d_bn2')
		if not y_dim:
			d_bn3 = batch_norm(name='d_bn3')

	    # 如果y_dim为 None，表示没有条件变量
		if not y_dim:
			# 第一层卷积，h0维度为[64 14 14 64]，卷积核均为5*5，步长为 2,
			# 填充方式为same，所以卷积后输出图像为原来的1/4
			h0 = lrelu(conv2d(image, df_dim, name='d_h0_conv'))

			# 第二层卷积，h1的形状为 [64 7 7 128]
			h1 = lrelu(d_bn1(conv2d(h0, df_dim*2, name='d_h1_conv')))

			# 第三层卷积,h2的形状为 [64 4 4 256]
			h2 = lrelu(d_bn2(conv2d(h1, df_dim*4, name='d_h2_conv')))

			#第四层卷积,h3的形状为 [64 2 2 512]
			h3 = lrelu(d_bn3(conv2d(h2, df_dim*8, name='d_h3_conv')))

			# 把tensor展开为一维向量[64 2048],输入线性函数，h4的形状为 [64 1]
			h4 = linear(tf.reshape(h3, [batch_size, -1]), 1, 'd_h4_lin')

			# 输入sigmod函数，求出概率值，形状为[64 1]
			return tf.nn.sigmoid(h4), h4
	  
	    # 如果y_dim为真，表示有条件变量
		else:   
			# 这里yb的维度[64 1 1 10]
			yb = tf.reshape(y, [batch_size, 1, 1, y_dim])    
			'''
			  x将image和 yb连接起来，image的维度为[64 28 28 1]。这里先将yb和[64 28 28 1]的单位
			张量进行了逐元素积，得到张量[64 28 28 10],逐元素积用到了广播机制,然后[64 28 28 10]
			和image在第4维进行矩阵连接得到[64 28 28 11].这相当于是使用了Conditional GAN，为图像
			提供标签作为条件信息，将x=[64 28 28 11]输入到卷积层conv2d
			'''     			    
			x = conv_cond_concat(image, yb)

			# 第一个卷积层，卷积后和yb进行融合,h0维度为[64 14 14 21]
			h0 = lrelu(conv2d(x, c_dim + y_dim, name='d_h0_conv'))
			h0 = conv_cond_concat(h0, yb)

			# 第二个卷积层,h1的维度为[64  7*7*74+10]
			h1 = lrelu(d_bn1(conv2d(h0, df_dim + y_dim, name='d_h1_conv')))
			h1 = tf.reshape(h1, [batch_size, -1])      
			h1 = tf.concat([h1, y], 1)

			# 线性输入层 1 , h2的维度为[64 1024+10]
			h2 = lrelu(d_bn2(linear(h1, dfc_dim, 'd_h2_lin')))
			h2 = tf.concat([h2, y], 1)

			# 线性输出层 2 , h3的维度为[64 1]
			h3 = linear(h2, 1, 'd_h3_lin')

			# 输入sigmod函数，求出概率值，形状为[64 1]
			return tf.nn.sigmoid(h3), h3

# 定义生成器，在这里z为平均分布的随机分布数，z的维度为[64 100]，y的维度为[64 10]
def generator(z, y):
	with tf.variable_scope("generator") as scope:
		g_bn0 = batch_norm(name='g_bn0')
		g_bn1 = batch_norm(name='g_bn1')
		g_bn2 = batch_norm(name='g_bn2')		
		if not y_dim:
			g_bn3 = batch_norm(name='g_bn3')
		
		#如果条件变量不存在		
		if not y_dim:
			# s_h和s_w为 28
			s_h, s_w = output_height, output_width
			#s_h2和s_w2为 14
			s_h2, s_w2 = conv_out_size_same(s_h, 2), conv_out_size_same(s_w, 2)
			# s_h4和s_w4为 7
			s_h4, s_w4 = conv_out_size_same(s_h2, 2), conv_out_size_same(s_w2, 2)
			# s_h8, s_w8为 4
			s_h8, s_w8 = conv_out_size_same(s_h4, 2), conv_out_size_same(s_w4, 2)
			# s_h16, s_w16为 2
			s_h16, s_w16 = conv_out_size_same(s_h8, 2), conv_out_size_same(s_w8, 2)

			# 对噪声变量z全连接，隐射为 [64  64*8*2*2] 维向量
			z_, h0_w, h0_b = linear(z, gf_dim*8*s_h16*s_w16, 'g_h0_lin', with_w=True)

			# 改变其形状为 [64 2 2 64*8]
			h0 = tf.reshape(z_, [-1, s_h16, s_w16, gf_dim * 8])
			h0 = tf.nn.relu(g_bn0(h0))

			# 反卷积第一层，输出h1形状为：[64 4 4 256]
			h1, h1_w, h1_b = deconv2d(h0, [batch_size, s_h8, s_w8, gf_dim*4], name='g_h1', with_w=True)
			h1 = tf.nn.relu(g_bn1(h1))

			# 反卷积第二层,输出h2的形状为 [64 7 7 128]
			h2, h2_w, h2_b = deconv2d(h1, [batch_size, s_h4, s_w4, gf_dim*2], name='g_h2', with_w=True)
			h2 = tf.nn.relu(g_bn2(h2))

			# 反卷机第三层，输出的形状为 [64 14 14 64]
			h3, h3_w, h3_b = deconv2d(h2, [batch_size, s_h2, s_w2, gf_dim*1], name='g_h3', with_w=True)
			h3 = tf.nn.relu(g_bn3(h3))

			# 反卷机第四层，输出为[64 28 28 1]
			h4, h4_w, h4_b = deconv2d(h3, [batch_size, s_h, s_w, c_dim], name='g_h4', with_w=True)

			# 输入tanh函数，得到[-1,1]之间的值
			return tf.nn.tanh(h4)

		# 如果条件变量存在
		else:
			# s_h,s_w为 28
			s_h, s_w = output_height, output_width
			# s_h2,s_h4分别为 14，7
			s_h2, s_h4 = int(s_h/2), int(s_h/4)
			# s_w2,s_w4分别为 14 ,7
			s_w2, s_w4 = int(s_w/2), int(s_w/4)

			#y的维度为[64 10],z的维度为 [64 100]，z与y连接后为[64 110]			
			z = tf.concat([z, y], 1)

			# h0的维度是[64 1024+10]
			h0 = tf.nn.relu(g_bn0(linear(z, gfc_dim, 'g_h0_lin')))
			h0 = tf.concat([h0, y], 1)

			# h1的维度为[64 7 7 128+10]
			h1 = tf.nn.relu(g_bn1(linear(h0, gf_dim*2*s_h4*s_w4, 'g_h1_lin')))
			h1 = tf.reshape(h1, [batch_size, s_h4, s_w4, gf_dim * 2])			
			yb = tf.reshape(y, [batch_size, 1, 1, y_dim])
			h1 = conv_cond_concat(h1, yb)

			# 第一次翻卷机，h2的维度是[64 14 14 128+10]
			h2 = tf.nn.relu(g_bn2(deconv2d(h1,[batch_size, s_h2, s_w2, gf_dim * 2], name='g_h2')))
			h2 = conv_cond_concat(h2, yb)

			# 第二次反卷积，返回的形状为[64 28 28 1]
			return tf.nn.sigmoid(deconv2d(h2, [batch_size, s_h, s_w, c_dim], name='g_h3'))

# 卷积的尺寸除以步长
def conv_out_size_same(size, stride):
	return int(math.ceil(float(size) / float(stride)))


# 将两个tensor进行融合，这里x代表图像，y代表条件变量
def conv_cond_concat(x, y):	
	x_shapes = x.get_shape()
	y_shapes = y.get_shape()
	# 这里的点乘用到的TensorFlow的广播机制
	return tf.concat([x, y*tf.ones([x_shapes[0], x_shapes[1], x_shapes[2], y_shapes[3]] ) ], 3)


# 正常的卷积操作
def conv2d(input_,output_dim,k_h=5, k_w=5, d_h=2, d_w=2, stddev=0.02,name="conv2d"):
	with tf.variable_scope(name):    
		w = tf.get_variable('w', [k_h, k_w, input_.get_shape()[-1], output_dim],initializer=tf.truncated_normal_initializer(stddev=stddev))
		'''
		tf.get_variable：可以用来创建或者获取变量，当创建变量时，与tf.Variable是一样的。
			k_h: 卷积核高度
			k_w：卷积核尺寸
			input_.get_shape()[-1] ：卷积核的通道数
			d_h：卷积纵向步长
			d_w：卷积的横向步长
			output_dim: 卷积核个数
		'''
		conv = tf.nn.conv2d(input_, w, strides=[1, d_h, d_w, 1], padding='SAME')

		biases = tf.get_variable('biases', [output_dim], initializer=tf.constant_initializer(0.0))
		conv = tf.reshape(tf.nn.bias_add(conv, biases), conv.get_shape())

		return conv

# 反卷积操作定义，反卷积是正卷积的逆向操作
def deconv2d(input_,output_shape,k_h=5,k_w=5,d_h=2,d_w=2,stddev=0.02,name="deconv2d",with_w=False):
	with tf.variable_scope(name):
		# filter : [height, width, output_channels, in_channels]
		w = tf.get_variable('w', [k_h, k_w, output_shape[-1], input_.get_shape()[-1]],
		          initializer=tf.random_normal_initializer(stddev=stddev))    
		try:
			deconv = tf.nn.conv2d_transpose(input_, w, output_shape=output_shape,
		            strides=[1, d_h, d_w, 1])
		# Support for verisons of TensorFlow before 0.7.0
		except AttributeError:
			deconv = tf.nn.deconv2d(input_, w, output_shape=output_shape,strides=[1, d_h, d_w, 1])

		biases = tf.get_variable('biases', [output_shape[-1]], initializer=tf.constant_initializer(0.0))
		deconv = tf.reshape(tf.nn.bias_add(deconv, biases), deconv.get_shape())

		if with_w:
			return deconv, w, biases
		else:
			return deconv

# lrelu激活函数的定义     
def lrelu(x, leak=0.2, name="lrelu"):
	return tf.maximum(x, leak*x)


# 线性变换函数，相当于全连接层
def linear(input_, output_size, scope=None, stddev=0.02, bias_start=0.0, with_w=False):
	shape = input_.get_shape().as_list()

	with tf.variable_scope(scope or "Linear"):
		matrix = tf.get_variable("Matrix", [shape[1], output_size], tf.float32,tf.random_normal_initializer(stddev=stddev))
		bias = tf.get_variable("bias", [output_size],initializer=tf.constant_initializer(bias_start))
		if with_w:
			return tf.matmul(input_, matrix) + bias, matrix, bias
		else:
			return tf.matmul(input_, matrix) + bias

# 训练模型
def train():
	# 定义输入的各变量形状
	y = tf.placeholder(tf.float32, [batch_size, y_dim], name='y')
	image_dims = [input_height, input_width, c_dim]
	inputs=tf.placeholder(tf.float32, [batch_size] + image_dims, name='real_images')
	z = tf.placeholder(tf.float32, [batch_size, z_dim], name='z')
	
	# 定义生成器和判别器的计算
	G = generator(z, y)
	D, D_logits = discriminator(inputs, y, reuse=False)
	D_, D_logits_ = discriminator(G, y, reuse=True)

	# 定义损失函数
	d_loss_real = tf.reduce_mean(tf.nn.sigmoid_cross_entropy_with_logits(logits=D_logits, labels=tf.ones_like(D)))
	d_loss_fake = tf.reduce_mean(tf.nn.sigmoid_cross_entropy_with_logits(logits=D_logits_, labels=tf.zeros_like(D_)))
	g_loss = tf.reduce_mean(tf.nn.sigmoid_cross_entropy_with_logits(logits=D_logits_, labels=tf.ones_like(D_)))
	d_loss = d_loss_real + d_loss_fake
	
	# 定义需要优化的参数
	t_vars = tf.trainable_variables() #显示图中可训练的变量。
	d_vars = [var for var in t_vars if 'd_' in var.name]
	g_vars = [var for var in t_vars if 'g_' in var.name]
	
	# 定义优化器
	d_optim = tf.train.AdamOptimizer(0.0001).minimize(d_loss, var_list=d_vars)
	g_optim = tf.train.AdamOptimizer(0.0001).minimize(g_loss, var_list=g_vars)
  	
	init = tf.global_variables_initializer() 
	sess = tf.Session()
	sess.run(init)   	
	if os.path.exists(output_path):  
	    shutil.rmtree(output_path)   # 删除目录树
	os.mkdir(output_path)            # 重新创建目录树
	sample_z = np.random.uniform(-1, 1, size=(batch_size , z_dim))

	mnist=mnistReader(mnistPath="E:/testdata/mnist.pkl") 
	counter = 1
	for i in range(max_epoch):
		for j in range(100):
			print ("epoch:%s, iter:%s" % (i, j)  )
			batch_images, batch_labels=mnist.next_train_batch(batch_size=batch_size)
			batch_z = np.random.uniform(-1, 1, [batch_size, z_dim]).astype(np.float32)
			sess.run(d_optim, feed_dict={inputs: batch_images,z: batch_z,y:batch_labels})  
			sess.run(g_optim, feed_dict={z: batch_z, y:batch_labels}) 
			sess.run(g_optim, feed_dict={z: batch_z, y:batch_labels})     
		sample_labels=mnist.get_sample_label(batch_size=batch_size)
		samples = sess.run(G,feed_dict={z: sample_z,y:sample_labels})
		show_result(samples, os.path.join(output_path, "random_sample%s.jpg" % counter))
		counter+=1

# 保存生成的图片结果
def show_result(batch_res, fname, grid_size=(8, 8), grid_pad=5):  
	# 有条件变量的GAN用了sigmod函数，没有条件变量的用了tanh函数
	if not y_dim:
		batch_res =0.5*batch_res.reshape((batch_res.shape[0], 28, 28))+0.5
	else:
		batch_res = batch_res.reshape((batch_res.shape[0], 28, 28))

	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                # 生成器生成的是0-1的值，所以要乘以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)  

if __name__ == '__main__':
	train()

第一次epoch和第十四次epoch的结果如下：