gan_ganglia - CSDN
gan 订阅
氮化镓,化学式GaN,英文名称Gallium nitride,是氮和镓的化合物,是一种直接能隙(direct bandgap)的半导体,自1990年起常用在发光二极管中。此化合物结构类似纤锌矿,硬度很高。氮化镓的能隙很宽,为3.4电子伏特,可以用在高功率、高速的光电元件中,例如氮化镓可以用在紫光的激光二极管,可以在不使用非线性半导体泵浦固体激光器(Diode-pumped solid-state laser)的条件下,产生紫光(405nm)激光。2014年,日本名古屋大学和名城大学教授赤崎勇、名古屋大学教授天野浩和美国加州大学圣塔芭芭拉分校教授中村修二因发明蓝光LED而获的当年的诺贝尔物理奖。 [1-3] 展开全文
氮化镓,化学式GaN,英文名称Gallium nitride,是氮和镓的化合物,是一种直接能隙(direct bandgap)的半导体,自1990年起常用在发光二极管中。此化合物结构类似纤锌矿,硬度很高。氮化镓的能隙很宽,为3.4电子伏特,可以用在高功率、高速的光电元件中,例如氮化镓可以用在紫光的激光二极管,可以在不使用非线性半导体泵浦固体激光器(Diode-pumped solid-state laser)的条件下,产生紫光(405nm)激光。2014年,日本名古屋大学和名城大学教授赤崎勇、名古屋大学教授天野浩和美国加州大学圣塔芭芭拉分校教授中村修二因发明蓝光LED而获的当年的诺贝尔物理奖。 [1-3]
信息
化学式
GaN
英文名
gallium nitride
CAS登录号
25617-97-4
中文名
氮化镓
EINECS登录号
247-129-0
分子量
83.73
氮化镓基本信息
中文名称:氮化镓英文名称:gallium(iii) nitride英文别名:Gallium nitride; nitridogallium; gallium nitrogen(-3) anion分子量:83.7297熔点:1700℃密度:6.1g/mL,25/4℃
收起全文
精华内容
参与话题
  • 深度学习----GAN(生成对抗神经网络)原理解析

    万次阅读 多人点赞 2019-03-01 16:12:40
    1.1、 GAN的原理: 1.2、架构 1.3、 GAN 的特点及优缺点: 二、为什么GAN中的优化器不常用SGD 三、为什么GAN不适合处理文本数据 四、训练GAN的一些技巧 五、GAN的广泛应用 一、原理...


    欢迎来到我的目录页:https://blog.csdn.net/Sakura55/article/details/80678611


    一、原理部分

    首先附上一张流程图
    这里写图片描述

    1.1、 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构成了一个动态的“博弈过程”,最终的平衡点即纳什均衡点.

    1.2、架构

    这里写图片描述

          ~~~~~~通过优化目标,使得我们可以调节概率生成模型的参数\theta,从而使得生成的概率分布和真实数据分布尽量接近。

          ~~~~~~那么怎么去定义一个恰当的优化目标或一个损失?传统的生成模型,一般都采用数据的似然性来作为优化的目标,但GAN创新性地使用了另外一种优化目标。首先,它引入了一个判别模型(常用的有支持向量机和多层神经网络)。其次,它的优化过程就是在寻找生成模型和判别模型之间的一个纳什均衡。

          ~~~~~~GAN所建立的一个学习框架,实际上就是生成模型和判别模型之间的一个模仿游戏。**生成模型的目的,就是要尽量去模仿、建模和学习真实数据的分布规律;而判别模型则是要判别自己所得到的一个输入数据,究竟是来自于真实的数据分布还是来自于一个生成模型。**通过这两个内部模型之间不断的竞争,从而提高两个模型的生成能力和判别能力。

    这里写图片描述

           ~~~~~~~当一个判别模型的能力已经非常强的时候,如果生成模型所生成的数据,还是能够使它产生混淆,无法正确判断的话,那我们就认为这个生成模型实际上已经学到了真实数据的分布。

    1.3、 GAN 的特点及优缺点:

    特点

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

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

    优点

    (以下部分摘自ian goodfellow 在Quora的问答)

              ~~~~~~~~~~● GAN是一种生成式模型,相比较其他生成模型(玻尔兹曼机和GSNs)只用到了反向传播,而不需要复杂的马尔科夫链

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

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

              ~~~~~~~~~~● 相比于变分自编码器, GANs没有引入任何决定性偏置( deterministic bias),变分方法引入决定性偏置,因为他们优化对数似然的下界,而不是似然度本身,这看起来导致了VAEs生成的实例比GANs更模糊

              ~~~~~~~~~~● 相比VAE, GANs没有变分下界,如果鉴别器训练良好,那么生成器可以完美的学习到训练样本的分布.换句话说,GANs是渐进一致的,但是VAE是有偏差的

              ~~~~~~~~~~● GAN应用到一些场景上,比如图片风格迁移,超分辨率,图像补全,去噪,避免了损失函数设计的困难,不管三七二十一,只要有一个的基准,直接上判别器,剩下的就交给对抗训练了。

    缺点

              ~~~~~~~~~~● 训练GAN需要达到纳什均衡,有时候可以用梯度下降法做到,有时候做不到.我们还没有找到很好的达到纳什均衡的方法,所以训练GAN相比VAE或者PixelRNN是不稳定的,但我认为在实践中它还是比训练玻尔兹曼机稳定的多

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

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


    附:模式崩溃(model collapse)原因

              ~~~~~~~~~~一般出现在GAN训练不稳定的时候,具体表现为生成出来的结果非常差,但是即使加长训练时间后也无法得到很好的改善。

              ~~~~~~~~~~具体原因可以解释如下:
              ~~~~~~~~~~GAN采用的是对抗训练的方式,G的梯度更新来自D,所以G生成的好不好,得看D怎么说。具体就是G生成一个样本,交给D去评判,D会输出生成的假样本是真样本的概率(0-1),相当于告诉G生成的样本有多大的真实性,G就会根据这个反馈**不断改善自己,提高D输出的概率值**。但是如果某一次G生成的样本可能并不是很真实,但是D给出了正确的评价,或者是G生成的结果中一些特征得到了D的认可,这时候G就会认为我输出的正确的,那么接下来我就这样输出肯定D还会给出比较高的评价,实际上G生成的并不怎么样,但是他们两个就这样自我欺骗下去了,导致最终生成结果缺失一些信息,特征不全。
    这里写图片描述

                                             ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~局部极小值点

    这里写图片描述

                         ~~~~~~~~~~~~~~~~~~~~~鞍点

    二、为什么GAN中的优化器不常用SGD

    1. SGD容易震荡,容易使GAN训练不稳定,

    2. GAN的目的是在高维非凸的参数空间中找到纳什均衡点,GAN的纳什均衡点是一个鞍点,但是SGD只会找到局部极小值,因为SGD解决的是一个寻找最小值的问题,GAN是一个博弈问题。

    三、为什么GAN不适合处理文本数据

    1. 文本数据相比较图片数据来说是离散的,因为对于文本来说,通常需要将一个词映射为一个高维的向量,最终预测的输出是一个one-hot向量,假设softmax的输出是(0.2, 0.3, 0.1,0.2,0.15,0.05)那么变为onehot是(0,1,0,0,0,0),如果softmax输出是(0.2, 0.25, 0.2, 0.1,0.15,0.1 ),one-hot仍然是(0, 1, 0, 0, 0, 0),所以对于生成器来说,G输出了不同的结果但是D给出了同样的判别结果,并不能将梯度更新信息很好的传递到G中去,所以D最终输出的判别没有意义。

    2. 另外就是GAN的损失函数是JS散度,JS散度不适合衡量不想交分布之间的距离。

    (WGAN虽然使用wassertein距离代替了JS散度,但是在生成文本上能力还是有限,GAN在生成文本上的应用有seq-GAN,和强化学习结合的产物)

    四、训练GAN的一些技巧

    1. 输入规范化到(-1,1)之间,最后一层的激活函数使用tanh(BEGAN除外)

    2. 使用wassertein GAN的损失函数,

    3. 如果有标签数据的话,尽量使用标签,也有人提出使用反转标签效果很好,另外使用标签平滑,单边标签平滑或者双边标签平滑

    4. 使用mini-batch norm, 如果不用batch norm 可以使用instance norm 或者weight norm

    5. 避免使用RELU和pooling层,减少稀疏梯度的可能性,可以使用leakrelu激活函数

    6. 优化器尽量选择ADAM,学习率不要设置太大,初始1e-4可以参考,另外可以随着训练进行不断缩小学习率,

    7. 给D的网络层增加高斯噪声,相当于是一种正则

    GAN的变种

    自从GAN出世后,得到了广泛研究,先后几百篇不同的GANpaper横空出世,国外有大神整理了一个GAN zoo(GAN动物园),链接如下,感兴趣的可以参考一下:

    https://github.com/hindupuravinash/the-gan-zoo

    GitHub上已经1200+star了,顺便附上一张GAN的成果图,可见GAN的研究火热程度:

    五、GAN的广泛应用

    1. GAN本身是一种生成式模型,所以在数据生成上用的是最普遍的,最常见的是图片生成,常用的有DCGAN WGAN,BEGAN,个人感觉在BEGAN的效果最好而且最简单。

    2. GAN本身也是一种无监督学习的典范,因此它在无监督学习,半监督学习领域都有广泛的应用

    3. 不仅在生成领域,GAN在分类领域也占有一席之地,简单来说,就是替换判别器为一个分类器,做多分类任务,而生成器仍然做生成任务,辅助分类器训练。

    4. GAN可以和强化学习结合,目前一个比较好的例子就是seq-GAN

    5. 目前比较有意思的应用就是GAN用在**图像风格迁移,图像降噪修复,图像超分辨率了,都有比较好的结果**。

    6. 目前也有研究者将GAN用在对抗性攻击上,具体就是训练GAN生成对抗文本,有针对或者无针对的欺骗分类器或者检测系统等等,但是目前没有见到很典范的文章。


    参考文献:

    https://github.com/hindupuravinash/the-gan-zoo
    https://blog.csdn.net/qq_25737169/article/details/78857724#t0
    https://www.jianshu.com/p/80bd4d4c2992

    展开全文
  • GAN网络详解(从零入门)

    万次阅读 多人点赞 2019-07-30 10:13:02
    从一个小白的方式理解GAN网络(生成对抗网络),可以认为是一个造假机器,造出来的东西跟真的一样,下面开始讲如何造假:(主要讲解GAN代码,代码很简单) 我们首先以造小狗的假图片为例。 首先需要一个生成小狗...

    从一个小白的方式理解GAN网络(生成对抗网络),可以认为是一个造假机器,造出来的东西跟真的一样,下面开始讲如何造假:(主要讲解GAN代码,代码很简单)

    我们首先以造小狗的假图片为例。

    首先需要一个生成小狗图片的模型,我们称之为generator,还有一个判断小狗图片是否是真假的判别模型discrimator,

    首先输入一个1000维的噪声,然后送入生成器,生成器的具体结构如下所示(不看也可以,看完全篇回来再看也一样):

    其实比较简单,代码如下所示:

    def generator_model():
        model = Sequential()
        model.add(Dense(input_dim=1000, output_dim=1024))
        model.add(Activation('tanh'))
        model.add(Dense(128 * 8 * 8))
        model.add(BatchNormalization())
        model.add(Activation('tanh'))
        model.add(Reshape((8, 8, 128), input_shape=(8 * 8 * 128,)))
        model.add(UpSampling2D(size=(4, 4)))
        model.add(Conv2D(64, (5, 5), padding='same'))
        model.add(Activation('tanh'))
        model.add(UpSampling2D(size=(2, 2)))
        model.add(Conv2D(3, (5, 5), padding='same'))
        model.add(Activation('tanh'))
        return model

    生成器接受一个1000维的随机生成的数组,然后输出一个64×64×3通道的图片数据。输出就是一个图片。不必太过深究,输入是1000个随机数字,输出是一张图片。

     

    下面再看判别器代码与结构:

    代码如下所示:

    
    def discriminator_model():
        model = Sequential()
        model.add(Conv2D(64, (5, 5), padding='same', input_shape=(64, 64, 3)))
        model.add(Activation('tanh'))
        model.add(MaxPooling2D(pool_size=(2, 2)))
        model.add(Conv2D(128, (5, 5)))
        model.add(Activation('tanh'))
        model.add(MaxPooling2D(pool_size=(2, 2)))
        model.add(Flatten())
        model.add(Dense(1024))
        model.add(Activation('tanh'))
        model.add(Dense(1))
        model.add(Activation('sigmoid'))
        return model

    输入是64,64,3的图片,输出是一个数1或者0,代表图片是否是狗。

    下面根据代码讲具体操作:

    把真图与假图。进行拼接,然后打上标签,真图标签是1,假图标签是0,送入训练的网络。

    # 随机生成的1000维的噪声
    noise = np.random.uniform(-1, 1, size=(BATCH_SIZE, 1000))
    
    # X_train是训练的图片数据,这里取出一个batchsize的图片用于训练,这个是真图(64张)
    image_batch = X_train[index * BATCH_SIZE:(index + 1) * BATCH_SIZE]
    
    # 这里是经过生成器生成的假图
    generated_images = generator_model.predict(noise, verbose=0)
    
    # 将真图与假图进行拼接
    X = np.concatenate((image_batch, generated_images))
    
    # 与X对应的标签,前64张图为真,标签是1,后64张图是假图,标签为0
    y = [1] * BATCH_SIZE + [0] * BATCH_SIZE
    
    # 把真图与假图的拼接训练数据1送入判别器进行训练判别器的准确度
    d_loss = discriminator_model.train_on_batch(X, y)

    这里要是看不明白的话可以结合别人的讲解结合来看。

    在这里训练好之后,判别器的精度会不断提高。

    下面是重头戏了,也是GAN网络的核心:

    def generator_containing_discriminator(g, d):
        model = Sequential()
        model.add(g)
        # 判别器参数不进行修改
        d.trainable = False
        model.add(d)
        return model

    他的网络结构如下所示:

    这个模型有生成器与判别器组成:看代码,这个模型上半部分是生成网络,下半部分是判别网络,生成网络首先生成假图,然后送入判别网络中进行判断,这里有一个d.trainable=False,意思是,只调整生成器,判别的的参数不做更改。简直巧妙。

     

    然后我们来看如何训练生成网络,这一块也是核心区域:

            # 训练一个batchsize里面的数据
            for index in range(int(X_train.shape[0]/BATCH_SIZE)):
    
                # 产生随机噪声
                noise = np.random.uniform(-1, 1, size=(BATCH_SIZE, 1000))
    
                # 这里面都是真图片
                image_batch = X_train[index*BATCH_SIZE:(index+1)*BATCH_SIZE]
    
                # 这里产生假图片
                generated_images = g.predict(noise, verbose=0)
    
                # 将真图片与假图片拼接在一起
                X = np.concatenate((image_batch, generated_images))
    
                # 前64张图片标签为1,即真图,后64张照片为假图
                y = [1] * BATCH_SIZE + [0] * BATCH_SIZE
    
                # 对于判别器进行训练,不断提高判别器的识别精度
                d_loss = d.train_on_batch(X, y)
    
                # 再次产生随机噪声
                noise = np.random.uniform(-1, 1, (BATCH_SIZE, 1000))
                
                # 设置判别器的参数不可调整
                d.trainable = False
                
                # ××××××××××××××××××××××××××××××××××××××××××××××××××××××××××
                # 在此我们送入噪声,并认为这些噪声是真实的标签
                g_loss = generator_containing_discriminator.train_on_batch(noise, [1] * BATCH_SIZE)
                # ××××××××××××××××××××××××××××××××××××××××××××××××××××××××××
                
                # 此时设置判别器可以被训练,参数可以被修改
                d.trainable = True
                
                # 打印损失值
                print("batch %d d_loss : %s, g_loss : %f" % (index, d_loss, g_loss))

    重点在于这句代码

    g_loss = generator_containing_discriminator.train_on_batch(noise, [1] * BATCH_SIZE)

    首先这个网络模型(定义在上面),先传入生成器中,然后生成器生成图片之后,把图片传入判别器中,标签此刻传入的是1,真实的图片,但实际上是假图,此刻判别器就会判断为假图,然后模型就会不断调整生成器参数,此刻的判别器的参数被设置为为不可调整,d.trainable=False,所以为了不断降低loss值,模型就会一直调整生成器的参数,直到判别器认为这是真图。此刻判别器与生成器达到了一个平衡。也就是说生成器产生的假图,判别器已经分辨不出来了。所以继续迭代,提高判别器精度,如此往复循环,直到生成连人都辨别不了的图片。

    最后我训练了大概65轮,实际上生成比较真实的狗的图片我估计可能上千轮了,当然不同的网络结构,所需要的迭代次数也不一样。我这个因为太费时间,就跑了大概,可以看出大概有个狗模样。这个是训练了65轮之后的效果:

    以上就是全部的内容了。

    https://github.com/jensleeGit/Kaggle_self_use/tree/master/Generative%20Dog%20Images

    展开全文
  • 生成对抗网络——GAN(一)

    万次阅读 多人点赞 2019-03-18 18:51:51
    由此可见,GAN在视觉领域的未来多年内,将是一片沃土(CVer们是时候入门GAN了)。而发现这片矿源的就是GAN之父,Goodfellow大神。 ~~~ 生成对抗网络GAN,是当今的一大热门研究方向。在2014年,被Goodfellow大神提...

    Generative adversarial network

    据有关媒体统计:CVPR2018的论文里,有三分之一的论文与GAN有关
    由此可见,GAN在视觉领域的未来多年内,将是一片沃土(CVer们是时候入门GAN了)。而发现这片矿源的就是GAN之父,Goodfellow大神。
    文末有基于keras的GAN代码,有助于理解GAN的原理


    生成对抗网络GAN,是当今的一大热门研究方向。在2014年,被Goodfellow大神提出来,当时的G神还只是蒙特利尔大学的博士生而已。
    GAN之父的主页:
    http://www.iangoodfellow.com/

    GAN的论文首次出现在NIPS2014上,论文地址如下:
    https://arxiv.org/pdf/1406.2661.pdf


    入坑GAN,首先需要理由,GAN能做什么,为什么要学GAN。
    GAN的初衷就是生成不存在于真实世界的数据,类似于使得 AI具有创造力或者想象力。应用场景如下:

    1. AI作家,AI画家等需要创造力的AI体;
    2. 将模糊图变清晰(去雨,去雾,去抖动,去马赛克等),这需要AI具有所谓的“想象力”,能脑补情节;
    3. 进行数据增强,根据已有数据生成更多新数据供以feed,可以减缓模型过拟合现象。
      以上的场景都可以找到相应的paper。而且GAN的用处也远不止此,期待我们继续挖掘,是发论文的好方向哦

    GAN的原理介绍

    这里介绍的是原生的GAN算法,虽然有一些不足,但提供了一种生成对抗性的新思路。放心,我这篇博文不会堆一大堆公式,只会提供一种理解思路。

    理解GAN的两大护法GD

    G是generator,生成器: 负责凭空捏造数据出来

    D是discriminator,判别器: 负责判断数据是不是真数据

    这样可以简单的看作是两个网络的博弈过程。在最原始的GAN论文里面,G和D都是两个多层感知机网络。首先,注意一点,GAN操作的数据不一定非得是图像数据,不过为了更方便解释,我在这里用图像数据为例解释以下GAN:
    图片名称

    稍微解释以下上图,z是随机噪声(就是随机生成的一些数,也就是GAN生成图像的源头)。D通过真图和假图的数据(相当于天然label),进行一个二分类神经网络训练(想各位必再熟悉不过了)。G根据一串随机数就可以捏造一个“假图像”出来,用这些假图去欺骗D,D负责辨别这是真图还是假图,会给出一个score。比如,G生成了一张图,在D这里得分很高,那证明G是很成功的;如果D能有效区分真假图,则G的效果还不太好,需要调整参数。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比如cGAN),怎么理解这里的无监督呢?
    这里,给的真图是没有经过人工标注的,你只知道这是真实的图片,比如全是人脸,而系统里的D并不知道来的图片是什么玩意儿,它只需要分辨真假。G也不知道自己生成的是什么玩意儿,反正就是学真图片的样子骗D。

    正由于GAN的无监督,在生成过程中,G就会按照自己的意思天马行空生成一些“诡异”的图片,可怕的是D还能给一个很高的分数。比如,生成人脸极度扭曲的图片。这就是无监督目的性不强所导致的,所以在同年的NIPS大会上,有一篇论文conditional GAN就加入了监督性进去,将可控性增强,表现效果也好很多。


    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)
    
    展开全文
  • GAN(一):基本框架

    万次阅读 2018-11-22 16:35:15
    GAN(1):基本框架一、GAN的概念二、algorithm 小白的第一篇博客,写的有不对的地方,望各位批评指正; 一、GAN的概念 1)generator:Neural Network image generation: 给定一个vector,经过NN Generator后,产生...

    GAN(一):基本框架


    小白的第一篇博客,写的有不对的地方,望各位批评指正;

    一、GAN的概念

    1)generator:Neural Network
    image generation:
    给定一个vector,经过NN Generator后,产生一张图片
    sentence generation:
    给定一个vector,经过NN Generator后,产生一个句子
    2)discriminator:Neural Network
    image----->Discriminator----->scalar(一个数),这个数越大,表示image越realistic,越小表示image越fake

    一个GAN正是包含上述两部分,一个generator,一个discriminator(互相对抗)
    generator和discriminator就像是猎食者和猎物之间的关系,一个产生图片,一个辨别图片的真假,互相促进,使得最终产生的图片接近realistic

    问题1:为什么generator不通过样本自己学习,而要通过discriminator评分?
    解答1:generator是通过产生一个pixel一个pixel来产生整张图像的,因此对于图像局部区域之间的联系不能控制,也就是没有所谓的全局观。而discriminator是对整张图像进行打分,具有全局观,因此用discriminator来促进
    问题2:为什么discriminator不自己产生图像,而是只打分呢?
    解答2:事实上如果能解决如何取到argmax的问题,discriminator是可以自己产生图像的,但是argmax非常复杂,经常不好解或者根本解不出来,所以也不采用。

    二、algorithm

    1.Initialize generator and discriminator(随机初始化G,D两个神经网络)
    2. In each training iteration:
    step1:Fix generator G, and update discriminator D
    Discriminator learns to assign high scores to real objects and low scores to generated objects.
    (固定G,更新D。随机采样z,输入到G,G产生一系列图像G(z),D将其和database中的图像相比较,学习给真实的图像打高分,给假的图像打低分)

    step2:Gix discriminator D, and update generator G
    vector–>generator(NN,update)–>image
    image–>discriminator(NN,fix)–>score(higher is better)
    so, we need Gradient Ascent not Gradient descent
    (固定D,更新G)
    上面是完整的算法

    首先,我们要明确一点:G和D是互相促进的。G的目的是产生的图像让D感到模糊不知道该分成realistic(看起来像是现实的)还是fake(看起来是假的),D的目的是将realistic和fake的图像准确分辨。所以G产生的图像会越来越真,D的辨别能力会越来越强,最终达到一个平衡。
    Pdata 表示真实数据的分布,Pg generator产生的分布,最终的目的就是让Pg 的分布尽可能的和Pdata 相同。
    我们用D(x)表示真实图像经过discriminator后的分数,G(z)表示随机变量z经过generator后产生的图像,那么有:D(G(z)) 表示generator产生的图像经过discriminator后的分数
    我们所希望的是最大化下面这个式子:
    discriminator

    1. 从discriminator的角度来看,D(x)越大越好;上式的第二项越大越好(第二项中减号后面那项表示fake图片的得分,自然越小越好,所以带个减号之后就是越大越好CSDN上数学公式难输。。。能懂-这意思就行)
      因此,我们希望最大化上面这个式子
      generator
      2.从generator的角度来看,当然是希望自己产生的图片能够瞒天过海,所以希望上式越大越好

    有了这两个式子以后,就可以使用梯度上升或者梯度下降(在两个式子前面加负号)来解决了。

    展开全文
  • GAN最全论文合集

    千次阅读 多人点赞 2019-09-24 09:38:05
    已经到2019年了,再回来补充补充,坏消息是GAN的热度已经没有那么高了,一是各种各样的应用坑都被踩完了几乎,二是GAN结构以及不容易训练的问题。 相关论文合集: Kaiming He大神论文合集 [深度学习论文从0开始] ...
  • GAN简介及其常见应用

    千次阅读 2019-03-15 11:37:43
    GAN简介及其常见应用 很长一段时间,只有人类有能力创造,人工智能唯一的好处是解决回归,分类和聚类等问题,但随着生成网络的引入,人工智能研究人员能够使机器生成相同的内容或与人类同行相比质量更高。 ...
  • GAN的系列经典模型讲解

    千次阅读 2019-07-21 21:36:56
    自从Goodfellow2014年提出这个想法之后,生成对抗网络(GAN)就成了深度学习领域内最火的一个概念,包括LeCun在内的许多学者都认为,GAN的出现将会大大推进AI向无监督学习发展的进程。 于是,研究GAN就...
  • GAN原理,优缺点、应用总结

    千次阅读 2019-07-17 10:28:04
    h1 class="csdn_top" id="gan原理优缺点应用总结"><a name="t0"></a>GAN原理,优缺点、应用总结</h1> <br> 本文已投稿至微信公众号–机器学习算法全栈工程师,欢迎关注</article>&...
  • 生成式对抗网络(GAN, Generative Adversarial Networks )是一种深度学习模型,是近年来复杂分布上无监督学习最具前景的方法之一。模型通过框架中(至少)两个模块:生成模型(Generative Model)和判别模型...
  • 关于PatchGAN的理解

    万次阅读 多人点赞 2019-01-16 16:26:53
    GAN一般情况下的网络结构,在一些人的实验中已经表明对于要求高分辨率、高细节保持的图像领域中并不适合,有些人根据这一情况设计了PatchGAN的思路。这种GAN的差别主要是在于Discriminator上,一般的GAN是只需要输出...
  • GAN | CycleGAN | 风格迁移

    万次阅读 2018-07-01 18:22:38
    GAN是解决风格迁移的深度学习方法,本文将做出简要介绍。一、GAN GAN由生成网络G和对抗网络D组成,G用于接收一个噪声z,从而生成图片G(z);D是一个判别网络,判别一张图片x是不是“真的”我们所需得到的目的图片...
  • GAN模型中,输入一般被随机噪声,那么如何将输入该为一张实际图像,然后利用生成器使其成为与真实图像类似的图像?比如,将DCGAN模型中的随机噪声改为真实图像,该如何重新设计生成器的结构?或者在原始GAN中,该...
  • GAN的Loss为什么降不下去

    千次阅读 2019-05-16 00:05:41
    为什么GAN的Loss一直降不下去。GAN到底什么时候才算收敛?其实,作为一个训练良好的GAN,其Loss就是降不下去的。衡量GAN是否训练好了,只能由人肉眼去看生成的图片质量是否好。不过,对于没有一个很好的评价是否收敛...
  • 本文记录的是李弘毅老师的GAN的第二节课,bilibili视频链接为:https://www.bilibili.com/video/av24011528/?p=2,相关的课程课件链接为:http://speech.ee.ntu.edu.tw/~tlkagk/courses/MLDS_2018/Lecture/CGAN.pdf ...
  • GAN训练心得

    万次阅读 热门讨论 2018-11-24 20:54:52
    先抱怨一句,GAN训练真不容易… 一开始GAN总是训练效果很差,使用的是CNN去训练generator和discriminator,但是出来的总是“晶体图”,找到了一些技巧,然后自己实践了一下,也遇到了一些蠢哭的事情。 我换了一个...
  • CV之CycleGAN:CycleGAN算法相关思路配图、论文集合 目录 CycleGAN算法相关思路配图 CycleGAN算法相关论文集合 改进的StarGAN CycleGAN算法相关思路配图 1、成对(Paired)数据与不成对(Unpaired)数据...
  • StarGAN-多领域图像翻译

    万次阅读 2020-08-28 00:42:07
    CycleGAN解决了Unpaired数据下的图像翻译问题。但无论是Pix2Pix还是CycleGAN,都是解决了一对一的问题,即一个领域到另一个领域的转换。当有很多领域要转换了,对于每一个领域转换,都需要重新训练一个模型去解决。...
  • GAN 论文大汇总

    万次阅读 2017-04-24 15:23:39
    关于生成对抗网络(GAN)的新论文每周都会出现很多,跟踪发现他们非常难,更不用说去辨别那些研究人员对 GAN 各种奇奇怪怪,令人难以置信的创造性的命名!当然,你可以通过阅读 OpanAI 的博客或者 KDNuggets 中的...
  • 这次要介绍的工作是来自于CVPR2018李飞飞组关于预测行人运动轨迹的工作,通过结合GAN和sequence prediction来帮助提高效果。由于受限于笔者阅读面窄,对这方面的早期工作不甚了解,就全盘接受本文对早期工作介绍的...
  • 参考下面的github链接就明白了: https://github.com/ChengBinJin/V-GAN-tensorflow
1 2 3 4 5 ... 20
收藏数 31,825
精华内容 12,730
关键字:

gan