GAN（初步学习）

最新推荐文章于 2024-03-07 17:55:11 发布

Java-浩浩

最新推荐文章于 2024-03-07 17:55:11 发布

阅读量1k

点赞数

本文链接：https://blog.csdn.net/weixin_46099084/article/details/109014267

版权

GAN的原理介绍

GAN的主要灵感来源于博弈论中零和博弈的思想，应用到深度学习神经网络上来说，就是**通过生成网络G（Generator）和判别网络D（Discriminator）不断博弈，进而使G学习到数据的分布**，如果用到图片生成上，则训练完成后，G可以从一段随机数中生成逼真的图像。G， D的主要功能是：

● G是一个生成式的网络，它接收一个随机的噪声z（随机数），通过这个噪声生成图像

● D是一个判别网络，判别一张图片是不是“真实的”。它的输入参数是x，x代表一张图片，输出D（x）代表x为真实图片的概率，如果为1，就代表100%是真实的图片，而输出为0，就代表不可能是真实的图片

训练过程中，生成网络G的目标就是尽量生成真实的图片去欺骗判别网络D。而D的目标就是尽量辨别出G生成的假图像和真实的图像。这样，G和D构成了一个动态的“博弈过程”，最终的平衡点即纳什均衡点.

损失函数

在这里插入图片描述

可以这样理解：损失函数做的是最大化D的区分度，最小化G输出和真实数据的区别。
损失函数可以拆分为两部分：
判别模型：log(D1(x))+log(1-D2(G(z)))…(1)生成模型：log(D2(G(z)))…(2)
当判别模型能力强时，D1(x)->1, D2(G(z))->0,(1)式趋近于0
当生成模型能力强时，D2(G(z))->1,(2)式趋近于0

一个简单的GAN案例

在这里插入图片描述

实现功能：上图中，蓝色线代表真实数据，绿色线代表生成网络输出数据，最终我们希望绿色线能和蓝色线能够比较接近

GAN是怎么训练呢

根据 GAN 的训练算法，我画一张图：

图片名称

GAN 的训练在同一轮梯度反传的过程中可以细分为 2 步，先训练 D 再训练 G；注意不是等所有的 D 训练好以后，才开始训练 G，因为 D 的训练也需要上一轮梯度反传中 G 的输出值作为输入。

当训练 D 的时候，上一轮 G 产生的图片，和真实图片，直接拼接在一起，作为 x。然后根据，按顺序摆放 0 和 1，假图对应 0，真图对应 1。然后就可以通过，x 输入生成一个 score（从 0 到 1 之间的数），通过 score 和 y 组成的损失函数，就可以进行梯度反传了。（我在图片上举的例子是 batch = 1，len(y)=2*batch，训练时通常可以取较大的 batch）

当训练 G 的时候，需要把 G 和 D 当作一个整体，我在这里取名叫做’D_on_G’。这个整体(下面简称 DG 系统)的输出仍然是 score。输入一组随机向量，就可以在 G 生成一张图，通过D 对生成的这张图进行打分，这就是 DG 系统的前向过程。score=1 就是 DG 系统需要优化的目标，score 和 y=1 之间的差异可以组成损失函数，然后可以反向传播梯度。注意，这里的 D 的参数是不可训练的。这样就能保证 G 的训练是符合 D 的打分标准的。这就好比：如果你参加考试，你别指望能改变老师的评分标准

GAN 的特点及优缺点：

特点

● 相比较传统的模型，他存在两个不同的网络，而不是单一的网络，并且训练方式采用的是对抗训练方式

● GAN中G的梯度更新信息来自判别器D，而不是来自数据样本

优点

● 相比其他所有模型, GAN可以产生更加清晰，真实的样本

●GAN采用的是一种无监督的学习方式训练，可以被广泛用在无监督学习和半监督学习领域

● GAN应用到一些场景上，比如图片风格迁移，图像补全，去噪，只要有一个的基准，直接用判别器，剩下的就交给对抗训练了。

缺点

● GAN不适合处理离散形式的数据，比如文本

● GAN存在训练不稳定、梯度消失、模式崩溃的问题（目前已解决）

训练GAN的一些技巧

输入规范化到（-1，1）之间，最后一层的激活函数使用tanh（BEGAN除外）
使用wassertein GAN的损失函数，
如果有标签数据的话，尽量使用标签，也有人提出使用反转标签效果很好，另外使用标签平滑，单边标签平滑或者双边标签平滑
使用mini-batch norm，如果不用batch norm 可以使用instance norm 或者weight norm
避免使用RELU和pooling层，减少稀疏梯度的可能性，可以使用leakrelu激活函数
优化器尽量选择ADAM，学习率不要设置太大，初始1e-4可以参考，另外可以随着训练进行不断缩小学习率，
给D的网络层增加高斯噪声，相当于是一种正则

代码部分

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

class GAN():
    def __init__(self):
        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)

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

        # Build the generator
        self.generator = self.build_generator()

        # The generator takes noise as input and generates imgs
        z = Input(shape=(self.latent_dim,))
        img = self.generator(z)

        # For the combined model we will only train the generator
        self.discriminator.trainable = False

        # The discriminator takes generated images as input and determines validity
        validity = self.discriminator(img)

        # The combined model  (stacked generator and discriminator)
        # Trains the generator to fool the discriminator
        self.combined = Model(z, 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(1024))
        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))

        model.summary()

        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'))
        model.summary()

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

        return Model(img, validity)

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

        # Load the dataset
        (X_train, _), (_, _) = mnist.load_data()

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

        # Adversarial ground truths
        valid = np.ones((batch_size, 1))
        fake = np.zeros((batch_size, 1))

        for epoch in range(epochs):

            # ---------------------
            #  Train Discriminator
            # ---------------------

            # Select a random batch of images
            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))

            # Generate a batch of new images
            gen_imgs = self.generator.predict(noise)

            # Train the discriminator
            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)

            # ---------------------
            #  Train Generator
            # ---------------------

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

            # Train the generator (to have the discriminator label samples as valid)
            g_loss = self.combined.train_on_batch(noise, valid)

            # Plot the progress
            print ("%d [D loss: %f, acc.: %.2f%%] [G loss: %f]" % (epoch, d_loss[0], 100*d_loss[1], g_loss))

            # If at save interval => save generated image samples
            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)

        # 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/%d.png" % epoch)
        plt.close()


if __name__ == '__main__':
    gan = GAN()
    gan.train(epochs=30000, batch_size=32, sample_interval=200)

参考文献：
https://blog.csdn.net/LEE18254290736/article/details/97371930
https://blog.csdn.net/leviopku/article/details/81292192
https://blog.csdn.net/weixin_43535573/article/details/89035764
深度学习GAN可参考李宏毅生成对抗网络学习：
https://blog.csdn.net/qq_35608277/article/details/83894943?utm_medium=distribute.pc_relevant_t0.none-task-blog-BlogCommendFromMachineLearnPai2-1.edu_weight&depth_1-utm_source=distribute.pc_relevant_t0.none-task-blog-BlogCommendFromMachineLearnPai2-1.edu_weight

Java-浩浩

关注

0
点赞
踩
5

收藏

觉得还不错? 一键收藏
0
评论
GAN（初步学习）

GAN的原理介绍GAN的主要灵感来源于博弈论中零和博弈的思想，应用到深度学习神经网络上来说，就是**通过生成网络G（Generator）和判别网络D（Discriminator）不断博弈，进而使G学习到数据的分布**，如果用到图片生成上，则训练完成后，G可以从一段随机数中生成逼真的图像。G， D的主要功能是： ● G是一个生成式的网络，它接收一个随机的噪声z（随机数），通过这个噪声生成图像 ● D是一个判别网络，判别一张图片是不是“真实的”。它的输
复制链接

扫一扫