精华内容
下载资源
问答
  • PyTorch正式实施“具有对抗损失和渐变蒙版的多阶段原始视频降噪”| 代码即将发布! 视频 参考 @InProceedings{paliwal2021maskdenosing, title={Multi-Stage Raw Video Denoising with Adversarial Loss and ...
  • 内容损失 对抗损失Recently, I came across the amazing paper presented in CVPR 2019 by Jon Barron about developing a robust and adaptive loss function for Machine Learning problems. This post is a ...

    内容损失 对抗损失

    Recently, I came across the amazing paper presented in CVPR 2019 by Jon Barron about developing a robust and adaptive loss function for Machine Learning problems. This post is a review of that paper along with some necessary concepts and, it will also contain an implementation of the loss function on a simple regression problem.

    最近,我遇到了乔恩·巴伦 ( Jon Barron)在CVPR 2019上发表的有关开发针对机器学习问题的健壮和自适应损失函数的惊人论文 。 这篇文章是对该论文的评论以及一些必要的概念,并且还将包含一个简单回归问题的损失函数的实现。

    离群值和稳健损失的问题: (Problem with Outliers and Robust Loss:)

    Consider one of the most used errors in machine learning problems- Mean Squared Error (MSE). As you know it is of the form (y-x)². One of the key characteristics of the MSE is that its high sensitivity towards large errors compared to small ones. A model trained with MSE will be biased towards reducing the largest errors. For example, a single error of 3 units will be given same importance to 9 errors of 1 unit.

    考虑一下机器学习问题中最常用的错误之一-均方误差(MSE)。 如您所知,它的形式为(yx)²。 MSE的主要特征之一是与小错误相比,它对大错误的敏感性高。 用MSE训练模型将倾向于减少最大的误差 。 例如,3个单位的单个误差将与1个单位的9个误差具有相同的重要性。

    I created an example using Scikit-Learn to demonstrate how the fit varies in a simple data-set with and without taking the effect of outliers.

    我使用Scikit-Learn创建了一个示例,以演示在有和没有受到异常值影响的情况下,拟合如何在简单数据集中变化。

    Image for post
    Fig. 1: MSE and effect of outliers. (Image by Author)
    图1:MSE和异常值的影响。 (图片由作者提供)

    As you can see the fit line including the outliers get heavily influenced by the outliers but, the optimization problem should require the model to get more influenced by the inliers. At this point you can already think about Mean Absolute Error (MAE) as better choice than MSE, due to less sensitivity to large errors. There are various types of robust losses (like MAE) and for a particular problem we may need to test various losses. Wouldn’t it be amazing to test various loss functions on the fly while training a network? The main idea of the paper is to introduce a generalized loss function where the robustness of the loss function can be varied and, this hyperparameter can be trained while training the network, to improve performance. It is way less time consuming than finding the best loss say, by performing grid-search cross-validation. Let’s get started with the definition below —

    如您所见,包括异常值在内的拟合线受到异常值的严重影响,但是,优化问题应要求模型受到较大范围的影响。 此时,由于对大误差的敏感性较低,因此您已经可以将平均绝对误差(MAE)视为比MSE更好的选择。 健壮损耗有多种类型(例如MAE),对于特定问题,我们可能需要测试各种损耗。 在训练网络时动态地测试各种损失功能会不会令人惊讶? 本文的主要思想是引入广义损失函数,其中损失函数的健壮性可以改变,并且可以在训练网络的同时训练该超参数,以提高性能。 通过执行网格搜索交叉验证,与找到最佳损失相比,它节省了很多时间。 让我们开始下面的定义-

    稳健和适应性损失:一般形式: (Robust and Adaptive Loss: General Form:)

    The general form of the robust and adaptive loss is as below —

    鲁棒性和自适应性损失的一般形式如下:

    Image for post
    Exp. 1: Robust Loss: α is the hyperparameter that controls the robustness.
    经验 1:稳健性损失:α是控制稳健性的超参数。

    α controls the robustness of the loss function. c can be considered as a scale parameter which controls the size of the bowl near x=0. Since α acts as hyperparameter, we can see that for different values of α the loss function takes familiar forms. Let’s see below —

    α控制损失函数的鲁棒性。 c可以看作是比例参数,它控制碗的大小接近x = 0。 由于α充当超参数,我们可以看到,对于不同的α值,损失函数采用熟悉的形式。 让我们在下面看到-

    Image for post
    Exp. 2: Various losses from the adaptive loss (Expression. 1) for different values of α.
    经验 2:对于不同的α值,自适应损失(表达式1)产生的各种损失。

    The loss function is undefined at α = 0 and 2, but taking the limit we can make approximations. From α =2 to α =1 the loss smoothly makes a transition from L2 loss to L1 loss. For different values of α we can plot the loss function to see how it behaves (fig. 2).

    损失函数在α = 0和2时未定义,但是采用极限,我们可以近似。 从α = 2到α = 1,损耗平稳地从L2损耗过渡到L1损耗。 对于不同的α值,我们可以绘制损失函数以观察其行为(图2)。

    We can also spend some time with the first derivative of this loss function because the derivative is needed for gradient-based optimization. For various values of α the derivatives w.r.t x are shown below. In figure 2, I have also plotted the derivatives along with the loss function for different α.

    我们也可以花一些时间处理该损失函数的一阶导数,因为基于梯度的优化需要该导数。 对于各种α值,导数wrt x如下所示。 在图2中,我还绘制了不同α的导数以及损失函数。

    Image for post
    Exp. 3: Derivative of robust loss (Exp. 1) w.r.t x for various values of α.
    经验 3:对于各种α值,稳健损耗(实验1)wrt x的导数。

    自适应损耗及其导数的行为: (Behaviour of Adaptive Loss and Its Derivative:)

    The figure below is very important to understand the behaviour of this loss function and its derivative. For the plots below, I have fixed the scale parameter c to 1.1. When x = 6.6, we can consider this as like x = 6× c. We can draw the following inferences about the loss and its derivative —

    下图对于理解此损失函数及其导数的行为非常重要。 对于下面的图,我将比例参数c固定为1.1。 当x = 6.6时,我们可以将其视为x = 6× c 。 我们可以得出有关损失及其导数的以下推论-

    1. The loss function is smooth for x, α and c>0 and thus suited for gradient based optimization.

      对于x,αc > 0, 损失函数是平滑因此适合基于梯度的优化。

    2. The loss is always zero at origin and increases monotonically for |x|>0. Monotonic nature of the loss can also be compared with taking log of a loss.

      损耗在原点处始终为零,并且对于| x |> 0单调增加 。 损失的单调性也可以与损失的对数进行比较。

    3. The loss is also monotonically increasing with increasing α. This property is important for the robust nature of loss function because we can start with a higher value of α and then gradually reduce (smoothly) during optimization to enable robust estimation avoiding local minima.

      损耗也随着α的增加而单调增加。 该属性对于损失函数的鲁棒性很重要,因为我们可以从较高的α值开始,然后在优化过程中逐渐减小(平滑)以实现鲁棒的估计,从而避免局部最小值

    4. We see that when |x|<c, the derivatives are almost linear for different values of α. This implies that the derivatives are proportional to residual’s magnitude when they are small.

      我们看到,当| x | < c ,对于不同的α值,导数几乎是线性的。 这意味着,当导数较小时,它们与残差的大小成正比

    5. For α = 2 the derivative is throughout proportional to the residual’s magnitude. This is in general the property of MSE (L2) loss.

      对于α = 2,导数始终与残差的大小成比例。 通常,这是MSE(L2)损失的属性。

    6. For α = 1 (gives us L1 Loss), we see that the derivative’s magnitude saturates to a constant value (exactly 1/c) beyond |x|>c. This implies that effect of residuals never exceeds a fixed amount.

      对于α = 1(给我们L1损失),我们看到导数的大小饱和到一个恒定值(恰好是1 / c ),超过|。 x |> c 。 这意味着残差的影响永远不会超过固定量。

    7. For α < 1, the derivative’s magnitude decreases as |x|>c. This implies that when residual increases it has less effect on the gradient, thus the outliers will have less effect during gradient descent.

      α <1时,导数的幅度减小为| |。 x |> c 。 这意味着当残差增加时,它对梯度的影响较小,因此异常值在梯度下降期间的影响较小。

    Image for post
    Fig. 2: Loss function and derivative of loss function as a function of α. (Image by Author)
    图2:损失函数和损失函数的导数随α的变化。 (图片由作者提供)

    I have also plotted below the surface plots of robust loss and its derivative for different values of α.

    我还绘制了鲁棒损耗及其对于不同α值的导数的表面图。

    Image for post
    Fig. 3: Surface plots of Adaptive Loss Function (left) and its derivative (right). (Image by Author)
    图3:自适应损失函数(左)及其导数(右)的曲面图。 (图片由作者提供)

    实现稳健的损失:Pytorch和Google Colab: (Implementing Robust Loss: Pytorch and Google Colab:)

    Since we have gone through the basics and properties of the robust and adaptive loss function, let us put this into action. Codes used below are just slightly modified from what can be found in Jon Barron’s GitHub repository. I have also created an animation to depict how the adaptive loss finds the best-fit line as the number of iteration increases.

    由于我们已经研究了健壮和自适应损失函数的基本知识和属性,因此让我们付诸实践。 下面使用的代码与Jon Barron的GitHub存储库中的代码稍作修改。 我还创建了一个动画来描述随着迭代次数的增加,自适应损失如何找到最佳拟合线。

    Rather than cloning the repository and working with it, we can install it locally using pip in Colab.

    无需克隆存储库并使用它,我们可以在Colab中使用pip在本地安装它。

    !pip install git+https://github.com/jonbarron/robust_loss_pytorchimport robust_loss_pytorch 

    We create a simple linear dataset including normally distributed noise and also outliers. Since the library uses pytorch, we convert the numpy arrays of x, y to tensors using torch.

    我们创建一个简单的线性数据集,其中包括正态分布的噪声以及离群值。 由于该库使用pytorch ,我们使用torchx,y的numpy数组转换为张量。

    import numpy as np
    import torch scale_true = 0.7
    shift_true = 0.15x = np.random.uniform(size=n)y = scale_true * x + shift_truey = y + np.random.normal(scale=0.025, size=n) # add noise flip_mask = np.random.uniform(size=n) > 0.9 y = np.where(flip_mask, 0.05 + 0.4 * (1. — np.sign(y — 0.5)), y)
    # include outliersx = torch.Tensor(x)
    y = torch.Tensor(y)

    Next we define a Linear regression class using pytorch modules as below-

    接下来,我们使用pytorch模块定义线性回归类,如下所示:

    class RegressionModel(torch.nn.Module):   def __init__(self):      super(RegressionModel, self).__init__()      self.linear = torch.nn.Linear(1, 1) 
    ## applies the linear transformation. def forward(self, x): return self.linear(x[:,None])[:,0] # returns the forward pass

    Next, we fit a linear regression model to our data but, first the general form of the loss function is used. Here we use a fixed value of α (α = 2.0) and it remains constant throughout the optimization procedure. As we have seen for α = 2.0 the loss function replicates L2 loss and this as we know is not optimal for problems including outliers. For optimization we use the Adam optimizer with a learning rate of 0.01.

    接下来,我们将线性回归模型拟合到我们的数据,但首先使用损失函数的一般形式。 在这里,我们使用固定值α ( α = 2.0),并且在整个优化过程中保持不变。 如我们所见,对于α = 2.0,损失函数复制了L2损失,并且我们知道,这对于包括异常值在内的问题不是最佳的。 对于优化,我们使用学习率为0.01的Adam优化器。

    regression = RegressionModel()
    params = regression.parameters()
    optimizer = torch.optim.Adam(params, lr = 0.01)for epoch in range(2000):
    y_i = regression(x)
    # Use general loss to compute MSE, fixed alpha, fixed scale. loss = torch.mean(robust_loss_pytorch.general.lossfun(
    y_i — y, alpha=torch.Tensor([2.]), scale=torch.Tensor([0.1]))) optimizer.zero_grad() loss.backward() optimizer.step()

    Using the general form of the robust loss function and a fixed value of α, we can obtain the fit line. The original data, true line (line with the same slope and bias used to generate data-points excluding the outliers) and fit line are plotted below in fig. 4.

    使用鲁棒损失函数的一般形式和固定值α ,我们可以获得拟合线。 原始数据,真实线(具有与用于生成数据点的斜率和偏差相同的斜率和偏差的线,但不包括异常值 )和拟合线绘制在下面的图5中。 4。

    Image for post
    Fig. 4: General Loss Function (Image by Author)
    图4:一般损失函数(作者提供)

    The general form of the loss function doesn’t allow α to change and thus we have to fine tune the α parameter by hand or by performing a grid-search. Also, as the figure above suggests that the fit is affected by the outliers because we used L2 loss. This is the general scenario but, what happens if we use the adaptive version of the loss function ? We call the adaptive loss module and just initialize α and let it adapt itself at each iteration step.

    损失函数的一般形式不允许α改变,因此我们必须手动或通过执行网格搜索来微调α参数。 同样,如上图所示,因为我们使用了L2损失,所以拟合度受异常值的影响。 这是一般情况,但是,如果我们使用损失函数的自适应版本会怎样? 我们称自适应损失模块,仅初始化α,并让其在每个迭代步骤中进行自适应。

    regression = RegressionModel()adaptive = robust_loss_pytorch.adaptive.AdaptiveLossFunction(           num_dims = 1, float_dtype=np.float32)params = list(regression.parameters()) + list(adaptive.parameters())optimizer = torch.optim.Adam(params, lr = 0.01)for epoch in range(2000):   y_i = regression(x)   loss = torch.mean(adaptive.lossfun((y_i — y)[:,None]))
    # (y_i - y)[:, None] # numpy array or tensor optimizer.zero_grad() loss.backward() optimizer.step()

    Using this, and also some extra bit of code using Celluloid module, I created the animation below (figure 5). Here, you clearly see, how with increasing iterations adaptive loss finds the best fit line. This is close to the true line and it is negligibly affected by the outliers.

    使用此代码以及Celluloid模块的一些额外代码,我在下面创建了动画(图5)。 在这里,您可以清楚地看到,随着迭代次数的增加,自适应损失如何找到最佳拟合线。 这接近真实界限,并且受到异常值的影响可以忽略不计。

    Image for post
    Fig. 5: Animation of how adaptive loss function settles for the best fit. (Image by Author)
    图5:自适应损失函数如何适应最佳拟合的动画。 (图片由作者提供)

    讨论: (Discussion:)

    We have seen how the robust loss including an hyperparameter α can be used to find the best loss-function on the fly. The paper also demonstrates how the robustness of the loss-function with α as continuous hyperparameter can be introduced to classic computer vision algorithms. Examples of implementing adaptive loss for Variational Autoencoder and Monocular depth estimations are shown in the paper and these codes are also available in Jon’s GitHub. However, the most fascinating part for me was the motivation and step by step derivation of the loss function as described in the paper. It’s easy to read so, I suggest to take a look at the paper!

    我们已经看到了如何使用包括超参数α的鲁棒损耗来动态地找到最佳损耗函数。 本文还演示了如何将α作为连续超参数的损失函数的鲁棒性引入经典的计算机视觉算法中。 本文显示了为变分自动编码器和单眼深度估计实现自适应损耗的示例,这些代码也可以在Jon的GitHub中找到 。 但是,对我而言,最有趣的部分是本文所述的损失函数的动机和逐步推导。 这很容易阅读,所以我建议看一下这篇论文!

    Stay strong and cheers!!

    保持坚强和欢呼!!

    翻译自: https://medium.com/@saptashwa/the-most-awesome-loss-function-172ffc106c99

    内容损失 对抗损失

    展开全文
  • 深度学习中的对抗损失怎么使用

    千次阅读 2019-03-15 16:18:13
    对前几天的对抗损失总结一下,转载请注明出处,如有不对的地方,欢迎前来指出,一起探讨。 1.对抗损失的目的与作用 对抗损失的使用主要是为了减少标注数据,在真实的业务中,对于数据的标注是一件非常头疼的事,...

    对前几天的对抗损失总结一下,转载请注明出处,如有不对的地方,欢迎前来指出,一起探讨。

    1.对抗损失的目的与作用

        对抗损失的使用主要是为了减少标注数据,在真实的业务中,对于数据的标注是一件非常头疼的事,为了使用1000条标注能够达到2000条标注数据的所能达到效果(打个比方),模拟真实世界中各种噪声的情况,让模型更加鲁棒,更好用,准确率更高,在图像处理中经常使用引入噪声来增加图像的样本集,在文本类数据中怎么来使用呢?

        那具体怎么做呢?一般方法是将真实数据+噪声,使得数据散度更大,让有标签与无标签的数据在模型上一起进行学习。

    2.对抗损失的方法

    • 一般对抗损失(在进行一般对抗的时候,首先对要对batch_size的数据进行一次损失的计算,根据损失对输入(可以是字向量、词向量、词性向量、偏旁向量等特征的拼接)的向量进行偏导数计算,但要注意的是需要对输入数据进行stop_gradiants,然后刚才求得的Grad进行L2正则化处理,将处理后的值称作扰动perturb,将perturb与embedding一起add,然后在进行一次损失的计算,起到了对每个batch_size的数据进行了两次的计算,增加模型的鲁棒性)
    • 随机对抗损失(随机生成一个形状与embedding相同的向量,然后进行MASK操作,再进行L2正则化生成pertub,最后将生成的噪声添加到输入特征向量上进行再次计算损失)
    • 虚拟对抗损失(虚拟对抗与随机损失有点相似,但是引入了KL散度,具体看下面实现)

    3.对抗损失具体实现

    一般对抗损失

    def adversarial_loss(embedded, loss, loss_fn):
      """Adds gradient to embedding and recomputes classification loss."""
      grad, = tf.gradients(
          loss,
          embedded)
      grad = tf.stop_gradient(grad)
      perturb = _scale_l2(grad, FLAGS.perturb_norm_length)
      return loss_fn(embedded + perturb)

    随机对抗损失

    def random_perturbation_loss(embedded, length, loss_fn):
      """Adds noise to embeddings and recomputes classification loss."""
      noise = tf.random_normal(shape=tf.shape(embedded))
      perturb = _scale_l2(_mask_by_length(noise, length), FLAGS.perturb_norm_length)
      return loss_fn(embedded + perturb)
    

    虚拟对抗损失

    def virtual_adversarial_loss(logits, embedded, inputs,
                                 logits_from_embedding_fn):
      """Virtual adversarial loss.
    
      Computes virtual adversarial perturbation by finite difference method and
      power iteration, adds it to the embedding, and computes the KL divergence
      between the new logits and the original logits.
    
      Args:
        logits: 3-D float Tensor, [batch_size, num_timesteps, m], where m=1 if
          num_classes=2, otherwise m=num_classes.
        embedded: 3-D float Tensor, [batch_size, num_timesteps, embedding_dim].
        inputs: VatxtInput.
        logits_from_embedding_fn: callable that takes embeddings and returns
          classifier logits.
    
      Returns:
        kl: float scalar.
      """
      # Stop gradient of logits. See https://arxiv.org/abs/1507.00677 for details.
      logits = tf.stop_gradient(logits)
    
      # Only care about the KL divergence on the final timestep.
      weights = inputs.eos_weights
      assert weights is not None
      if FLAGS.single_label:
        indices = tf.stack([tf.range(FLAGS.batch_size), inputs.length - 1], 1)
        weights = tf.expand_dims(tf.gather_nd(inputs.eos_weights, indices), 1)
    
      # Initialize perturbation with random noise.
      # shape(embedded) = (batch_size, num_timesteps, embedding_dim)
      d = tf.random_normal(shape=tf.shape(embedded))
    
      # Perform finite difference method and power iteration.
      # See Eq.(8) in the paper http://arxiv.org/pdf/1507.00677.pdf,
      # Adding small noise to input and taking gradient with respect to the noise
      # corresponds to 1 power iteration.
      for _ in xrange(FLAGS.num_power_iteration):
        d = _scale_l2(
            _mask_by_length(d, inputs.length), FLAGS.small_constant_for_finite_diff)
    
        d_logits = logits_from_embedding_fn(embedded + d)
        kl = _kl_divergence_with_logits(logits, d_logits, weights)
        d, = tf.gradients(
            kl,
            d,
            aggregation_method=tf.AggregationMethod.EXPERIMENTAL_ACCUMULATE_N)
        d = tf.stop_gradient(d)
    
      perturb = _scale_l2(d, FLAGS.perturb_norm_length)
      vadv_logits = logits_from_embedding_fn(embedded + perturb)
      return _kl_divergence_with_logits(logits, vadv_logits, weights)

     

     

     

    展开全文
  • 看到有些讲解的文章,说对抗损失是gan的思想,优化目标是让判别器不能分辨原图和破坏图,但是我的理解完全相反。以下是我的理解,如有不对,请指出。 1.作者原文中的图2 有明显的说明,“an adversarial loss is ...

    看到有些讲解的文章,说DCL中的对抗损失是gan的思想,优化目标是让判别器不能分辨原图和破坏图,但是我的理解完全相反。以下是我的理解,如有不对,请指出。

    1.作者原文中的图2 有明显的说明,“an adversarial loss is applied to distinguish original images from destructed ones.”也就是说对抗损失的目的是为了区分原图和破坏图。

     2)在3.1.2节中,作者说分类loss和对抗loss是以对抗的形式进行工作。分类loss是不区分原图和破坏图的,对抗loss区分原图和对抗图,这样才是对抗的。

     3)认为是以不区分原图和破坏图为目的的人,大多是因为以下的公式,

    认为不论d为0还是1的时候,及不论是原图还是破坏图,D的优化方向都是1.但是这只是在单个二分类中才是 这样的理解,但是作者论文中说明了输出维度是2, 

    那此公式就是一个softmax loss!跟分类loss是一个形式,用于区分是原图还是不是原图。也就是说 不是一个二分类器的输出,不是经过这个二分类器后原图输出1,破坏后的图也输出1.而是相当于有两个分类器,一个判别是不是原图,一个判别是不是破坏后的图,具体原理详见softmax。

    4)作者的代码也证实了这一观点,2分类模式下的输出层(实际还可以有另一种模式,具体可以自己看代码)

     拿到这个输出之后是直接一个ce loss!

    最后,探讨一下为什么对抗网络能有效果,对抗网络其实相当于让模型学习到了什么是RCM引入的噪声信息,也就是将原来的视觉特征空间分割成了噪声空间和有用空间,能让模型在分类的时候不要去拟合噪声空间。

    展开全文
  • 行业分类-电子电器-一种基于跨域数据和对抗损失的城市尺度无线业务流量预测方法.zip
  • 生成对抗网络损失函数的理解

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

    GAN损失函数

    • 对抗网络中生成器的目的是尽可能使生成样本分布拟合真实样本分布。
    • 鉴别器目的是尽可能鉴别输入样本来自于真实的还是生成的。
    • 大家都知道GAN的优化目标函数如下:
      在这里插入图片描述
    • 但其参数到底是如何优化的呢?答案是交替迭代优化;如下图所示:
      在这里插入图片描述
      • 图(a):固定G参数不变,优化D的参数,即最大化 m a x V ( D , G ) maxV(D,G) maxV(D,G)等价于 m i n [ − V ( 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表示对应的标签;则交叉熵表示为 z ∗ − l o g ( s i g m o i d ( x ) ) + ( 1 − z ) ∗ − l o g ( 1 − s i g m o i d ( x ) ) z * -log(sigmoid(x)) + (1 - z) * -log(1 - sigmoid(x)) zlog(sigmoid(x))+(1z)log(1sigmoid(x)).
        • 推导如下:
          z ∗ − l o g ( s i g m o i d ( x ) ) + ( 1 − z ) ∗ − l o g ( 1 − s i g m o i d ( x ) ) z * -log(sigmoid(x)) + (1 - z) * -log(1 - sigmoid(x)) zlog(sigmoid(x))+(1z)log(1sigmoid(x))
          = z ∗ − l o g ( 1 / ( 1 + e − x ) ) + ( 1 − z ) ∗ − l o g ( e − x / ( 1 + e − x ) ) = z * -log(1 / (1 +e^{-x})) + (1 - z) * -log(e^{-x} / (1 +e^{-x})) =zlog(1/(1+ex))+(1z)log(ex/(1+ex))
          = z ∗ l o g ( 1 + e − x ) + ( 1 − z ) ∗ ( − l o g ( e − x ) + l o g ( 1 + e − x ) ) = z * log(1 + e^{-x}) + (1 - z) * (-log(e^{-x}) + log(1 + e^{-x})) =zlog(1+ex)+(1z)(log(ex)+log(1+ex))
          = z ∗ l o g ( 1 + e − x ) + ( 1 − z ) ∗ ( x + l o g ( 1 + e − x ) ) = z * log(1 + e^{-x}) + (1 - z) * (x + log(1 + e^{-x})) =zlog(1+ex)+(1z)(x+log(1+ex))
          = ( 1 − z ) ∗ x + l o g ( 1 + e − x ) = (1 - z) * x + log(1 + e^{-x}) =(1z)x+log(1+ex)
          = x − x ∗ z + l o g ( 1 + e − x ) = x - x * z + log(1 + e^{-x}) =xxz+log(1+ex)
          x<0,可进一步化简为:
          = l o g ( e x ) − x ∗ z + l o g ( 1 + e − x ) = log(e^x) - x * z + log(1 + e^{-x}) =log(ex)xz+log(1+ex)
          = − x ∗ z + l o g ( 1 + e x ) = - x * z + log(1 + e^{x}) =xz+log(1+ex)
        • 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时,真实样本对应的损失为: − l o g ( s i g m o i d ( x ) ) = l o g ( e − x + 1 ) = l o g ( e x + 1 ) − x -log(sigmoid(x))=log(e^{-x}+1)=log(e^x+1)-x log(sigmoid(x))=log(ex+1)=log(ex+1)x.
      • z=0时,生成样本对应的损失为: − l o g ( 1 − s i g m o i d ( x ) ) = x + l o g ( e − x + 1 ) = l o g ( e x + 1 ) -log(1-sigmoid(x))=x+log(e^{-x}+1)=log(e^x+1) log(1sigmoid(x))=x+log(ex+1)=log(ex+1).其中 s o f t p l u s ( x ) = l o g e ( 1 + e x ) softplus(x)=log_e(1+e^x) softplus(x)=loge(1+ex).
        在这里插入图片描述
      • 由于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的标签
    展开全文
  • 生成式对抗网络即GAN由生成器和判别器组成。原论文中,关于生成器和判别器的损失函数是写成以下形式: 首先,第一个式子我们不看梯度符号的话即为判别器的损失函数,logD(xi)为判别器将真实数据判定为真实数据的...
  • 我们的目标是学习一个映射G: X->Y,使来自G(X)的图像的分布与使用对抗损失的分布难以区分。因为这个映射是高度欠约束的,我们将它与一个逆映射F: Y->X 和引入一个循环一致性损失 执行F(G(X))约等于X (Y与G(F(Y))亦然...
  • 其实GAN的损失函数并没有特殊之处,就是常用的binary_crossentropy,关键在于训练过程中存在两个神经网络和两个损失函数。 np.random.seed(42) tf.random.set_seed(42) codings_size = 30 generator = keras....
  • 我们提出了一个简单的正则化方案来处理生成对抗网络(GAN)中的模式缺失和训练不稳定的问题。 关键思想是利用鉴别器学习到的视觉特征。 我们通过向生成器提供由鉴别器提取的真实数据特征来重建真实数据。 将重建损失...
  • 对抗loss理解

    2021-01-11 11:53:10
    第一个式子为判别器的损失...由于判别器(警察)鉴别真伪的能力随着训练次数的增加越来越高,生成器就要与之“对抗”,生成器就要相应地提高“造假”技术,来迷惑判别器。第二个式子为第一个式子的第二项,含义相同...
  • 纸 赵一豪,吴瑞海,董浩, ,ECCV 2020 代码用法 对于环境: conda env create -f acl-gan.yaml 对于数据集:数据集应以以下格式存储: \数据集 | \火车 | | \ trainA | | \ trainB ... python train.py --config ...
  • 【生成对抗网络】starGAN 详细解读

    千次阅读 2020-02-13 08:30:18
    损失函数 Adversarial Loss(对抗损失) 为了保证生成图像的真实性,采用了对抗损失。Dsrc(x)是D给出的源域上的概率分布。 生成器G试图将这个目标最小化,即尽可能缩小自己生成的数据与真实数据的差别,让 D 真假难...
  • 生成对抗网络GAN损失函数Loss的计算

    万次阅读 2017-07-31 15:24:07
    损失函数的计算辨别器对假数据的损失原理相同,最终达到的目标是对于所有的真实图片,输出为1;对于所有的假图片,输出为0。 生成器的目标是愚弄辨别器蒙混过关,需要达到的目标是对于生成的图片,输出为1.`d_loss_...
  • 对抗损失:我想你们大多数人现在都熟悉这种典型的对抗损失。 x是ground truth,所以我们希望D(x)返回1,否则返回0。注意,D只是鉴别器的函数形式。 联合损失: 式3为其联合损失函数。Lambda 1, 2, 3用来平衡每个...
  • ADDA是当前域适应方法中较为出色的一种,同时也是一种典型的asymmetric transformation。看了一些关于该论文的笔记,觉得...生成对抗学习是现今一种很具前景的方法,生成器通过将源域分布不断的更新改进,使源域分布...
  • SRGAN的损失函数

    千次阅读 2018-06-21 20:14:50
    GAN的作用,是额外增加一个D网络和2个损失(判别损失和生成判别损失),用一种交替训练的方式训练两个网络。这个模型可以分为3部分:main模块,adversarial模块,和vgg模块。(一般main模块就是adversarial模块里的G...
  • 感知损失(perceptual loss)详解

    万次阅读 2019-10-21 17:21:53
    文章目录一、感知损失二、Loss_feature三、Loss_style 一、感知损失 图中: 蓝线加黑线表示内容损失,作用在较低特征层上 红线和黑线表示风格损失,作用在从低到高所有特征层上 System overview We train an ...
  • 1.铰链损失函数hinge loss 铰链损失函数(hinge loss)的思想就是让那些未能正确分类的和正确分类的之间的距离要足够的远,如果相差达到一个阈值Δ\DeltaΔ时,此时这个未正确分类的误差就可以认为是0,否则就要累积...
  • 对比损失与三元组损失

    千次阅读 2019-08-05 14:23:01
    【时间】2019.08.05 【题目】对比损失与三元组损失 一、对比损失 二、三元组损失 具体见:一篇文章,教你读懂度量学习、三元组损失函数 度量学习(metric learning)损失函数 ...
  • SRGAN损失函数(目标函数)详解

    千次阅读 2020-02-02 21:06:05
    SRGAN损失函数的解析及其Keras代码实现
  • CYCADA:循环一致性对抗域适应方法

    千次阅读 2019-09-26 17:41:37
    CyCADA方法:通过在多个损失函数上训练模型。总体思路为:特征级+像素级上的对齐+在对齐过程中保留数据中的语义信息(即将数据的类别...原样本映射的目标样本的对抗损失(像素数级适应)Lgan 特征级适应损失Lgan 重...
  • 因此,发生器的优化信号来自三个方面:标准GAN中的对抗损失,真实数据的去噪损失和潜码的重建损失,这有助于防止无梯度问题。 我们使用稳健的度量标准Frechet起始距离评估生成的样本的质量和多样性,该度量可以检测...
  • 上文说到生成对抗网络GAN能够通过训练学习到数据分布,进而生成新的样本。可是GAN的缺点是生成的图像是随机的,不能控制生成图像属于何种类别。比如数据集包含飞机、汽车和房屋等类别,原始GAN并不能在测试阶段控制...
  • 对抗生成网络及代码实例

    千次阅读 2017-07-18 18:05:26
    构建一个简单对抗生成模型,使生成网络能够生成一个位于已知图形之间的图形,并且尽量拟合已知图形。 已知图形如下: 首先看一下训练效果 下图依次是迭代50次,500次,5000次的效果 代码地址: ...
  • optimization-based super-resolution method 受目标函数选择影响,目前以mms(minimizing the mean squared)为目标函数,即损失函数+结果估计peak signal-to-noise 峰值信噪比为主要模式,但是缺少高频细节 ...
  • 越学越糊涂,忘了各个模块存在的初衷,也还是没完全弄清“损失函数、目标函数、经验风险、期望风险、结构风险、泛化、方差、偏差”等概念以及直观上的作用。李航说机器学习有三要素:模型、策略和算法(统计学方法=...
  • 1.为什么要用交叉熵损失代替平方损失 为什么不用二次方代价函数 权值​和偏置​的偏导数为​ 求导过程 偏导数受激活函数的导数影响,sigmoid函数导数在输出接近0和1时非常小,会导致一些实例在刚开始训练...
  • 语音增强生成对抗网络的混合惩罚性损失
  • 理解计算机视觉中的损失函数

    千次阅读 2020-05-26 12:36:37
    选择正确的损失函数可以帮助你的模型学习如何将注意力集中在数据中的正确特征集合上,从而获得最优和更快的收敛。 计算机视觉是计算机科学的一个领域,主要研究从数字图像中自动提取信息。 在过去的十年中...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 21,217
精华内容 8,486
关键字:

对抗损失