深度学习-DCGAN试玩

GAN

简单讲下GAN原理，数学公式什么的就不贴了，有兴趣可以百度，很多的，有一定数学基础的可以去研究研究，那个是GAN的理论基础。

直觉的说，GAN就是生成东西，生成的东西是基于我给定的训练集的样本的分布，即我的让我的模型去学习我样本的分布，让他们尽可能接近，然后模型就可以生成同样分布的东西，因为理论上分布是连续的，所以可以无限生成不同的东西，服从同一分布。

二次元头像就是这个道理，我们从网上获取了一堆二次元头像，其实他是服从一个分布的，只是我们不知道，所以要让GAN去学，学了后就可以从这个分布里去生成图片了。

主要训练思路就是训练2个神经网络，一个是生成器，一个鉴别器，他们两个互相对抗，互相升级，用我们的老化就是道高一尺魔高一丈，最终达到平衡的状态。

举个比较好理解的假酒的例子


造假的人（生产者）刚开始肯定会先弄点乱七八糟的东西，希望混一起喝起来能跟酒一样，然后给别人（鉴别者）喝一口，好像跟真酒差距还挺大，那我继续研究怎么造假，直到最后给别人喝起来跟真的一样，别人就觉得这个就是真的，那就说明造假很成功，也就是别人看来就是真的，和真的酒是同一个分布了。

DCGAN

DCGAN是GAN的一个变种，原理一样的，只是训练的时候网络结构不一样，更加稳定，容易训练。比如用了反卷积，用了上采样，用了BN，leakyRelu，都是为了好训练，具体的可以去百度。

贴一个mnist手写字体的生成，用的是DCGAN，思路还是清晰的。
先训练鉴别者，给真实数据打标签1，生产的数据打0，始终让鉴别者能辨别真假，
然后训练生产者，给生产的数据打1，让生产者生产出来的数据能骗过鉴别者，最终鉴别者给出1，
然后鉴别者继续训练，提供鉴别能力，然后生产者也训练，提高造假能力，就这样循环，到一定阶段鉴别者就会把生产者生产出来的东西认为是真的，因为生产者已经近似达到真实样本的分布，抽样出来的就是真的了。

贴下代码，keras写的，jupyter上可以跑，我根据理解注释了下：

from __future__ import print_function, division

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 numpy as np

(X_train, _), (_, _) = mnist.load_data()
print(X_train.shape)

class DCGAN():
    def __init__(self):
        # 图片的行，列，通道，灰度就1个
        self.img_rows = 28
        self.img_cols = 28
        self.channels = 1
        self.img_shape = (self.img_rows, self.img_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()

        # 生产者的输入100维度的向量
        z = Input(shape=(self.latent_dim,))
        #输入向量输出图片
        img = self.generator(z)

        # 先训练生产者，不训练鉴别者
        self.discriminator.trainable = False

        # 鉴别者通过生产者的图片来进行鉴别
        valid = self.discriminator(img)

        # 将生产者和鉴别者模型连起来
        self.combined = Model(z, valid)
        self.combined.compile(loss='binary_crossentropy', optimizer=optimizer)

    def build_generator(self):

        model = Sequential()

        model.add(Dense(128 * 7 * 7, activation="relu", input_dim=self.latent_dim))
        model.add(Reshape((7, 7, 128)))
        model.add(UpSampling2D())
        model.add(Conv2D(128, kernel_size=3, padding="same"))
        model.add(BatchNormalization(momentum=0.8))
        model.add(Activation("relu"))
        model.add(UpSampling2D())
        model.add(Conv2D(64, kernel_size=3, padding="same"))
        model.add(BatchNormalization(momentum=0.8))
        model.add(Activation("relu"))
        model.add(Conv2D(self.channels, kernel_size=3, padding="same"))
        model.add(Activation("tanh"))

        model.summary()

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

        return Model(noise, img)

    def build_discriminator(self):

        model = Sequential()

        model.add(Conv2D(32, kernel_size=3, strides=2, input_shape=self.img_shape, padding="same"))
        model.add(LeakyReLU(alpha=0.2))
        model.add(Dropout(0.25))
        model.add(Conv2D(64, kernel_size=3, strides=2, padding="same"))
        model.add(ZeroPadding2D(padding=((0,1),(0,1))))
        model.add(BatchNormalization(momentum=0.8))
        model.add(LeakyReLU(alpha=0.2))
        model.add(Dropout(0.25))
        model.add(Conv2D(128, kernel_size=3, strides=2, padding="same"))
        model.add(BatchNormalization(momentum=0.8))
        model.add(LeakyReLU(alpha=0.2))
        model.add(Dropout(0.25))
        model.add(Conv2D(256, kernel_size=3, strides=1, padding="same"))
        model.add(BatchNormalization(momentum=0.8))
        model.add(LeakyReLU(alpha=0.2))
        model.add(Dropout(0.25))
        model.add(Flatten())
        model.add(Dense(1, activation='sigmoid'))

        model.summary()

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

        return Model(img, validity)

    def train(self, epochs, batch_size=128, save_interval=50):

        # 加载训练集， 60000个 28 x 28
        (X_train, _), (_, _) = mnist.load_data()

        # 归一化-1 到 1
        X_train = X_train / 127.5 - 1.
        #添加1维数据,图片是灰度所以是1个通道
        X_train = np.expand_dims(X_train, axis=3)

        # 给数据打标签 一半 1 一半 0
        valid = np.ones((batch_size, 1))
        fake = np.zeros((batch_size, 1))

        for epoch in range(epochs):

            # ---------------------
            #  训练鉴别者
            # ---------------------

            # 从0-59999里获取batch_size个随机数
            idx = np.random.randint(0, X_train.shape[0], batch_size)
#             print('idx:',idx.shape)
            #从X_train获取相应的数据 img 维度 batch_size x 28 x 28 x 1
            imgs = X_train[idx]
#             print('imgs:',imgs.shape)

            # 采样batch_size 个 latent_dim维度的噪声 batch_size x latent_dim
            noise = np.random.normal(0, 1, (batch_size, self.latent_dim))
#             print('noise:',noise.shape)
            #生产者生产采样batch_size个图片 batch_size x 28 x 28 x 1
            gen_imgs = self.generator.predict(noise)
#             print('gen_imgs:',gen_imgs.shape)

            # 训练鉴别者,因为有2部分数据，所以都要训练，然后求平均损失,真实数据设为1 生产的数据为0
            d_loss_real = self.discriminator.train_on_batch(imgs, valid)
            d_loss_fake = self.discriminator.train_on_batch(gen_imgs, fake)
            d_loss = 0.5 * np.add(d_loss_real, d_loss_fake)

            # ---------------------
            #  训练生产者
            # ---------------------

            # 训练生产者，让生产者的标签都为1
            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))

            # 每save_interval轮保存图片
            if epoch % save_interval == 0:
                self.save_imgs(epoch)

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

        # Rescale images 0 - 1
        gen_imgs = 0.5 * gen_imgs + 0.5

        fig, axs = plt.subplots(r, c)
        cnt = 0
        for i in range(r):
            for j in range(c):
                axs[i,j].imshow(gen_imgs[cnt, :,:,0], cmap='gray')
                axs[i,j].axis('off')
                cnt += 1
        fig.savefig("images/mnist_%d.png" % (epoch//50))
        plt.close()
 

dcgan = DCGAN()
dcgan.train(epochs=4000, batch_size=32, save_interval=50)

很多GAN的keras实现集合github

好了，今天就到这里了，希望对学习理解有帮助，大神看见勿喷，仅为自己的学习理解，能力有限，请多包涵，部分图片来自网络，侵删。