精华内容
下载资源
问答
  • 生成对抗网络损失函数的理解

    万次阅读 多人点赞 2018-12-12 17:30:08
    tf.nn.sigmoid_entropy_with_logits(labels,logits) 对抗网络中生成器的目的是尽可能使生成样本分布拟合真实样本分布。 鉴别的目的是尽可能鉴别输入样本来自于真实的还是生成的。 ...

    GAN损失函数

    • 对抗网络中生成器的目的是尽可能使生成样本分布拟合真实样本分布。
    • 鉴别器目的是尽可能鉴别输入样本来自于真实的还是生成的。
    • 大家都知道GAN的优化目标函数如下:
      在这里插入图片描述
    • 但其参数到底是如何优化的呢?答案是交替迭代优化;如下图所示:
      在这里插入图片描述
      • 图(a):固定G参数不变,优化D的参数,即最大化maxV(D,G)maxV(D,G)等价于min[V(D,G)]min[-V(D,G)]。因此,D的损失函数等价如下:
        在这里插入图片描述
      • 鉴别器认为来自真实数据样本的标签为1而来自生成样本的标签为0。因此,其优化过程是类似Sigmoid 的二分类,即sigmoid的交叉熵。
      • Tensorflow中的交叉熵是用tf.nn.sigmoid_entropy_with_logits(logits,labels)表示。
      • 查看TF的sigmoid交叉熵API可帮助理解:
        • x = logits表示鉴别器输出特征, z = labels表示对应的标签;则交叉熵表示为 zlog(sigmoid(x))+(1z)log(1sigmoid(x))z * -log(sigmoid(x)) + (1 - z) * -log(1 - sigmoid(x)).
        • 推导如下:
          zlog(sigmoid(x))+(1z)log(1sigmoid(x))z * -log(sigmoid(x)) + (1 - z) * -log(1 - sigmoid(x))
          =zlog(1/(1+ex))+(1z)log(ex/(1+ex))= z * -log(1 / (1 +e^{-x})) + (1 - z) * -log(e^{-x} / (1 +e^{-x}))
          =zlog(1+ex)+(1z)(log(ex)+log(1+ex))= z * log(1 + e^{-x}) + (1 - z) * (-log(e^{-x}) + log(1 + e^{-x}))
          =zlog(1+ex)+(1z)(x+log(1+ex))= z * log(1 + e^{-x}) + (1 - z) * (x + log(1 + e^{-x}))
          =(1z)x+log(1+ex)= (1 - z) * x + log(1 + e^{-x})
          =xxz+log(1+ex)= x - x * z + log(1 + e^{-x})
          x<0,可进一步化简为:
          =log(ex)xz+log(1+ex)= log(e^x) - x * z + log(1 + e^{-x})
          =xz+log(1+ex)= - x * z + log(1 + e^{x})
        • The logistic loss formula from above is x - x * z + log(1 + exp(-x))
        • For x < 0, a more numerically stable formula is -x * z + log(1 + exp(x))
        • Note that these two expressions can be combined into the following:max(x, 0) - x * z + log(1 + exp(-abs(x)))
      • z=1时,真实样本对应的损失为:log(sigmoid(x))=log(ex+1)=log(ex+1)x-log(sigmoid(x))=log(e^{-x}+1)=log(e^x+1)-x.
      • z=0时,生成样本对应的损失为:log(1sigmoid(x))=x+log(ex+1)=log(ex+1)-log(1-sigmoid(x))=x+log(e^{-x}+1)=log(e^x+1).其中softplus(x)=loge(1+ex)softplus(x)=log_e(1+e^x).
        在这里插入图片描述
      • 由于JS散度具有非负性,当两者分布相等时,其散度为零。因此,D(x)训练得越好,G(z)就越接近最优,则生成器的损失越接近于生成样本分布和真实样本分布的JS 散度。
    • GAN网络算法流程如下表:
      在这里插入图片描述
    • 实际上,式(2-6)可能并没有提供足够的梯度来更新G 的参数。训练初期, 由于G 没有得到较好的训练,生成样本很差,D 会以高置信度的概率来拒绝初期生成的样本,导致log(1−D(G(z)))达到饱和,无法提供足够的梯度来更新 G。于是,采用最大化log(D(G(z)))来代替最小化log(1−D(G(z)))更新 G的参数。
    • tensorflow框架下的GAN的损失代码如下:
    # the first term of discriminator loss of real sample:-log[D(x)]
    d_loss_real = tf.reduce_mean(tf.nn.sigmoid_entropy_with_logits(logits=D_real_logits,labels=tf.ones_like(D));
    # the second term of discriminator loss of fake sample:-log[1-D(G(z))]
    d_loss_fake = tf.reduce_mean(tf.nn.sigmoid_entropy_with_logits(logits=D_fake_logits,labels=tf.zeros_like(D));
    # D_fake_logits是鉴别器对生成器生成样本提取的特征 D(G(z))
    d_loss = d_loss_real + d_loss_fake ;
    # -log[D(G(z))]
    g_loss = tf.reduce_mean(tf.nn.sigmoid_entropy_with_logits(logits=D_fake_logits,labels=tf.ones_like(D));
    
    • D表示对应维度大小为batchsize的标签
    展开全文
  • 原论文中,关于生成器和判别器的损失函数是写成以下形式: 首先,第一个式子我们不看梯度符号的话即为判别器的损失函数,logD(xi)为判别器将真实数据判定为真实数据的概率,log(1-D(G(zi)))为判别器将生成器生成的...

    生成式对抗网络即GAN由生成器和判别器组成。原论文中,关于生成器和判别器的损失函数是写成以下形式:
    在这里插入图片描述
    首先,第一个式子我们不看梯度符号的话即为判别器的损失函数,logD(xi)为判别器将真实数据判定为真实数据的概率,log(1-D(G(zi)))为判别器将生成器生成的虚假数据判定为真实数据的对立面即将虚假数据仍判定为虚假数据的概率。判别器就相当于警察,在鉴别真伪时,必须要保证鉴别的结果真的就是真的假的就是假的,所以判别器的总损失即为二者之和,应当最大化该损失。由于判别器(警察)鉴别真伪的能力随着训练次数的增加越来越高,生成器就要与之“对抗”,生成器就要相应地提高“造假”技术,来迷惑判别器。第二个式子为第一个式子的第二项,含义相同,只不过对于生成器应当最小化该项,生成器当然希望辨别器将虚假数据仍判定为虚假数据的概率越低越好,即将虚假数据误判定为真实数据的概率越大越好,即最大化log(D(G(zi)))损失函数。所以二者相互提高或者减小自身的损失,以不断互相对抗。
    GitHub上的Deep Convolutional Generative Adversarial Networks(DCGAN)的损失函数是用nn.BCELoss()来写的,具体如下:

    import torch
    from torch.autograd import Variable
    
    batch_size = 10
    
    adversarial_loss = nn.BCELoss()
    
    valid = Variable(torch.Tensor(batch_size, 1).fill_(1.0), requires_grad=False)
    fake = Variable(torch.Tensor(batch_size, 1).fill_(0.0), requires_grad=False)
    
    # dis:鉴别器 
    # gen_imgs:生成器生成图像
    # real_imgs:真实图像
    g_loss = adversarial_loss(dis(gen_imgs), valid)
    
    real_loss = adversarial_loss(dis(real_imgs), valid)
    fake_loss = adversarial_loss(dis(gen_imgs), fake)
    d_loss = real_loss + fake_loss
    
    

    nn.BCELoss的计算公式这里不再赘述,可以查看官方文档,我手写一下代码中的g_lossd_loss:
    在这里插入图片描述
    在这里插入图片描述
    torch中都是最小化损失函数,所以d_loss能理解,而g_loss只不过对原论文中的写法换了一种表述,即最大化D(G(Z))的概率:使得鉴别器将生成器生成的图像鉴别为真的概率越大越好。

    在这里插入图片描述
    我用pytorch搭建了一个简易的GAN,没用卷积层,只是单纯的全连接层,利用mnist图像作为真实数据,随机生成100维的随机噪声作为生成器的输入,20次迭代的最终结果如上图,可以看出GAN多多少少能有些真实图像的大概轮廓。

    展开全文
  • 生成对抗网络GAN损失函数Loss的计算

    万次阅读 2017-07-31 15:24:07
    损失函数的计算辨别器对假数据的损失原理相同,最终达到的目标是对于所有的真实图片,输出为1;对于所有的假图片,输出为0。 生成器的目标是愚弄辨别器蒙混过关,需要达到的目标是对于生成的图片,输出为1.`d_loss_...

    损失函数的计算

    辨别器对假数据的损失原理相同,最终达到的目标是对于所有的真实图片,输出为1;对于所有的假图片,输出为0。
    生成器的目标是愚弄辨别器蒙混过关,需要达到的目标是对于生成的图片,输出为1(正好和鉴别器相反).

    d_loss_real = tf.reduce_mean(tf.nn.sigmoid_cross_entropy_with_logits(logits=d_logits_real,labels=tf.ones_like(d_logits_real) * (1 - smooth))) 
    
    d_loss_fake = tf.reduce_mean(tf.nn.sigmoid_cross_entropy_with_logits(logits=d_logits_fake,labels=tf.zeros_like(d_logits_real)))
    
    d_loss = d_loss_real + d_loss_fake 
    
    g_loss = tf.reduce_mean(
                 tf.nn.sigmoid_cross_entropy_with_logits(logits=d_logits_fake,
                                              labels=tf.ones_like(d_logits_fake))
    展开全文
  • 其实GAN的损失函数并没有特殊之处,就是常用的binary_crossentropy,关键在于训练过程中存在两个神经网络和两个损失函数。 np.random.seed(42) tf.random.set_seed(42) codings_size = 30 generator = keras....

    GAN最不好理解的就是Loss函数的定义和训练过程,这里用一段代码来辅助理解,就能明白到底是怎么回事。其实GAN的损失函数并没有特殊之处,就是常用的binary_crossentropy,关键在于训练过程中存在两个神经网络和两个损失函数。

    np.random.seed(42)
    tf.random.set_seed(42)
    
    codings_size = 30
    
    generator = keras.models.Sequential([
        keras.layers.Dense(100, activation="selu", input_shape=[codings_size]),
        keras.layers.Dense(150, activation="selu"),
        keras.layers.Dense(28 * 28, activation="sigmoid"),
        keras.layers.Reshape([28, 28])
    ])
    discriminator = keras.models.Sequential([
        keras.layers.Flatten(input_shape=[28, 28]),
        keras.layers.Dense(150, activation="selu"),
        keras.layers.Dense(100, activation="selu"),
        keras.layers.Dense(1, activation="sigmoid")
    ])
    gan = keras.models.Sequential([generator, discriminator])
    
    discriminator.compile(loss="binary_crossentropy", optimizer="rmsprop")
    discriminator.trainable = False
    gan.compile(loss="binary_crossentropy", optimizer="rmsprop")
    
    batch_size = 32
    dataset = tf.data.Dataset.from_tensor_slices(X_train).shuffle(1000)
    dataset = dataset.batch(batch_size, drop_remainder=True).prefetch(1)
    

    这里generator并不用compile,因为gan网络已经compile了。具体原因见下文。

    训练过程的代码如下

    def train_gan(gan, dataset, batch_size, codings_size, n_epochs=50):
        generator, discriminator = gan.layers
        for epoch in range(n_epochs):
            print("Epoch {}/{}".format(epoch + 1, n_epochs))              # not shown in the book
            for X_batch in dataset:
                # phase 1 - training the discriminator
                noise = tf.random.normal(shape=[batch_size, codings_size])
                generated_images = generator(noise)
                X_fake_and_real = tf.concat([generated_images, X_batch], axis=0)
                y1 = tf.constant([[0.]] * batch_size + [[1.]] * batch_size)
                discriminator.trainable = True
                discriminator.train_on_batch(X_fake_and_real, y1)
                # phase 2 - training the generator
                noise = tf.random.normal(shape=[batch_size, codings_size])
                y2 = tf.constant([[1.]] * batch_size)
                discriminator.trainable = False
                gan.train_on_batch(noise, y2)
            plot_multiple_images(generated_images, 8)                     # not shown
            plt.show()                                                    # not shown
    

    第一阶段(discriminator训练)

    # phase 1 - training the discriminator
    noise = tf.random.normal(shape=[batch_size, codings_size])
    generated_images = generator(noise)
    X_fake_and_real = tf.concat([generated_images, X_batch], axis=0)
    y1 = tf.constant([[0.]] * batch_size + [[1.]] * batch_size)
    discriminator.trainable = True
    discriminator.train_on_batch(X_fake_and_real, y1)
    

    这个阶段首先生成数量相同的真实图片和假图片,concat在一起,即X_fake_and_real = tf.concat([generated_images, X_batch], axis=0)。然后是label,真图片的label是1,假图片的label是0。

    然后是迅速阶段,首先将discrinimator设置为可训练,discriminator.trainable = True,然后开始阶段。第一个阶段的训练过程只训练discriminator,discriminator.train_on_batch(X_fake_and_real, y1),而不是整个GAN网络gan

    第二阶段(generator训练)

    # phase 2 - training the generator
    noise = tf.random.normal(shape=[batch_size, codings_size])
    y2 = tf.constant([[1.]] * batch_size)
    discriminator.trainable = False
    gan.train_on_batch(noise, y2)
    

    在第二阶段首先生成假图片,但是不再生成真图片。把假图片的label全部设置为1,并把discriminator的权重冻结,即discriminator.trainable = False。这一步很关键,应该这么理解:

    前面第一阶段的是discriminator的训练,使真图片的预测值尽量接近1,假图片的预测值尽量接近0,以此来达到优化损失函数的目的。现在将discrinimator的权重冻结,网络中输入假图片,并故意把label设置为1。

    注意,在整个gan网络中,从上向下的顺序是先通过geneartor,再通过discriminator,即gan = keras.models.Sequential([generator, discriminator])。第二个阶段将discrinimator冻结,并训练网络gan.train_on_batch(noise, y2)。如果generator生成的图片足够真实,经过discrinimator后label会尽可能接近1。由于故意把y2的label设置为1,所以如果genrator生成的图片足够真实,此时generator训练已经达到最优状态,不会大幅度更新权重;如果genrator生成的图片不够真实,经过discriminator之后,预测值会接近0,由于y2的label是1,相当于预测值不准确,这时候gan网络的损失函数较大,generator会通过更新generator的权重来降低损失函数。

    之后,重新回到第一阶段训练discriminator,然后第二阶段训练generator。假设整个GAN网络达到理想状态,这时候generator产生的假图片,经过discriminator之后,预测值应该是0.5。假如这个值小于0.5,证明generator不是特别准确,在第二阶段训练过程中,generator的权重会被继续更新。假如这个值大于0.5,证明discriminator不是特别准确,在第一阶段训练中,discriminator的权征会被继续更新。

    简单说,对于一张generator生成的假图片,discriminator会尽量把预测值拉下拉,generator会尽量把预测值往上扯,类似一个拔河的过程,最后达到均衡状态,例如0.6, 0.4, 0.55, 0.45, 0.51, 0.49, 0.50。

    展开全文
  • Tensorflow2.0 + Transformers 实现Bert FGM抗训练惩罚梯度损失函数前言变种实现Transformers中的word_embeddings代码修改实验效果总结 前言 之前看了很多关于NLP中应用对抗训练的文章,测试结果都很香,所以想在...
  • 1.铰链损失函数hinge loss 铰链损失函数(hinge loss)的思想就是让那些未能正确分类的和正确分类的之间的距离要足够的远,如果相差达到一个阈值Δ\DeltaΔ时,此时这个未正确分类的误差就可以认为是0,否则就要累积...
  • 深度学习常用损失函数

    千次阅读 2019-03-30 13:33:23
    损失函数的作用是衡量实际输出与预计输出之间的差异,损失函数的设计是深度学习中十分重要的部分,不仅会影响到训练的速度,还会影响隐含层中数据的分布情况。目前仅仅是总结了部分常用损失函数的计算方法,其中涉及...
  • 损失函数和代价函数是同一个东西,目标函数是一个与他们相关但更广的概念,对于目标函数来说在有约束条件下的最小化就是损失函数(loss function)举个例子解释一下:上面三个图的函数依次为 , , 。我们是想用这三个...
  • GAN是一种特殊的损失函数

    千次阅读 2018-12-21 15:58:42
    摘要: 从本质上来说,生成对抗网络(GAN)是一种特殊的损失函数,我们来深入探索下这句话的含义。   数据科学家Jeremy Howard在fast.ai的《生成对抗网络(GAN)》课程中曾经讲过这样一句话: “从本质上来说,...
  • 损失函数--KL散度与交叉熵

    千次阅读 2019-12-04 01:38:50
    损失函数 ​ 在逻辑回归建立过程中,我们需要一个关于模型参数的可导函数,并且它能够以某种方式衡量模型的效果。这种函数称为损失函数(loss function)。 ​ 损失函数越小,则模型的预测效果越优。所以我们可以把...
  • 在深度学习中我们常用的损失函数是二次函数 L=(y−y^)22(3)L=\frac{(y-\hat{y})^2}{2} (3)L=2(y−y^​)2​(3),若激活函数使用的是sigmoid函数,则 y^=σ(z)\hat{y}=\sigma(z)y^​=σ(z),其中 z=wx+bz=wx+bz=wx+b。...
  • 深度学习-常用损失函数详细介绍

    千次阅读 2019-11-27 11:18:52
    深度学习常用损失函数介绍, 本文主要收集和整理了深度学习常用的损失函数,包括softmax,arcface,centerloss等常见损失函数,给出函数表达式,以及使用介绍和应用场景
  • SRGAN损失函数(目标函数)详解

    千次阅读 2020-02-02 21:06:05
    SRGAN损失函数的解析及其Keras代码实现
  • 深度学习中常用的损失函数

    千次阅读 2019-10-22 19:36:52
    文章目录一、什么是损失函数?二、分类任务损失1、0-1 loss2、熵与交叉熵loss3、softmax loss及其变种4、KL散度5、Hinge loss6、Exponential loss与Logistic loss三、回归任务损失1、L1 loss2、L2 loss3、L1 loss与...
  • ...今天来说说深度学习中常见的损失函数(loss),覆盖分类,回归任务以及生成对抗网络,有了目标才能去优化一个模型。 作者&编辑 | 言有三 1 什么是损失函数 在机器学习中,损失函数(lo...
  • 损失函数(loss function)是用来估量模型的预测值f(x)与真实值Y的不一致程度,损失函数越小,一般就代表模型的鲁棒性越好,正是损失函数指导了模型的学习。 感知损失perceptual loss(VGG损失) 对于图像风格化,...
  • L1与L2损失函数

    千次阅读 2019-03-20 09:55:30
    参考之前博客:https://blog.csdn.net/yql_617540298/article/details/87904860 ... 一、损失函数 1. L1 loss L1范数损失函数,也被称为最小绝对值偏差(LAD),最小绝对值误差(LAE)。总的说来,它是把目标值与...
  • VAE的损失函数的拆分

    千次阅读 2019-08-26 10:05:51
    「Structured Disentangled Representations」这篇文章对VAE的损失函数提出了一个同一化的解释,根据这个解释可以很好的分析近几年来对VAE的各种变形。 VAE损失函数的不同形式 ...
  • 损失函数Author:Sowmya YellapragadaTranslator:ronghuaiyangFrom:AI公园 导读损失函数在模型...
  • 文章目录 写在最前面的话:本文主要整理深度学习中的损失函数,从原理到作用,详细了解损失函数

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 12,337
精华内容 4,934
关键字:

对抗损失函数