2019-3-10——生成對抗網絡GAN---生成mnist手寫數字圖像

"""
生成對抗網絡（GAN，Generative Adversarial Networks）的基本原理很簡單：
假設有兩個網絡，生成網絡G和判別網絡D。生成網絡G接受一個隨機的噪聲z並生成圖片，
記為G（z）；判別網絡D的作用是判別一張圖片x是否真實，對於輸入x，D(x)是x為真實圖片的概率。
在訓練過程中， 生成器努力讓生成的圖片更加真實從而使得判別器無法辨別圖像的真假，
而D的目標就是盡量把分辨出真實圖片和生成網絡G產出的圖片，這個過程就類似於二人博弈，
G和D構成了一個動態的“博弈過程”。隨着時間的推移，生成器和判別器在不斷地進行對抗，
最終兩個網絡達到一個動態平衡：生成器生成的圖像G(z)接近於真實圖像分布，而判別器識別不出真假圖像，
即D（G(z)）=0.5。最后，我們就可以得到一個生成網絡G，用來生成圖片。
"""
import tensorflow as tf
from matplotlib import pyplot as plt
import os
import numpy as np
from tensorflow.examples.tutorials.mnist import input_data
mnist=input_data.read_data_sets('/MNIST_data/',one_hot=True)
batch_size=64
units_size=128
learning_rate=0.001
epoch=300
smooth=0.1
"""定義生成模型"""
def generatorModel(noise_img,units_size,out_size,alpha=0.01):
    """生成器的目的是：對於生成的圖片，G希望D打上標簽1"""
    with tf.variable_scope('generator'):
        FC=tf.layers.dense(noise_img,units_size)
        relu=tf.nn.leaky_relu(FC,alpha)
        drop=tf.layers.dropout(relu,rate=0.2)
        logits=tf.layers.dense(drop,out_size)
        outputs=tf.tanh(logits)
        return logits,outputs

"""定義判別模型"""
def discriminatorModel(images,unite_size,alpha=0.01,reuse=False):
    """
    判別器的目的是：
    1. 對於真實圖片，D要為其打上標簽1
    2. 對於生成圖片，D要為其打上標簽0
    """
    with tf.variable_scope('discriminator',reuse=reuse):
        FC=tf.layers.dense(images,units_size)
        relu=tf.nn.leaky_relu(FC,alpha)
        logits=tf.layers.dense(relu,1)
        outputs=tf.sigmoid(logits)
        return logits,outputs
"""定義損失函數"""
def loss_fenction(real_logits,fake_logits,smooth):
    """生成器希望判別器判別出來的標簽為1; tf.ones_like()創建一個將所有元素都設置為1的張量"""
    G_loss=tf.reduce_mean(tf.nn.sigmoid_cross_entropy_with_logits(
        logits=fake_logits,
        labels=tf.ones_like(fake_logits)*(1-smooth))
    )
    """判別器識別生成器產出的圖片，希望識別出來的標簽為0;tf.zeros_like()創建一個將所有元素都設置為0的張量"""
    fake_loss=tf.reduce_mean(tf.nn.sigmoid_cross_entropy_with_logits(
        logits=fake_logits,
        labels=tf.zeros_like(fake_logits))
    )
    """判別器判別真實圖片，希望判別出來的標簽為1;tf.ones_like()創建一個將所有元素都設置為1的張量"""
    real_loss=tf.reduce_mean(tf.nn.sigmoid_cross_entropy_with_logits(
        logits=real_logits,
        labels=tf.ones_like(real_logits)*(1-smooth))
    )
    D_loss=tf.add(fake_loss,real_loss)
    return G_loss,fake_loss,real_loss,D_loss
"""定義優化器"""
def optimizer(G_loss,D_loss,learning_rate):
    """因為GAN中一共訓練了兩個網絡，所以分別對G和D進行優化"""
    train_var=tf.trainable_variables()   #需要訓練的變量
    G_var=[var for var in train_var if var.name.startswith('generator')]
    D_var=[var for var in train_var if var.name.startswith('discriminator')]
    G_optimizer=tf.train.AdadeltaOptimizer(learning_rate).minimize(G_loss,var_list=G_var)
    D_optimizer=tf.train.AdadeltaOptimizer(learning_rate).minimize(D_loss,var_list=D_var)
    return G_optimizer,D_optimizer
"""訓練"""
def train(mnist):
    image_size = mnist.train.images[0].shape[0]
    real_images = tf.placeholder(tf.float32,[None,image_size])
    fake_images = tf.placeholder(tf.float32,[None,image_size])
    """調用生成模型生成假圖片G_output"""
    G_logits,G_output = generatorModel(fake_images,units_size,image_size)
    """D對真實圖像的判別"""
    real_logits,real_output = discriminatorModel(real_images,units_size)
    """D對G生成圖像的判別"""
    fake_logits,fake_output=discriminatorModel(G_output,units_size,reuse=True)
    G_loss,real_loss,fake_loss,D_loss=loss_fenction(real_logits,fake_logits,smooth)
    G_optimizer,D_optimizer=optimizer(G_loss,D_loss,learning_rate)

    saver=tf.train.Saver()
    step=0
    with tf.Session() as session:
        session.run(tf.global_variables_initializer())
        for Epoch in range(epoch):
            for batch_i in range(mnist.train.num_examples//batch_size):
                batch_image,_=mnist.train.next_batch(batch_size)
                """對圖像像素進行scale，tanh的輸出結果為(-1,1)"""
                batch_image=batch_image*2-1
                """模型的輸入噪聲"""
                noise_image=np.random.uniform(-1,1,size=(batch_size,image_size))#從均勻分布[-1,1)中隨機采樣
                session.run(G_optimizer,feed_dict={fake_images:noise_image})
                session.run(D_optimizer,feed_dict={real_images:batch_image,fake_images:noise_image})
                step=step+1
                loss_D= session.run(D_loss, feed_dict={real_images: batch_image, fake_images: noise_image})
                loss_real= session.run(real_loss, feed_dict={real_images: batch_image, fake_images: noise_image})
                loss_fake= session.run(fake_loss, feed_dict={real_images: batch_image, fake_images: noise_image})
                loss_G= session.run(G_loss, feed_dict={fake_images: noise_image})
            print('epoch:', Epoch, 'loss_D:', loss_D,'loss_real', loss_real,'loss_fake', loss_fake, 'loss_G',  loss_G)
            model_path=os.getcwd()+os.sep+"mnist.model"
            saver.save(session,model_path,global_step=step)
"""定義主函數"""
def main(argv=None):
    train(mnist)
if __name__ =='__main__':
    tf.app.run()

 

import tensorflow as tf
import numpy as np
from matplotlib import pyplot as plt
import pickle
import example88_0

UNITS_SIZE = example88_0.units_size


def generatorImage(image_size):
    sample_images = tf.placeholder(tf.float32, [None, image_size])
    G_logits, G_output = example88_0.generatorModel(sample_images, UNITS_SIZE, image_size)
    saver = tf.train.Saver()
    with tf.Session() as session:
        session.run(tf.global_variables_initializer())
        saver.restore(session, tf.train.latest_checkpoint('.'))
        sample_noise = np.random.uniform(-1, 1, size=(25, image_size))
        samples = session.run(G_output, feed_dict={sample_images: sample_noise})
    with open('samples.pkl', 'wb') as f:
        pickle.dump(samples, f)


def show():
    with open('samples.pkl', 'rb') as f:
        samples = pickle.load(f)
    fig, axes = plt.subplots(figsize=(7, 7), nrows=5, ncols=5, sharey=True, sharex=True)
    for ax, image in zip(axes.flatten(), samples):
        ax.xaxis.set_visible(False)
        ax.yaxis.set_visible(False)
        ax.imshow(image.reshape((28, 28)), cmap='Greys_r')
    plt.show()


def main(argv=None):
    image_size = example88_0.mnist.train.images[0].shape[0]
    generatorImage(image_size)
    show()


if __name__ == '__main__':
    tf.app.run()