精华内容
下载资源
问答
我要提问
  • 加权交叉熵损失函数：tf.nn.weighted_cross_entropy_with_logits 千次阅读
    2020-06-19 21:06:19

    tf.nn.weighted_cross_entropy_with_logits函数

    tf.nn.weighted_cross_entropy_with_logits(
    targets,
    logits,
    pos_weight,
    name=None
)

    定义在：tensorflow/python/ops/nn_impl.py。

    计算加权交叉熵。

    类似于sigmoid_cross_entropy_with_logits()，除了pos_weight，允许人们通过向上或向下加权相对于负误差的正误差的成本来权衡召回率和精确度。

    通常的交叉熵成本定义为：

    targets * -log(sigmoid(logits)) +
    (1 - targets) * -log(1 - sigmoid(logits))

    值pos_weights > 1减少了假阴性计数，从而增加了召回率。相反设置pos_weights < 1会减少假阳性计数并提高精度。从一下内容可以看出pos_weight是作为损失表达式中的正目标项的乘法系数引入的：

    targets * -log(sigmoid(logits)) * pos_weight +
    (1 - targets) * -log(1 - sigmoid(logits))

    为了简便起见，让x = logits，z = targets，q = pos_weight。损失是：

      qz * -log(sigmoid(x)) + (1 - z) * -log(1 - sigmoid(x))
= qz * -log(1 / (1 + exp(-x))) + (1 - z) * -log(exp(-x) / (1 + exp(-x)))
= qz * log(1 + exp(-x)) + (1 - z) * (-log(exp(-x)) + log(1 + exp(-x)))
= qz * log(1 + exp(-x)) + (1 - z) * (x + log(1 + exp(-x))
= (1 - z) * x + (qz +  1 - z) * log(1 + exp(-x))
= (1 - z) * x + (1 + (q - 1) * z) * log(1 + exp(-x))

    设置l = (1 + (q - 1) * z)，确保稳定性并避免溢出，使用一下内容来实现：

    (1 - z) * x + l * (log(1 + exp(-abs(x))) + max(-x, 0))

    logits和targets必须具有相同的类型和形状。

    参数：

    • targets：一个Tensor，与logits具有相同的类型和形状。
    • logits：一个Tensor，类型为float32或float64。
    • pos_weight：正样本中使用的系数。
    • name：操作的名称（可选）。

    返回：

    与具有分量加权逻辑损失的logits具有相同形状的Tensor。

    可能引发的异常：

    • ValueError：如果logits和targets没有相同的形状。
    更多相关内容

  • caffe 加权交叉熵损失函数 SigmoidCrossEntropyLoss

     2017-12-24 23:13:56
    论文中"Holistically-Nested Edge Detection"使用的加权损失函数，具体用法见博客http://blog.csdn.net/majinlei121/article/details/78884531
    收起

  • [TensorFlow] 交叉熵损失函数，加权交叉熵损失函数

     千次阅读 2021-08-22 17:10:41
    本篇文章会更细地讲一下tensorflow中交叉熵损失函数的应用，以及在优化过程中可能用到加权交叉熵损失函数的使用方式。 一、基础计算 当存在多个类别时，通常使用交叉熵损失函数来衡量模型的效果，也是对模型调参的...

    写在前面

    在文章[TensorFlow] argmax, softmax_cross_entropy_with_logits, sparse_softmax_cross_entropy_with_logits函数详解中，提到了交叉熵损失函数的计算方式以及tensorflow中的输入和输出等。本篇文章会更细地讲一下tensorflow中交叉熵损失函数的应用，以及在优化过程中可能用到加权交叉熵损失函数的使用方式。

    一、基础计算

    当存在多个类别时，通常使用交叉熵损失函数来衡量模型的效果，也是对模型调参的重要依据，交叉熵损失函数的公式为：
    L = 1 N ∑ i L i = − 1 N ∑ i ∑ C = 1 M y i c l o g P i c \begin{aligned} L = \frac{1}{N}\sum_{i}L_i = -\frac{1}{N} \sum_{i} \sum_{C=1}^My_{ic}logP_{ic} \end{aligned} L=N1​i∑​Li​=−N1​i∑​C=1∑M​yic​logPic​​
    代码：

    import tensorflow as tf
import numpy as np
 
sess=tf.Session()
#logits代表wx+b的输出，注意：logits没有进行softmax
logits = np.array([[1, 2, 3],
                   [4, 5, 6],
                   [7, 10, 3],
                   [8, 2, 0],
                   [9, 6, 3]], dtype=np.float32)
#labels是[2,2,1,0,1]的ont-hot编码形式
labels = np.array([[0, 0, 1],
                   [0, 0, 1],
                   [0, 1, 0],
                   [1, 0, 0],
                   [0, 1, 0]], dtype=np.float32)
                   
softmax_out=tf.nn.softmax(logits)
print("softmax_out is::")
print(sess.run(softmax_out))

print("labels * tf.log(softmax_out) is::")
print(sess.run(labels * tf.log(softmax_out)))   # label和softmax_out取log后相乘

print("cross_entropy1 is::")
cross_entropy1 = -tf.reduce_sum(labels * tf.log(softmax_out), axis=1)  # 每个样本的不同label，求损失和
print(sess.run(cross_entropy1))

    结果：

    softmax_out is::
[[9.0030573e-02 2.4472848e-01 6.6524094e-01]
 [9.0030573e-02 2.4472848e-01 6.6524094e-01]
 [4.7384717e-02 9.5174748e-01 8.6788135e-04]
 [9.9719369e-01 2.4717962e-03 3.3452120e-04]
 [9.5033026e-01 4.7314156e-02 2.3556333e-03]]
labels * tf.log(softmax_out) is::
[[-0.0000000e+00 -0.0000000e+00 -4.0760601e-01]
 [-0.0000000e+00 -0.0000000e+00 -4.0760601e-01]
 [-0.0000000e+00 -4.9455535e-02 -0.0000000e+00]
 [-2.8102510e-03 -0.0000000e+00 -0.0000000e+00]
 [-0.0000000e+00 -3.0509458e+00 -0.0000000e+00]]
cross_entropy1 is::
[4.0760601e-01 4.0760601e-01 4.9455535e-02 2.8102510e-03 3.0509458e+00]

    二、tf.nn.softmax_cross_entropy_with_logits和tf.nn.sparse_softmax_cross_entropy_with_logits

    1.两个函数的输出结果相同，区别在于输入的labels不同。
    2.对于sparse_softmax_cross_entropy_with_logits， labels的size是[batch_size]，每个label的取值范围是[0, num_classes-1]，即每个样本的label就是0、1、2.
    3.对于softmax_cross_entropy_with_logits, labels的size是[batch_size, num_classes]，即sparse_softmax_cross_entropy_with_logits中labels的one-hot值。

    代码：

    import tensorflow as tf
import numpy as np
 
sess = tf.Session()
# logits代表wx+b的输出，注意：logits没有进行softmax
logits = np.array([[1, 2, 3],
                   [4, 5, 6],
                   [7, 10, 3],
                   [8, 2, 0],
                   [9, 6, 3]], dtype=np.float32)

print("cross_entropy2 is::")
cross_entropy2 = tf.nn.softmax_cross_entropy_with_logits(logits=logits, labels=labels)
print(sess.run(cross_entropy2))

# labels是[2,2,1,0,1]的ont-hot编码形式
labels = np.array([[0, 0, 1],
                   [0, 0, 1],
                   [0, 1, 0],
                   [1, 0, 0],
                   [0, 1, 0]], dtype=np.float32)

print("cross_entropy3 is::")
classes = tf.argmax(labels, axis=1)  # array([2,2,1,0,1])
cross_entropy3 = tf.nn.sparse_softmax_cross_entropy_with_logits(logits=logits, labels=classes)
print(sess.run(cross_entropy3))

    结果：

    cross_entropy2 is::
[4.0760595e-01 4.0760595e-01 4.9455538e-02 2.8102214e-03 3.0509458e+00]
cross_entropy3 is::
[4.0760595e-01 4.0760595e-01 4.9455538e-02 2.8102214e-03 3.0509458e+00]

    三、tf.losses.softmax_cross_entropy 和 tf.losses.sparse_softmax_cross_entropy

    1.主要用于进行不同样本的loss计算，但可通过权重来控制loss损失值
    2.默认weights=1，等价于tf.reduce_mean(tf.nn.softmax_cross_entropy_with_logits)
    3.weights为标量w时，等价于w*tf.reduce_mean(tf.nn.softmax_corss…)
    4.weights为向量时，算出的每个loss需要乘以对应样本权重，再求均值
    5.tf.losses.sparse_softmax_cross_entropy 同理等等价于tf.reduce_mean(tf.nn.sparse_softmax_cross_entropy_with_logits),只不过输入labels是非one-hot编码格式

    代码：

    import tensorflow as tf
import numpy as np
sess = tf.Session()
#logits代表wx+b的输出，注意：logits没有进行softmax
logits = np.array([[1, 2, 3],
                   [4, 5, 6],
                   [7, 10, 3],
                   [8, 2, 0],
                   [9, 6, 3]], dtype=np.float32)
#labels是[2,2,1,0,1]的ont-hot编码形式
labels = np.array([[0, 0, 1],
                   [0, 0, 1],
                   [0, 1, 0],
                   [1, 0, 0],
                   [0, 1, 0]], dtype=np.float32)

cross1 = tf.nn.softmax_cross_entropy_with_logits(labels=labels,logits=logits)
cross2 = tf.losses.softmax_cross_entropy(onehot_labels=labels, logits=logits)
cross3 = tf.losses.softmax_cross_entropy(onehot_labels=labels, logits=logits, weights=0.3)
 
print("cross1 is::")    
print (sess.run(cross1))            
print("cross2 is::")
print (sess.run(cross2))                   
print("tf.reduce_mean(cross1) is::")
print (sess.run(tf.reduce_mean(cross1)))    

print("cross3 is::")
print (sess.run(cross3))                          
print("0.3*tf.reduce_mean(cross1) is::")
print (sess.run(0.3*tf.reduce_mean(cross1)))

    结果：

    cross1 is::
[4.0760595e-01 4.0760595e-01 4.9455538e-02 2.8102214e-03 3.0509458e+00]
cross2 is::
0.7836847
tf.reduce_mean(cross1) is::
0.7836847

    四、加权交叉熵损失 – 样本加权

    tf.losses.softmax_cross_entropy可以对损失进行加权，当每个样本的权重不同时，可以按照样本的权重加权。

    import tensorflow as tf
import numpy as np
sess = tf.Session()
#logits代表wx+b的输出，注意：logits没有进行softmax
logits = np.array([[1, 2, 3],
                   [4, 5, 6],
                   [7, 10, 3],
                   [8, 2, 0],
                   [9, 6, 3]], dtype=np.float32)
#labels是[2,2,1,0,1]的ont-hot编码形式
labels = np.array([[0, 0, 1],
                   [0, 0, 1],
                   [0, 1, 0],
                   [1, 0, 0],
                   [0, 1, 0]], dtype=np.float32)
                   
cross2 = tf.losses.softmax_cross_entropy(onehot_labels=labels, logits=logits)
cross3 = tf.losses.softmax_cross_entropy(onehot_labels=labels, logits=logits, weights=0.3)    # 每个样本都权重0.3

print("cross2 is::")
print (sess.run(cross2))  
print("cross3 is::")
print (sess.run(cross3))                          
print("0.3*tf.reduce_mean(cross1) is::")
print (sess.run(0.3*tf.reduce_mean(cross1)))  

cross4 = tf.losses.softmax_cross_entropy(onehot_labels=labels, logits=logits,weights=[1, 2, 3, 4, 5])  # 用于控制每个样本的权重
print("cross4 is::", cross4)
print (sess.run(cross4))
print("sum", 4.0760595e-01 * 1 + 4.0760595e-01 * 2 + 4.9455538e-02 * 3 + 2.8102214e-03 * 4 + 3.0509458e+00 * 5)
print("average", (4.0760595e-01 * 1 + 4.0760595e-01 * 2 + 4.9455538e-02 * 3 + 2.8102214e-03 * 4 + 3.0509458e+00 * 5)/5.)

    结果：

    cross2 is::
0.7836847
cross3 is::
0.23510543
0.3*tf.reduce_mean(cross1) is::
0.23510541
cross4 is::
3.3274307
sum 16.6371543496
average 3.3274308699199997

    五、加权交叉熵损失 – 类别加权

    实际可能会遇到这样的情况，对于每个样本是没有权重的，但是针对不同的类别，有相应的权重，比如，类别3更不希望错误，所以类别3的损失权重可能会设置的比其他大。

    对于我们需要重视的类别，可以给其较高的权重，（权重越高，损失越大，模型越会学好这个类别），如：
    某个类别较少，则可以给出较高的权重，使其训练的更好
    某个类别不允许错误，则需要尽量训练好这个数据，可以将其权重调高

    #logits代表wx+b的输出，注意：logits没有进行softmax
logits = np.array([[1, 2, 3],
                   [4, 5, 6],
                   [7, 10, 3],
                   [8, 2, 0],
                   [9, 6, 3]], dtype=np.float32)
#labels是[2,2,1,0,1]的ont-hot编码形式
labels = np.array([[0, 0, 1],
                   [0, 0, 1],
                   [0, 1, 0],
                   [1, 0, 0],
                   [0, 1, 0]], dtype=np.float32)

class_weights = tf.constant([[1.0, 1.5, 4.0]])  # 3个类别的权重，用于控制每个类别的权重
weights = tf.reduce_sum(class_weights * labels, axis=1)  # 向量化的权重
print("weights is::", sess.run(weights))

cross1 = tf.nn.softmax_cross_entropy_with_logits(labels=labels,logits=logits)
print("cross1 is::")
print(sess.run(cross1))
weighted_losses = cross1 * weights
print("weighted_losses is::")
print(sess.run(weighted_losses))
print("tf.reduce_mean(weighted_losses) is::")
print(sess.run(tf.reduce_mean(weighted_losses)))

softmax_out=tf.nn.softmax(logits)
print("softmax_out is::")
print(sess.run(softmax_out))
print("labels * tf.log(softmax_out) is::")
print(sess.run(labels * tf.log(softmax_out)))   # label和softmax_out取log后相乘

sum = 4.0760601e-01 * 4 + 4.0760601e-01 * 4 + 4.9455535e-02 * 1.5 + 2.8102510e-03 * 1 + 3.0509458e+00 * 1.5   # 通过普通的计算方法看下是否与结果一致
print("sum/5 is::", sum/5)

    结果：

    weights is:: [4.  4.  1.5 1.  1.5]
cross1 is::
[4.0760595e-01 4.0760595e-01 4.9455538e-02 2.8102214e-03 3.0509458e+00]
weighted_losses is::
[1.6304238e+00 1.6304238e+00 7.4183308e-02 2.8102214e-03 4.5764189e+00]
tf.reduce_mean(weighted_losses) is::
1.582852
softmax_out is::
[[9.0030573e-02 2.4472848e-01 6.6524094e-01]
 [9.0030573e-02 2.4472848e-01 6.6524094e-01]
 [4.7384717e-02 9.5174748e-01 8.6788135e-04]
 [9.9719369e-01 2.4717962e-03 3.3452120e-04]
 [9.5033026e-01 4.7314156e-02 2.3556333e-03]]
labels * tf.log(softmax_out) is::
[[-0.0000000e+00 -0.0000000e+00 -4.0760601e-01]
 [-0.0000000e+00 -0.0000000e+00 -4.0760601e-01]
 [-0.0000000e+00 -4.9455535e-02 -0.0000000e+00]
 [-2.8102510e-03 -0.0000000e+00 -0.0000000e+00]
 [-0.0000000e+00 -3.0509458e+00 -0.0000000e+00]]
sum/5 is:: 1.5828520667

    六、加权交叉熵损失 – 类别转移矩阵加权

    上面是针对不同的类别，权重不同，但是若不是针对固定的类别有权重，而是比如：将类别1预测为类别2，这种错误代价较高，反而将类别1预测为类别3代价较低，这种方式怎么来进行损失加权呢？如预测值和真实值预测权重矩阵为：

    真实类别1真实类别2真实类别3
    预测类别1142
    预测类别2511
    预测类别3431

    其中 w 01 = 4 w_{01}=4 w01​=4表示预测类别为1实际类别为2的权重， w 02 = 2 w_{02}=2 w02​=2表示预测类别为1实际类别为3的权重。

    代码：

    #logits代表wx+b的输出，注意：logits没有进行softmax
logits = np.array([[1, 2, 3],
                   [4, 5, 6],
                   [7, 10, 3],
                   [2, 8, 0],
                   [9, 6, 3]], dtype=np.float32)
#labels是[2,2,1,0,1]的ont-hot编码形式
labels = np.array([[0, 1, 0],
                   [0, 0, 1],
                   [0, 1, 0],
                   [1, 0, 0],
                   [0, 1, 0]], dtype=np.float32)
transfer_weights = tf.constant([[1.0, 4.0, 2.0],
                               [5.0, 1.0, 1.0],
                               [4.0, 3.0, 1.0]])

weighted_logits = tf.matmul(logits, transfer_weights)
print("weighted_logits is::")
print(sess.run(weighted_logits))  # 得到预测值为logits情况下，实际label=1、label=2、label=3下的加权logits

softmax_out=tf.nn.softmax(weighted_logits)
print("softmax_out is::")
print(sess.run(softmax_out))
print("labels * tf.log(softmax_out) is::")
print(sess.run(labels * tf.log(softmax_out)))   # label和softmax_out取log后相乘

cross1 = tf.nn.softmax_cross_entropy_with_logits(labels=labels,logits=weighted_logits)
cross2 = tf.losses.softmax_cross_entropy(onehot_labels=labels, logits=weighted_logits)
print ("cross1 is::", sess.run(cross1))          
print ("cross2 is::", sess.run(cross2))

sum = 8.000336 + 34. + 22. + 0. + 0.6931472  # 常规算法，与参数结果比较是否一致
print("average is::", sum/5.)

    结果：

    weighted_logits is::
[[23. 15.  7.]
 [53. 39. 19.]
 [69. 47. 27.]
 [42. 16. 12.]
 [51. 51. 27.]]
softmax_out is::
[[9.99664545e-01 3.35350080e-04 1.12497425e-07]
 [9.99999166e-01 8.31528041e-07 1.71390690e-15]
 [1.00000000e+00 2.78946810e-10 5.74952202e-19]
 [1.00000000e+00 5.10908893e-12 9.35762291e-14]
 [5.00000000e-01 5.00000000e-01 1.88756719e-11]]
labels * tf.log(softmax_out) is::
[[ -0.         -8.000336   -0.       ]
 [ -0.         -0.        -34.       ]
 [  0.        -22.         -0.       ]
 [  0.         -0.         -0.       ]
 [ -0.         -0.6931472  -0.       ]]
cross1 is:: [ 8.000336  34.        22.         0.         0.6931472]
cross2 is:: 12.938696
average is:: 12.93869664

    参考文章：
    Tensorflow交叉熵的代码实现

    收起
    展开全文
    tensorflow 深度学习

  • 加权交叉熵损失函数

     千次阅读 热门讨论 2020-01-06 16:17:34
    Keras 加权交叉熵损失函数binary crossentropyTextCNN的loss函数功能快捷键合理的创建标题，有助于目录的生成如何改变文本的样式插入链接与图片如何插入一段漂亮的代码片生成一个适合你的列表创建一个表格设定内容...

    Keras 加权交叉熵损失函数binary crossentropy

    TextCNN的loss函数

    最近看到一篇论文通过设置带权重的交叉熵损失函数解决数据集中类不平衡问题，没有找到实现的代码，就参考了几篇代码写了一个。
    论文链接: Neural Network-based Detection of Self-Admitted Technical Debt: From Performance to Explainability.

    基于tensorflow2+python3.7的代码实现

    import tensorflow as tf
from keras import backend as K
def get_weight(weights):
    def mycrossentropy(y_true, y_pred):
        pt_1 = tf.where(tf.equal(y_true, 1), y_pred, tf.zeros_like(y_pred))
        pt_0 = tf.where(tf.equal(y_true, 0), y_pred, tf.ones_like(y_pred))
        loss = (1-weights)*K.binary_crossentropy(y_true, y_pred)*pt_1+weights*K.binary_crossentropy(y_true, y_pred)*pt_0
        return loss
    return mycrossentropy
    
model.compile('adam', loss=get_weight(weights), metrics=['accuracy'])

    参考代码来源：
    Focal Loss

    收起
    展开全文
    tensorflow 深度学习 python

  • caffe 加权交叉熵损失函数层（weighted sigmoid_cross_entropy_loss_layer）添加方法

     万次阅读 2017-12-24 13:04:30
    用卷积神经网络实现边缘检测的论文”Holistically-Nested Edge Detection”中使用了加权交叉熵损失函数（sigmoid_cross_entropy_loss_layer），因为在边缘检测中正样本（边缘）相对于负样本（非边缘）来讲，数量是很...

    用卷积神经网络实现边缘检测的论文”Holistically-Nested Edge Detection”中使用了加权交叉熵损失函数（sigmoid_cross_entropy_loss_layer），因为在边缘检测中正样本（边缘）相对于负样本（非边缘）来讲，数量是很少的，如果对正负样本的损失乘以同样的权重系数，那么网络就会把所有的像素都预测成负样本（因为正样本的数目很少，所以都预测为负样本的话，总的损失也会很小），而这是我们不想看到的，所以需要给正样本的损失加上一定的权重，当正样本分类错误的时候，乘以一个很大的权重，造成总的损失会很大。当负样本分类错的时候，乘以一个很小的权重（e.g. 1），但是由于负样本的总数比较多，所以总的损失也是符合实际情况的。
    先补上上面论文的地址：https://www.cv-foundation.org/openaccess/content_iccv_2015/papers/Xie_Holistically-Nested_Edge_Detection_ICCV_2015_paper.pdf
    caffe代码：https://github.com/s9xie/hed
    论文中交叉熵损失函数定义为：

    这里写图片描述

    比如一共100个像素，边缘像素有2个，非边缘有98个，那么边缘损失的权重为0.98，非边缘损失的权重为0.02，给数量少的正样本足够大的权重，卷积网络就可训练出最后满意结果。
    论文的代码使用的交叉熵损失函数是在原来caffe的SigmoidCrossEntropyLoss层上进行改进的，并没有定义新的层，在自己实际使用时还不能直接用，需要改一些东西，改过之后的文件在http://download.csdn.net/download/majinlei121/10171746，包括sigmoid_cross_entropy_loss_layer.cpp 和 sigmoid_cross_entropy_loss_layer.hpp
    cpp文件的改动主要是在加权损失方面
    由于只定义了cpu上运行的损失函数，没有sigmoid_cross_entropy_loss_layer.cu文件，所以需要把hpp文件中关于gpu执行的声明给注释掉，注释的代码包括：

      //virtual void Forward_gpu(const vector<Blob<Dtype>*>& bottom,
      //const vector<Blob<Dtype>*>& top);

    和

      //virtual void Backward_gpu(const vector<Blob<Dtype>*>& top,
      //const vector<bool>& propagate_down, const vector<Blob<Dtype>*>& bottom);

    另外自己还在损失函数的基础上又加了一个权重lambda_, lambda_是乘在正样本的损失上的，因此需要hpp文件中加入声明（124行）：

      int lambda_;

    并且需要在caffe/src/caffe/proto/caffe.proto文件中加入声明（在LossParameter里）加入：

      optional int32 lambda = 6 [default = 1];

    这样使用SigmoidCrossEntropyLoss层的时候为

    layer {
  name: "loss"
  type: "SigmoidCrossEntropyLoss"
  bottom: "conv5"
  bottom: "prob"
  top: "loss"
  propagate_down: 1
  propagate_down: 0
  loss_weight: 1 # 1
  loss_param: {
    normalize: 1
    lambda: 1
  }
}

    在论文给的sigmoid_cross_entropy_loss_layer.cpp代码中一开始调用了

    #include "caffe/vision_layers.hpp"

    但是在后期的caffe中vision_layers.hpp已经没有了，在下载地址http://download.csdn.net/download/majinlei121/10171746中已经将该句删除，添加为

    #include "caffe/layers/sigmoid_cross_entropy_loss_layer.hpp"

    按照上面的步骤修改就可以编译成功了（需要把caffe中原来的sigmoid_cross_entropy_loss_layer.cu删掉）。

    收起
    展开全文

  • tensorflow实现二分类中加权的交叉熵损失函数

     千次阅读 2021-12-01 14:22:07
    在实际业务中往往需要改写loss函数，例如对正样本进行加权，然而tensorflow的api中并没有直接实现的方法可以调用。列如对所有正样本进行10倍加权，可以有以下两个实现方法： import tensorflow as tf # 设labels...
    收起
    python list tensorflow

  • PyTorch学习笔记——多分类交叉熵损失函数

     千次阅读 2021-01-30 16:39:49
    理解交叉熵关于样本集的两个概率分布p和q，设p为真实的分布，比如[1, 0, 0]表示当前样本属于第一类，q为拟合的分布，比如[0.7, 0.2, 0.1]。按照真实分布p来衡量识别一个样本所需的编码长度的期望，即平均编码长度...
    收起

  • 损失函数——交叉熵损失函数

     千次阅读 2020-07-22 10:46:40
    交叉熵代价函数（Cross-entropy cost function）是用来衡量人工神经网络（ANN）的预测值与实际值的一种方式。与二次代价函数相比，它能更有效地促进ANN的训练。在介绍交叉熵代价函数之前，本文先简要介绍二次代价...
    收起
    神经网络

  • pytorch自定义交叉熵损失函数

     千次阅读 2021-07-21 19:13:32
    2维测试交叉熵代码： 注意： output 维度是[batch_size,所分类预测值，样本数] label维度是[batch_size,样本数] output = torch.randn(3, 3,5, requires_grad=True) label = torch.empty((3,5), dtype=torch.long)....
    收起

  • torch自己实现交叉熵损失函数

     2021-03-16 16:00:58
    torch自己实现交叉熵损失函数torch实现交叉熵 torch实现交叉熵 import torch import torch.nn as nn import torch.nn.functional as F class Loss(torch.nn.Module): def __init__(self, reduction='mean'): super...
    收起

  • 二分类问题的sigmoid交叉熵损失函数推导

     千次阅读 2020-09-23 18:43:06
    要建立一个模型，不可或缺的有：1、数据，2、损失函数，3、模型算法，4、优化算法。 今天我们讨论下损失函数这块。损失函数的设计，与模型最后输出的内容是有一定关联的。 对于大部分的任务（回归 or 分类）,最大...
    收起

  • Keras中的几种交叉熵损失函数

     千次阅读 2020-07-21 14:00:39
    binary_crossentropy损失函数和softmax激活函数相匹配，适应两类别分类的问题。categorical_crossentropy损失函数和sigmoid激活函数相匹配，适应多类别分类的问题。 二、categorical_crossent..
    收起

  • Pytorch专题实战——交叉熵损失函数(CrossEntropyLoss )

     千次阅读 2020-04-30 20:18:31
    文章目录1.用CrossEntropyLoss预测单个目标2.用CrossEntropyLoss预测多个目标3.二分类使用BCELoss损失函数4....loss = nn.CrossEntropyLoss() #实例化交叉熵损失函数 Y = torch.tensor([0]) #预...
    收起
    Python 数据挖掘

  • 交叉熵作为损失函数在神经网络中的作用和几种常用的交叉熵损失函数

     千次阅读 2019-02-18 21:04:23
    交叉熵的作用  通过神经网络解决分类问题时，最常用的一种方式就是在最后一层设置n个输出节点，无论在浅层神经网络还是在CNN中都是如此的，比如，在AlexNet中最后输出层有1000个节点。 一般情况下，最后一个...
    收起

  • 二元交叉熵损失函数

     千次阅读 2021-11-15 11:08:01
    公式 L(w) = -∑i=0N\sum_{i=0}^N∑i=0N​[yilogσ\sigmaσ(xi) + ...其中，σ\sigmaσ(x)是sigmoid函数，即： σ\sigmaσ(x) = 11+e−z\frac{1}{1 + e^{-z}}1+e−z1​ 解释 可视化的方法解释对数损失 交叉熵详解 ...
    收起
    机器学习

  • 交叉熵损失函数

     万次阅读 多人点赞 2016-10-05 23:27:35
    交叉熵可在神经网络(机器学习)中作为损失函数，p表示真实标记的分布，q则为训练后的模型的预测标记分布，交叉熵损失函数可以衡量p与q的相似性。交叉熵作为损失函数还有一个好处是使用sigmoid函数在梯度下降时能避免...
    收起
    机器学习

  • 交叉熵损失函数的优点（转载）

     千次阅读 2020-12-19 05:16:08
    第一篇：利用一些饱和激活函数的如sigmoid激活时，假如利用均方误差损失，那么损失函数向最后一层的权重传递梯度时，梯度公式为可见梯度与最后一层的激活函数的导数成正比，...再看损失函数改成交叉熵损失时：此时...
    收起

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 7,605
精华内容 3,042
热门标签
关键字：

加权交叉熵损失函数