神经网络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)


相关推荐

  • iOS layoutSubviews 调用[通俗易懂]

    iOS layoutSubviews 调用[通俗易懂]在初始化时,使用init和-(instancetype)initWithFrame:(CGRect)frame,但是,在调用时是有系统区分的,iOS11.0以下,调用init和-(instancetype)initWithFrame:(CGRect)frame当frame为CGRectZero是不会调用的, 在调用addSubView时,这个跟添加的subView尺寸大小没有关系。 改变…

  • 高速电平转换芯片_电平转换电路分压

    高速电平转换芯片_电平转换电路分压现在很多SOC器件为了降低功耗,都把IO口的电平设计成了1.8V,核电压0.85V,当这种SOC做主平台时,在做接口设计需要格外关注电平的匹配。单板中经常需要将1.8V的电平转换成3.3V或者转成5V。如果没有注意到输入和输出信号之间的电平匹配,系统就无法正常工作。这篇文章主要从两个简单的案例入手,分析电平转换电路需要注意的一些问题,以及在此类芯片数据手册中几个重要参数的解读,对开发人员来说,掌握这些器件的参数是器件选型必须关注的点。三极管做电平转换以常见的三极管做1.8V转3.3V为案例。电路图

  • Oracle数据库双机热备方案「建议收藏」

    http://blog.chinaunix.net/uid-25806228-id-2141469.html1.方案综述OracleFailSafe是架构在MicrosoftClusterServer(MSCS)上的一个Oracle产品,为Oracle的一些产品(数据库、OracleApplicationServer等)提供高可用性。提供

  • curl 的用法指南「建议收藏」

    curl 的用法指南「建议收藏」curl 的用法指南

  • python格式化转换_Python进制转换format格式化[通俗易懂]

    python格式化转换_Python进制转换format格式化[通俗易懂]>>>bin(13)’0b1101’十进制转成八进制和十六进制'{0:x}’.format(20)转换成十六进制'{0:o}’.format(20)转换成八进制进制转换的时候用{0:进制}八进制转为二进制:比如八进制数(37)8拆开373用二进制表示为117用二进制表示为111合起来即为1111…

  • json转对象时一直报错

    json转对象时一直报错json转对象时一直报错

发表回复

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

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