DCGAN。顧名思義，就是深度卷積生成對抗神經網路，也就是引入了卷積的，但是它用的是反捲積，就是卷積的反操作。

我們看看DCGAN的圖：

生成器開始輸入的是噪聲資料，然後經過一個全連線層，再把全連線層的輸出reshape，然後經過反捲積，

判別器就是卷積層，最後一個全連線層，用sigmoid啟用函式。

DCGAN注意事項：

生成器的全部啟用函式用relu，除了最後一層用tanh函式

判別器的啟用函式都是LeakyRelu，最後一層是sigmoid、

生成器和判別器都是用BN層，

在判別器中只需要一層全連線層用於最後的分類，不要接太多，一個就好

訓練的時候需要將原始輸入影象resize到[-1,1]

生成器最後一層不使用BN層，判別器第一層不使用BN層

然後將下DCGAN的網路結構：

首先是生成網路：

第一層：全連線層，輸出神經元個數64×8×影象長×影象寬，這個地方的長和寬是要原始圖片反推過來的，然後reshape成[batch_size,影象長,影象寬,64×8],然後接著relu啟用函式

第二層：反捲積層(deconv),卷積核大小[5,5],步長2,權重使用高斯分佈，同時權重的初始化標準差stddev=0.02，輸出通道數64×4，後面接BN層，然後使用relu作為啟用函式

第三層：也是反捲積層，引數和上面的一樣，輸出通道數是64×2，也是BN加relu

第四層：也是反捲積層，引數和上面的一樣，輸出通道數是64×1，也是BN加relu

第五層：反捲積層，輸出通道數為3,後面接relu(沒有BN層)

然後看我實現的程式碼：

匯入相關的庫

import matplotlib.pyplot as plt
import tensorflow as tf
from scipy import misc
import os
import numpy as np
%matplotlib inline

這個是顯示圖片，方便訓練過程中檢視

def vis_img(batch_size,samples):
    fig,axes = plt.subplots(figsize=(7,7),nrows=8,ncols=8,sharey=True,sharex=True)

    for ax,img in zip(axes.flatten(),samples[batch_size]):
        #print(img.shape)


        ax.xaxis.set_visible(False)
        ax.yaxis.set_visible(False)
        im = ax.imshow(img.reshape((32, 32,3)), cmap='Greys_r')
    plt.show()
    return fig, axes

import os
from scipy import misc
import numpy as np
def read_img(path):

    img = misc.imresize(misc.imread(path),size=[32,32])
    return img

def get_batch(path,batch_size):
    img_list = [os.path.join(path,i) for i in os.listdir(path)]
    
    n_batchs = len(img_list)//batch_size
    img_list = img_list[:n_batchs*batch_size]

    for ii in range(n_batchs):
        tmp_img_list = img_list[ii*batch_size:(ii+1)*batch_size]
        img_batch = np.zeros(shape=[batch_size, 32, 32, 3])
        for jj,img in enumerate(tmp_img_list):
            img_batch[jj] = read_img(img)
        yield img_batch

def generator(inputs,stddev=0.02,alpha=0.2,name='generator',reuse=False):


    with tf.variable_scope(name,reuse=reuse) as scope:


        fc1 = tf.layers.dense(gen_input,64*8*6*6,name='fc1')
        re1 = tf.reshape(fc1, (-1, 6, 6, 512),name='reshape')
        bn1 = tf.layers.batch_normalization(re1,name='bn1')
        #ac1 = tf.maximum(alpha * bn1, bn1,name='ac1')
        ac1 = tf.nn.relu(bn1,name='ac1')


        de_conv1 = tf.layers.conv2d_transpose(ac1,256,kernel_size=[5,5],padding='same',strides=2,kernel_initializer=tf.random_normal_initializer(stddev=stddev),name='decov1')
        bn2 = tf.layers.batch_normalization(de_conv1,name='bn2')
        #ac2 = tf.maximum(alpha * bn2, bn2,name='ac2')
        ac2 = tf.nn.relu(bn2,name='ac2')


        de_conv2 = tf.layers.conv2d_transpose(ac2, 128, kernel_size=[5, 5],padding='same',kernel_initializer=tf.random_normal_initializer(stddev=stddev),strides=2, name='decov2')
        bn3 = tf.layers.batch_normalization(de_conv2,name='bn3')
        #ac3 = tf.maximum(alpha * bn3, bn3,name='ac3')
        ac3 = tf.nn.relu(bn3,name='ac3')


        de_conv3 = tf.layers.conv2d_transpose(ac3, 64, kernel_size=[5, 5],padding='same',kernel_initializer=tf.random_normal_initializer(stddev=stddev), strides=2, name='decov3')
        bn4 = tf.layers.batch_normalization(de_conv3,name='bn4')
        #ac4 = tf.maximum(alpha * bn4, bn4,name='ac4')
        ac4 = tf.nn.relu(bn4,name='ac4')


        logits = tf.layers.conv2d_transpose(ac4, 3, kernel_size=[5, 5], padding='same',kernel_initializer=tf.random_normal_initializer(stddev=stddev), strides=2,name='logits')


        output = tf.tanh(logits)


        return output

構建判別網路：

def discriminator(inputs,stddev=0.02,alpha=0.2,batch_size=64,name='discriminator',reuse=False):
    with tf.variable_scope(name,reuse=reuse) as scope:

        conv1 = tf.layers.conv2d(inputs,64,(5,5),(2,2),padding='same',kernel_initializer=tf.random_normal_initializer(stddev=stddev),name='conv1')

        ac1 = tf.maximum(alpha*conv1,conv1,name='ac1')
        

        conv2 = tf.layers.conv2d(ac1, 128, (5,5), (2, 2), padding='same',
                                 kernel_initializer=tf.random_normal_initializer(stddev=stddev), name='conv2')
        bn2 = tf.layers.batch_normalization(conv2, name='bn2')
        ac2 = tf.maximum(alpha * bn2, bn2, name='ac2')
        

        conv3 = tf.layers.conv2d(ac2, 256, (5,5), (2, 2), padding='same',
                                 kernel_initializer=tf.random_normal_initializer(stddev=stddev), name='conv3')
        bn3 = tf.layers.batch_normalization(conv3, name='bn3')
        ac3 = tf.maximum(alpha * bn3, bn3, name='ac3')
  

        conv4 = tf.layers.conv2d(ac3, 512, (5,5), (2, 2), padding='same',
                               kernel_initializer=tf.random_normal_initializer(stddev=stddev), name='conv4')
        bn4 = tf.layers.batch_normalization(conv4, name='bn4')
        ac4 = tf.maximum(alpha * bn4, bn4, name='ac4')

        flat = tf.reshape(ac4,shape=[batch_size,6*6*512],name='reshape')

        fc2 = tf.layers.dense(flat, 1, kernel_initializer=tf.random_normal_initializer(stddev=stddev), name='fc2')
        return fc2
lr = 0.0002
epochs = 100
batch_size = 64

alpha = 0.2
with tf.name_scope('gen_input') as scope:
    gen_input = tf.placeholder(dtype=tf.float32,shape=[None,100],name='gen_input')

with tf.name_scope('dis_input') as scope:
    real_input = tf.placeholder(dtype=tf.float32,shape=[None,96,96,3],name='dis_input')
    


gen_out = generator(gen_input,stddev=0.02,alpha=alpha,name='generator',reuse=False)

real_logits = discriminator(real_input,alpha=alpha,batch_size=batch_size)
fake_logits = discriminator(gen_out,alpha=alpha,reuse=True)



#var_list_gen = tf.get_collection(tf.GraphKeys.TRAINABLE_VARIABLES,scope='generator')
#var_list_dis = tf.get_collection(tf.GraphKeys.TRAINABLE_VARIABLES,scope='discriminator')
train_var = tf.trainable_variables()
var_list_gen = [var for var in train_var if var.name.startswith('generator') ]
var_list_dis = [var for var in train_var if var.name.startswith('discriminator')]
with tf.name_scope('metrics') as scope:
    loss_g = tf.reduce_mean(tf.nn.sigmoid_cross_entropy_with_logits(labels=tf.ones_like(fake_logits)*0.9,logits=fake_logits))
    loss_d_f = tf.reduce_mean(tf.nn.sigmoid_cross_entropy_with_logits(labels=tf.zeros_like(fake_logits),logits=fake_logits))
    loss_d_r = tf.reduce_mean(tf.nn.sigmoid_cross_entropy_with_logits(labels=tf.ones_like(real_logits)*0.9,logits=real_logits))
    loss_d = loss_d_f + loss_d_r
    gen_optimizer = tf.train.AdamOptimizer(0.0002,beta1=0.5).minimize(loss_g,var_list=var_list_gen)
    dis_optimizer = tf.train.AdamOptimizer(0.0002,beta1=0.5).minimize(loss_d, var_list=var_list_dis)

with tf.Session() as sess:
    
    sess.run(tf.global_variables_initializer())
    
    coord = tf.train.Coordinator()
    threads = tf.train.start_queue_runners(sess=sess, coord=coord)
    writer = tf.summary.FileWriter('./graph/DCGAN',sess.graph)
    saver = tf.train.Saver()

       
    for epoch in range(epochs):
        total_g_loss = 0
        total_d_loss = 0
        KK = 0
        for batch in get_batch('./faces/',batch_size):

            x_real = batch
            x_real = x_real/127.5 - 1
            x_fake = np.random.uniform(-1,1,size=[batch_size,100])
            
            KK += 1
        

            _,tmp_loss_d= sess.run([dis_optimizer,loss_d],feed_dict={gen_input:x_fake,real_input:x_real})
         
            total_d_loss += tmp_loss_d

            _, tmp_loss_g = sess.run([gen_optimizer,loss_g],feed_dict={gen_input:x_fake})
            _, tmp_loss_g = sess.run([gen_optimizer,loss_g],feed_dict={gen_input:x_fake})
            total_g_loss += tmp_loss_g

        if epoch % 10 == 0:
            
            x_fake = np.random.uniform(-1,1,[64,100])

            samples = sess.run(gen_out,feed_dict={gen_input:x_fake})
            samples = (((samples - samples.min()) * 255) / (samples.max() - samples.min())).astype(np.uint8)
            
            vis_img(-1, [samples])
            
            print('epoch {},loss_g={}'.format(epoch, total_g_loss/2/KK))
            print('epoch {},loss_d={}'.format(epoch, total_d_loss/KK))

    writer.close()
    saver.save(sess, "./checkpoints/DCGAN")