关于GAN

 

可以看出，GAN分为两个网络：

（1）一个生成网络（generator）,用来从随机输入（z）制作假的数据集；

（2）一个判别网络（discriminator）用来区分真假图片；

---

 

---

假设真实图片为x, 则分类器对真实图片的分类结果为D（x）；噪声为z,生成的假图片为G（z）,分类器对假图片的分类结果为D(G(z))

假设真实样本的label为1， 生成的假图片为0

在训练阶段， 生成网络和判别网络交替训练

（1）固定判别网络，训练生成网络。此时目的是训练生成器，让生成的假的样本通过判别器后（判别器参数固定），让其被判别器误认为真实图片。

       此时的loss 为：-log(D(G(z)))  (注，此时D固定，优化G）

（1）固定生成网络，训练判别网络。此时的目的是训练判别器。我们希望判别器把生成假图片尽可能的认为是真图片， 而把真图片认为是生成的假图片，

      此时的loss 为：- [ log(1 - D(G(z))) + log(D(G(x))) ]   (注，此时G固定，优化D）

 

下面是关于mnist的代码：

import numpy as np
import tensorflow as tf
from tensorflow.examples.tutorials.mnist import input_data
import matplotlib.pyplot as plt
import os
import matplotlib.gridspec as gridspec
######################
''' label for fake image is 0, for real image is 1'''

mnist = input_data.read_data_sets('MNIST_data', one_hot=True)
iterations = 100000
batch_size = 128
noise_dim = 100

######################sample generation
def sample_Z(m, n):
    '''
    generate noise sample
    :param m: batch_size
    :param n:
    :return:
    '''
    return np.random.uniform(-1., 1., size=[m, n])

#################net parameters
Gw1 = tf.get_variable(name='Gw1', shape=[noise_dim, 128], dtype=tf.float32, initializer=tf.contrib.layers.xavier_initializer())
Gw2 = tf.get_variable(name='Gw2', shape=[128, 784], dtype=tf.float32, initializer=tf.contrib.layers.xavier_initializer())
Gb1 = tf.get_variable(name='Gb1', shape=[128], dtype=tf.float32, initializer=tf.constant_initializer(0))
Gb2 = tf.get_variable(name='Gb2', shape=[784], dtype=tf.float32, initializer=tf.constant_initializer(0))
params_G = [Gw1, Gw2, Gb1, Gb2]
Z = tf.placeholder(tf.float32, shape=[None, noise_dim], name='Z')

Dw1 = tf.get_variable(name='Dw1', shape=[784, 128], dtype=tf.float32, initializer=tf.contrib.layers.xavier_initializer())
Dw2 = tf.get_variable(name='Dw2', shape=[128, 1], dtype=tf.float32, initializer=tf.contrib.layers.xavier_initializer())
Db1 = tf.get_variable(name='Db1', shape=[128], dtype=tf.float32, initializer=tf.constant_initializer(0))
Db2 = tf.get_variable(name='Db2', shape=[1], dtype=tf.float32, initializer=tf.constant_initializer(0))
params_D = [Dw1, Dw2, Db1, Db2]
X = tf.placeholder(tf.float32, shape=[None, 784], name='X')


#################generation net

def generator(z1):

    z2 = tf.nn.relu(tf.matmul(z1, Gw1) + Gb1)
    G_prob = tf.nn.sigmoid(tf.matmul(z2, Gw2) + Gb2)
    return G_prob


#################discrimination net

def discriminator(x1):

    x2 = tf.nn.relu(tf.matmul(x1, Dw1) + Db1)
    D_prob = tf.nn.sigmoid(tf.matmul(x2, Dw2) + Db2)
    return D_prob

G_sample = generator(Z)
G_loss = -tf.reduce_mean(tf.log(discriminator(generator(Z))))
D_loss = -tf.reduce_mean(tf.log(1. - discriminator(generator(Z))) + tf.log(discriminator(X)))
G_optimizer = tf.train.AdamOptimizer(0.001).minimize(G_loss, var_list=params_G)
D_optimizer = tf.train.AdamOptimizer(0.001).minimize(D_loss, var_list=params_D)






#############################################
def plot(samples):
    fig = plt.figure(figsize=(4, 4))
    gs = gridspec.GridSpec(4, 4)
    gs.update(wspace=0.05, hspace=0.05)

    for i, sample in enumerate(samples):  # [i,samples[i]] imax=16
        ax = plt.subplot(gs[i])
        plt.axis('off')
        ax.set_xticklabels([])
        ax.set_aspect('equal')
        plt.imshow(sample.reshape(28, 28), cmap='Greys_r')

    return fig



if not os.path.exists('out/'):
    os.makedirs('out/')


j = 0
with tf.Session() as sess:
    sess.run(tf.initialize_all_variables())
    for i in range(1000000):
        lossG, _ = sess.run([G_loss, G_optimizer], feed_dict={Z: sample_Z(batch_size, noise_dim)})
        lossD, _ = sess.run([D_loss, D_optimizer], feed_dict={Z: sample_Z(batch_size, noise_dim), X: mnist.train.next_batch(batch_size)[0]})

        if (i+1)%200 == 0:
            samples = sess.run(G_sample, feed_dict={
                Z: sample_Z(16, noise_dim)})  # 16*784
            fig = plot(samples)
            plt.savefig('out/{}.png'.format(str(j).zfill(3)), bbox_inches='tight')
            j += 1
            plt.close(fig)
            print('iters is %d, lossG is %4f, lossD is %4f'%(i, lossG, lossD))

参考网页

https://zhuanlan.zhihu.com/p/24767059

https://blog.csdn.net/u012223913/article/details/75051516

https://blog.csdn.net/on2way/article/details/72773771

https://blog.csdn.net/sxf1061926959/article/details/54630462