GAN

带泄露修正线性单元（Leaky ReLU）

Dropout
Dropout 的工作原理是我们在前向传播的时候，让某个神经元的**值以一定的概率停止工作，这样可以使模型泛化性更强，因为它不会太依赖某些局部的特征

Batch Normallzatlon
Batch Normalization就是在深度神经网络训练过程中使得每一层神经网络的输入保持相同分布。

用大白话描述就是，计算出当前batch的每个channel的均值mean，计算出当前batch的每个channel的方差variance，令输入减去均值再除以标准差delta，得到normalized输出x-hat，最后乘以scale参数gamma，加上shift参数beta，得到最终变换后的输出y。

Adam

二元交叉熵

model.train_on_batch() 在训练集数据的一批数据上进行训练
train_on_batch(x, y, sample_weight=None, class_weight=None)

# -*- coding: UTF-8 -*-
#@Time : 2020/3/3 @Author : SUNLIN
from keras.datasets import mnist
from keras.layers import Input,Dense,Reshape,Flatten,Dropout
from keras.layers import BatchNormalization,Activation,ZeroPadding2D
from keras.layers.advanced_activations import LeakyReLU
from keras.layers.convolutional import UpSampling2D,Conv2D
from keras.models import Sequential,Model
from keras.optimizers import Adam

import matplotlib.pyplot as plt

import sys
import os
import numpy as np

class GAN():
    def __init__(self):
        self.img_row=28
        self.im_cols=28
        self.channels=1

        self.img_shape=(self.img_row,self.im_cols,self.channels)
        self.latent_dim=100

        optimizer=Adam(0.0002,0.5)

        self.discriminator=self.build_discriminator()
        self.discriminator.compile(loss='binary_crossentropy',
                                   optimizer=optimizer,
                                   metrics=['accuracy'])

        self.generator=self.build_generator()
        gan_input=Input(shape=(self.latent_dim,))
        img=self.generator(gan_input)
        # 在训练generate的时候不训练discriminator
        #判别器discriminator只训练判别器的参数；生成器的训练
        #是把生成器和判别器两个网络连在一起，一起组成combined
        self.discriminator.trainable=False
        validity=self.discriminator(img)
        self.combined=Model(gan_input,validity)
        self.combined.compile(loss='binary_crossentropy',optimizer=optimizer)

    def build_generator(self):
        model=Sequential()

        model.add(Dense(256,input_dim=self.latent_dim))
        model.add(LeakyReLU(alpha=0.2))
        model.add(BatchNormalization(momentum=0.8))

        model.add(Dense(512))
        model.add(LeakyReLU(alpha=0.2))
        model.add(BatchNormalization(momentum=0.8))

        model.add(Dense(np.prod(self.img_shape),activation='tanh'))
        model.add(Reshape(self.img_shape))

        noise=Input(shape=(self.latent_dim,))
        img=model(noise)

        return Model(noise,img)

    def build_discriminator(self):
        model=Sequential()
        model.add(Flatten(input_shape=self.img_shape))
        model.add(Dense(512))
        model.add(LeakyReLU(alpha=0.2))
        model.add(Dense(256))
        model.add(LeakyReLU(alpha=0.2))
        model.add(Dense(1,activation='sigmoid'))

        img=Input(shape=self.img_shape)
        validity=model(img)

        return Model(img,validity)

    def train(self,epochs,batch_size,sample_interval=50):

        path = './mnist.npz'
        f = np.load(path)
        X_train, y_train = f['x_train'], f['y_train']
        x_test, y_test = f['x_test'], f['y_test']
        print(X_train.shape)


        # (X_train,_),(_,_)=mnist.load_data()

        X_train=X_train/127.5-1.
        X_train=np.expand_dims(X_train,axis=3)

        valid=np.ones((batch_size,1))
        fake=np.zeros((batch_size,1))

        for epoch in range(epochs):
            idx=np.random.randint(0,X_train.shape[0],batch_size)
            imgs=X_train[idx]

            noise=np.random.normal(0,1,(batch_size,self.latent_dim))

            gen_imgs=self.generator.predict(noise)

            d_loss_real=self.discriminator.train_on_batch(imgs,valid)
            d_loss_fake=self.discriminator.train_on_batch(noise,fake)
            d_loss=0.5*np.add(d_loss_real+d_loss_fake)

            noise=np.random.normal(0,1,(batch_size,self.latent_dim))
            g_loss=self.combined.train_on_batch(noise,valid)
            print ("%d [D loss: %f, acc.: %.2f%%] [G loss: %f]" % (epoch, d_loss[0], 100*d_loss[1], g_loss))

            if epoch%sample_interval==0:
                self.sample_images(epoch)

    def sample_images(self,epoch):
        r,c=5,5
        noise=np.random.normal(0,1,(r*c,self.latent_dim))
        gen_imgs=self.generator.predict(noise)

        gen_imgs=0.5*gen_imgs+0.5
        cnt=0

        fig,axs=plt.subplot(r,c)
        for i in range(r):
            for j in range(c):
                axs[i,j].imshow(gen_imgs[cnt,:,:,0],cmp='gray')
                axs.axis('off')
                cnt+=1
        fig.savefig('imges/%d.png' %epoch)
        plt.close()

if __name__=='__main__':
    if not  os.path.exists('./images'):
        os.makedirs('./images')
    gan=GAN()
    gan.train(epochs=30000,batch_size=256,sample_interval=200)

参考：
矩池云 | 条件生成对抗模型生成数字图片
Batch Normalization的正确打开方式
Keras搭建简单GAN生成MNIST手写体
Keras中如何解决MNIST数据集无法下载的问题