神经网络loss函数意义_lossfunction

神经网络loss函数意义_lossfunctionL1Loss平均绝对误差(MAE),用于回归模型对于包含NNN个样本的batch数据D(x,y)D(x,y)D(x,y),losslossloss计算如下:loss=1N∑n=1Nlnloss=\frac{1}{N}\sum_{n=1}^{N}l_{n}loss=N1​∑n=1N​ln​其中,ln=∣xn−yn∣l_{n}=\left|x_{n}-y_{n}\right|ln​=∣xn​−yn​∣classL1Loss(_Loss):__constants__=[‘redu

大家好,又见面了,我是你们的朋友全栈君。如果您正在找激活码,请点击查看最新教程,关注关注公众号 “全栈程序员社区” 获取激活教程,可能之前旧版本教程已经失效.最新Idea2022.1教程亲测有效,一键激活。

Jetbrains全系列IDE使用 1年只要46元 售后保障 童叟无欺

L1Loss

平均绝对误差(MAE),用于回归模型

对于包含 N N N个样本的batch数据 D ( x , y ) D(x, y) D(x,y) x x x为神经网络的输出, y y y是真实的得分, x x x y y y同维度。

n n n个样本的损失值 l n l_{n} ln计算如下:

l n = ∣ x n − y n ∣ l_{n}=\left|x_{n}-y_{n}\right| ln=xnyn

其中, y n y_{n} yn代表第 n n n样本的真实得分,可能对应一个值,也可能多个值,代表样本不同方面的得分,所以 l n l_{n} ln可能是一个值,也可能是一个向量。

class L1Loss(_Loss):
    def __init__(self, size_average=None, reduce=None, reduction='mean'):
        super(L1Loss, self).__init__(size_average, reduce, reduction)
    def forward(self, input, target):
        return F.l1_loss(input, target, reduction=self.reduction)

pytorch中通过torch.nn.L1Loss类实现,也可以直接调用F.l1_loss 函数,代码中的size_averagereduce已经弃用。reduction有三种取值mean, sum, none,对应不同的返回 ℓ ( x , y ) \ell(x, y) (x,y)。 默认为mean,对 L L L中所有元素求平均,对应于一般情况下的 l o s s loss loss的计算。

L = { l 1 , … , l N } L=\left\{l_{1}, \ldots, l_{N}\right\} L={
l1,,lN}

ℓ ( x , y ) = { L ⁡ ,  if reduction  =  ’none’  mean ⁡ ( L ) ,  if reduction  =  ’mean’  sum ⁡ ( L ) ,  if reduction  =  ’sum’  \ell(x, y)=\left\{\begin{array}{ll}\operatorname L, & \text { if reduction }=\text { ‘none’ } \\ \operatorname{mean}(L), & \text { if reduction }=\text { ‘mean’ } \\ \operatorname{sum}(L), & \text { if reduction }=\text { ‘sum’ }\end{array} \right. (x,y)=L,mean(L),sum(L), if reduction = ’none’  if reduction = ’mean’  if reduction = ’sum’ 

MSELoss

均方误差(MSE),用于回归模型

对于包含 N N N个样本的batch数据 D ( x , y ) D(x, y) D(x,y) x x x为神经网络的输出, y y y是真实的得分。

n n n个样本的损失值 l n l_{n} ln计算如下:

l n = ( x n − y n ) 2 l_{n}=\left(x_{n}-y_{n}\right)^{2} ln=(xnyn)2

其中, y n y_{n} yn代表第 n n n样本的真实得分,可能对应一个值,也可能多个值,代表样本不同方面的得分,所以 l n l_{n} ln可能是一个值,也可能是一个向量。

class MSELoss(_Loss):
    def __init__(self, size_average=None, reduce=None, reduction='mean'):
        super(MSELoss, self).__init__(size_average, reduce, reduction)
    def forward(self, input, target):
        return F.mse_loss(input, target, reduction=self.reduction)

pytorch中通过torch.nn.MSELoss类实现,也可以直接调用F.mse_loss 函数。代码中的size_averagereduce已经弃用。reduction有三种取值mean, sum, none,对应不同的返回 ℓ ( x , y ) \ell(x, y) (x,y)。默认为mean,对 L L L中所有元素求平均,对应于一般情况下的 l o s s loss loss的计算。

L = { l 1 , … , l N } L=\left\{l_{1}, \ldots, l_{N}\right\} L={
l1,,lN}

ℓ ( x , y ) = { L ⁡ ,  if reduction  =  ’none’  mean ⁡ ( L ) ,  if reduction  =  ’mean’  sum ⁡ ( L ) ,  if reduction  =  ’sum’  \ell(x, y)=\left\{\begin{array}{ll}\operatorname L, & \text { if reduction }=\text { ‘none’ } \\ \operatorname{mean}(L), & \text { if reduction }=\text { ‘mean’ } \\ \operatorname{sum}(L), & \text { if reduction }=\text { ‘sum’ }\end{array} \right. (x,y)=L,mean(L),sum(L), if reduction = ’none’  if reduction = ’mean’  if reduction = ’sum’ 

SmoothL1Loss

分段使用均方误差和平均绝对误差,用于回归模型

对于包含 N N N个样本的batch数据 D ( x , y ) D(x, y) D(x,y) x x x为神经网络的输出, y y y是真实的得分。

n n n个样本的损失值 l n l_{n} ln计算如下:

l n = { 0.5 ( x n − y n ) 2 /  beta  ,  if  ∣ x n − y n ∣ <  beta  ∣ x n − y n ∣ − 0.5 ∗  beta  ,  otherwise  l_{n}=\left\{\begin{array}{ll}0.5\left(x_{n}-y_{n}\right)^{2} / \text { beta }, & \text { if }\left|x_{n}-y_{n}\right|<\text { beta } \\ \left|x_{n}-y_{n}\right|-0.5 * \text { beta }, & \text { otherwise }\end{array}\right. ln={
0.5(xnyn)2/ beta ,xnyn0.5 beta , if xnyn< beta  otherwise 

其中, y n y_{n} yn代表第 n n n样本的真实得分,可能对应一个值,也可能多个值,代表样本不同方面的得分,所以 l n l_{n} ln可能是一个值,也可能是一个向量。

相比平均绝对误差,SmoothL1Loss平滑了 ∣ x n − y n ∣ \left|x_{n}-y_{n}\right| xnyn趋近于0时的误差。相比均方误差函数,SmoothL1Loss对离群点更不敏感。在一定程度上可以防止梯度爆炸问题。Fast R-CNN论文有详细论述。

class SmoothL1Loss(_Loss):
    def __init__(self, size_average=None, reduce=None, reduction: str = 'mean', beta: float = 1.0) -> None:
        super(SmoothL1Loss, self).__init__(size_average, reduce, reduction)
        self.beta = beta
    def forward(self, input: Tensor, target: Tensor) -> Tensor:
        return F.smooth_l1_loss(input, target, reduction=self.reduction, beta=self.beta)

pytorch中通过torch.nn.SmoothL1Loss类实现,也可以直接调用F.smooth_l1_loss 函数。代码中的size_averagereduce已经弃用。reduction有三种取值mean, sum, none,对应不同的返回 ℓ ( x , y ) \ell(x, y) (x,y)。默认为mean,对 L L L中所有元素求平均,对应于一般情况下的 l o s s loss loss的计算。

L = { l 1 , … , l N } L=\left\{l_{1}, \ldots, l_{N}\right\} L={
l1,,lN}

ℓ ( x , y ) = { L ⁡ ,  if reduction  =  ’none’  mean ⁡ ( L ) ,  if reduction  =  ’mean’  sum ⁡ ( L ) ,  if reduction  =  ’sum’  \ell(x, y)=\left\{\begin{array}{ll}\operatorname L, & \text { if reduction }=\text { ‘none’ } \\ \operatorname{mean}(L), & \text { if reduction }=\text { ‘mean’ } \\ \operatorname{sum}(L), & \text { if reduction }=\text { ‘sum’ }\end{array} \right. (x,y)=L,mean(L),sum(L), if reduction = ’none’  if reduction = ’mean’  if reduction = ’sum’ 

参数 b e t a > = 0 beta>=0 beta>=0,默认为1

HuberLoss

分段使用均方误差和平均绝对误差,用于回归模型

对于包含 N N N个样本的batch数据 D ( x , y ) D(x, y) D(x,y) x x x为神经网络的输出, y y y是真实的得分。

n n n个样本的损失值 l n l_{n} ln计算如下:

l n = { 0.5 ( x n − y n ) 2 ,  if  ∣ x n − y n ∣ <  beta   beta  ∗ ( ∣ x n − y n ∣ − 0.5 ∗  beta  ) ,  otherwise  l_{n}=\left\{\begin{array}{ll}0.5\left(x_{n}-y_{n}\right)^{2}, & \text { if }\left|x_{n}-y_{n}\right|<\text { beta } \\ \text { beta }*(\left|x_{n}-y_{n}\right|-0.5 * \text { beta }), & \text { otherwise }\end{array}\right. ln={
0.5(xnyn)2, beta (xnyn0.5 beta ), if xnyn< beta  otherwise 

对比SmoothL1LossHuberLoss公式可知, HuberLoss = beta ∗ SmoothL1Loss \text {HuberLoss}= \text {beta}* \text {SmoothL1Loss} HuberLoss=betaSmoothL1Loss,两者有如下区别:

  • b e t a beta beta趋于0时,SmoothL1Loss收敛于L1Loss, HuberLoss收敛于常数0
  • b e t a beta beta趋于无穷时,SmoothL1Loss收敛于常数0,HuberLoss收敛于MSELoss
  • 随着 b e t a beta beta的变化,SmoothL1Loss中平均绝对误差段的斜率恒定为1;而HuberLos中平均绝对误差段的斜率是 b e t a beta beta

SmoothL1Loss 例子:

import torch
import torch.nn as nn
import math


def validate_loss(output, target, beta):
    val = 0
    for li_x, li_y in zip(output, target):
        for i, xy in enumerate(zip(li_x, li_y)):
            x, y = xy
            if math.fabs(x - y) < beta:
                loss_val = 0.5 * math.pow(x - y, 2) / beta
            else:
                loss_val = math.fabs(x - y) - 0.5 * beta
            val += loss_val
    return val / output.nelement()


beta = 1
loss_fct = nn.SmoothL1Loss(reduction="mean", beta=beta)
input_src = torch.Tensor([[0.8, 0.8], [0.9, 0.9], [0.3, 0.3]])
target = torch.Tensor([[0.6, 0.6], [0.7, 0.8], [0.4, 0.5]])
print(input_src.size())
print(target.size())
loss = loss_fct(input_src, target)
print(loss.item())

validate = validate_loss(input_src, target, beta)
print(validate)

loss_fct = nn.SmoothL1Loss(reduction="none", beta=beta)
loss = loss_fct(input_src, target)
print(loss)

输出结果:

torch.Size([3, 2])
torch.Size([3, 2])
0.01499999687075615
0.014999997715155441
tensor([[0.0200, 0.0200],
        [0.0200, 0.0050],
        [0.0050, 0.0200]])
版权声明:本文内容由互联网用户自发贡献,该文观点仅代表作者本人。本站仅提供信息存储空间服务,不拥有所有权,不承担相关法律责任。如发现本站有涉嫌侵权/违法违规的内容, 请发送邮件至 举报,一经查实,本站将立刻删除。

发布者:全栈程序员-用户IM,转载请注明出处:https://javaforall.cn/192294.html原文链接:https://javaforall.cn

【正版授权,激活自己账号】: Jetbrains全家桶Ide使用,1年售后保障,每天仅需1毛

【官方授权 正版激活】: 官方授权 正版激活 支持Jetbrains家族下所有IDE 使用个人JB账号...

(0)


相关推荐

  • 匹配滤波器及matlab仿真

    匹配滤波器及matlab仿真随机信号处理笔记:匹配滤波器——南京理工大学顾红老师的《随机信号处理》浅析文章目录随机信号处理笔记:匹配滤波器1.线性滤波器输出端信噪比2.匹配滤波器的传输函数和冲激响应2.1复函数的施瓦兹不等式2.2传输函数求解3.匹配滤波器的性质3.1匹配滤波器的最大峰值信噪比3.2匹配滤波器的幅频特性相频特性3.3匹配滤波器的物理可实现性3.4输出信号和噪声3.5匹配滤波器的时延适应性3.6匹配滤波器的频移不适应性3.7输出信号频谱与输入信号频谱关系4.匹配滤波器的信号处理SNR增益4.1matlab仿真匹配

  • Some STR Fun

    Some STR Fun

  • matlab灰度最大值和最小值_matlab灰度直方图

    matlab灰度最大值和最小值_matlab灰度直方图这里有两个版本的泛洪填充算法:第一个,更简单的一个包含两个未定义的变量,但这是一个工作版本:importnumpyasnpimportscipyasspimportscipy.ndimagedefflood_fill(test_array,h_max=255):input_array=np.copy(test_array)el=sp.ndimage.generate_bin…

  • 通过页码直接跳转 html

    通过页码直接跳转 html

    2021年10月20日
  • SAXReader 解析xml「建议收藏」

    SAXReader 解析xml「建议收藏」使用SAXReader解析xmlSAXReader的read方法有几种不同的重载,大概包括以下几种1.read(Filefile) 传入文件对象2.read(InputSourcein)传入InputSource3.read(InputStreamin) 传入流……其实最终的格式都是转换为InputSource的格式packageD

  • 【更新】互联网公司可投之参考[通俗易懂]

    【更新】互联网公司可投之参考[通俗易懂]【更新】互联网公司可投之参考以下内容收集于网络资料,仅供参考。如有误请指正~,未经允许,禁止转载。不介意的话,放个自己的字节内推,投递链接https://jobs.toutiao.com/s/dp5bxEK,内推码:AJCWZR2北京公司上海公司广州公司深圳公司武汉公司杭州公司成都公司成都公司长沙公司…小伙伴们觉得有用的话可以关注点赞收藏,后面持续更新~以下内容收集于网络资料,仅供参考。如有误请指正~,未经允许,禁止转载。#目前已更新:北京、上海、广州、深圳、武汉、杭州、成都、南京、长沙…不介意的

发表回复

您的电子邮箱地址不会被公开。

关注全栈程序员社区公众号