深度学习笔记

深度学习笔记(一)——损失函数 闲聊

关于摸鱼太久了，玩久了到有点愧疚，所以决定好好学习一下基础，免得到时候姓啥都不知道了。希望能够少摸鱼吧~

损失函数

损失函数定义：在训练机器学习算法中，为了获得最佳模型性能的最佳参数，我们需要一种函数来衡量我们模型的运行情况。函数通过惩罚我们模型(通过分配损失值)相对于当前参数所犯的任何参数，使得我们找到损失值最小的最佳参数。这个函数便称为损失函数。

交叉熵损失函数(Cross-entropy loss function)

交叉熵损失函数可能是使用最多的损失函数了，所以重点讲一下

交叉熵H(p,q)的定义是，其中log是以e为底的：

其中p为真实概率的分布，q为预测的概率分布。因此

交叉熵损失函数的二分类问题中，公式如下：

其中：x为样本，y为实际标签，a为预测的输出，n为样本总量。输入一般为softmax或者sigmoid函数的输出。

在多分类问题中，公式为：

输入一般为softmax或者sigmoid函数的输出。

以softmax的输出为例，softmax函数输出是一个和为一的概率向量。

假如一个鸡鸭鹅的三分类数据集，假如一个batch有三个输入，通过之前的网络，得到结果是（[10,8,6],[7,9,5],[5,4,10])。
实际的标签值为[0,1,2],即是鸡鸭鹅。

import torch 
import torch.nn as nn
import math
import time
# 假设结果
input_1=torch.Tensor([0,1,2])
# 预测结果
input_2 = torch.Tensor([
                        [10,8,6],
                        [7,9,5],
                        [5,4,10]
                        ])
#规定不同方向的softmax
softmax = nn.Softmax(dim=1)
#对不同维度的张量试验
output = softmax(input_2)
print(output)
#------------#
#tensor([[0.8668, 0.1173, 0.0159],
#        [0.1173, 0.8668, 0.0159],
#       [0.0067, 0.0025, 0.9909]])
#------------#

表示含义是：网络推测鸡的概率为[86.68%],鸭[11.73%],鹅[1.59%]，后面两行同理。
关于softmax的推理，可能计划在后面进行，这里就略过。

使用方法

import torch.nn as nn
nn.CrossEntropyLoss()

后面使用交叉熵损失函数进行计算

#直接使用pytorch中的loss_func=nn.CrossEntropyLoss()看与经过NLLLoss的计算是不是一样
crossentropyloss=nn.CrossEntropyLoss()
crossentropyloss_output1=crossentropyloss(output[0],input_1[0].long())
print('crossentropyloss_output[0]:',crossentropyloss_output1)
crossentropyloss_output2=crossentropyloss(output[1],input_1[1].long())
print('crossentropyloss_output[1]:',crossentropyloss_output2)
crossentropyloss_output3=crossentropyloss(output[2],input_1[2].long())
print('crossentropyloss_output[2]:',crossentropyloss_output3)
print('crossentropyloss_output:',(crossentropyloss_output1+crossentropyloss_output2+crossentropyloss_output3)/3)
crossentropyloss_output=crossentropyloss(output,input_1.long())
print('crossentropyloss_output:',crossentropyloss_output)
#------------------------#
#crossentropyloss_output[0]: tensor(0.6417)
#crossentropyloss_output[1]: tensor(0.6417)
#crossentropyloss_output[2]: tensor(0.5573)
#通过分开运算在求平均和用公式直接运算结果是相同的
#crossentropyloss_output: tensor(0.6135)
#crossentropyloss_output: tensor(0.6135)
#-----------------------#

通过上面的计算可以知道这个batch的loss为0.6135。

---

均方误差损失函数(Mean squared error function)

均方误差是指参数估计值与参数真值之差平方的期望值; MSE可以评价数据的变化程度，MSE的值越小，说明预测模型描述实验数据具有更好的精确度。（ i 表示第 i 个样本，N 表示样本总数）经常用于回归问题，通常用来做回归问题的代价函数。

优点：是光滑的函数，求导方便
缺点：容易造成梯度爆炸

import torch 
import torch.nn as nn

loss_MSE=nn.MSELoss()

x=torch.randn(100,100)
y=torch.randn(100,100)

loss=loss_MSE(x,y)

print(loss)
#tensor(2.0125)

---

smooth L1 loss

常用于目标检测，是fasterRCNN中的RPN的回归框的loss计算方法

import torch 
import torch.nn as nn

x=torch.randn(100,100)
y=torch.randn(100,100)
crit = torch.nn.SmoothL1Loss()

loss=crit(x,y)

print(loss)
#tensor(0.7194)

---

平均绝对误差函数

平均绝对误差是绝对误差的平均值 ，平均绝对误差能更好地反映预测值误差的实际情况。通常用来作为回归算法的性能指标。

import torch 
import torch.nn as nn
loss_MAE=nn.L1Loss()
x=torch.randn(100,100)
y=torch.randn(100,100)
loss=loss_MAE(x,y)
print(loss)
#tensor(1.1246)

---

Hinge 损失函数

特点：
(1)hinge损失函数表示如果被分类正确，损失为0，否则损失就为1-yf(x)。SVM就是使用这个损失函数。
(2)一般的f(x)是预测值，在-1到1之间，y是目标值(-1或1)。其含义是，f(x)的值在-1和+1之间就可以了，并不鼓励|f(x)|>1 ，即并不鼓励分类器过度自信，让某个正确分类的样本距离分割线超过1并不会有任何奖励，从而使分类器可以更专注于整体的误差。
(3) 健壮性相对较高，对异常点、噪声不敏感，但它没太好的概率解释。

import torch 
import torch.nn as nn


class MyHingeLoss(torch.nn.Module):
    # 不要忘记继承Module
    def __init__(self):
        super(MyHingeLoss, self).__init__()
 
    def forward(self, output, target):
        """output和target都是1-D张量,换句话说,每个样例的返回是一个标量.
        """
        hinge_loss = 1 - torch.mul(output, target)
        hinge_loss[hinge_loss < 0] = 0
        # 不要忘记返回scalar
        return torch.mean(hinge_loss)
x=torch.randn(100,100)
y=torch.randn(100,100)

HingeLoss=MyHingeLoss()
loss=HingeLoss(x,y)

print(loss)

---

HingeEmbeddingLoss

它输入x和y（1或者-1），margin默认为1。

1. 当y=-1的时候，loss=max(0,1-x)，如果x>1（margin），则loss=0；如果x<1，loss=1-x
2. 当y=1，loss=x
   通常用于非线性embedding，半监督学习，检测两个输入的相似性或者不相似性

import torch 
import torch.nn as nn

x=torch.randn(100,100)
y=torch.randn(100,100)
Hinge_Embedding_Loss=torch.nn.HingeEmbeddingLoss(margin=1.0,  reduction='mean')

loss=Hinge_Embedding_Loss(x,y)

print(loss)