RNN损失函数如何定义 relu损失函数

文章目录

• 优化算法

• 1.SGD

• 损失函数

• 一、回归

• 1.误差平方和SSE (MSE)

• 二、分类

• 1.交叉熵损失函数

• 1. 二分类 交叉熵损失函数 (sigmoid) (BCEWithLogitsLoss / BCELoss)
• 2.多分类交叉熵损失函数(softmax) (CrossEntropyLoss / logsoftmax+NLLLoss实 )

• 激活函数

• 非线性激活函数

• 1.sigmoid函数 (torch.nn.Sigmoid)
• 2.RELU （torch.nn.ReLU）

小参考：十、损失函数与反向传播 、优化器

优化算法

torch.optim是一个实现各种优化算法的包。最常用的方法都已经支持了，接口也足够通用

optimizer = optim.SGD(model.parameters(), lr=0.01, momentum=0.9)
optimizer = optim.Adam([var1, var2], lr=0.0001)

• 采取优化步骤
  1、所有优化器都实现了一个step()更新参数的方法。它可以通过两种方式使用：optimizer.step()

optimizer = optim.SGD(model.parameters(), lr=0.01, momentum=0.9)
optimizer = optim.Adam([var1, var2], lr=0.0001)

for input, target in dataset:
    optimizer.zero_grad()
    output = model(input)
    loss = loss_fn(output, target)
    loss.backward()
    optimizer.step()

1.SGD

torch.optim.SGD(params, lr=<required parameter>, momentum=0, dampening=0, weight_decay=0, 			
				nesterov=False, *, maximize=False)

• params ( iterable ) – 可迭代的参数以优化或定义参数组
• lr ( float ) – 学习率
• momentum -动量因子

import torch.optim as optim
#定义优化算法
opt = optim.SGD(net.parameters() #要优化的参数是哪些？
               , lr=lr #学习率
               , momentum = gamma) #动量参数

zhat = net.forward(X) #向前传播
loss = criterion(zhat,y.reshape(500).long()) #损失函数值
loss.backward() #反向传播
opt.step() #更新权重w，从这一瞬间开始，坐标点就发生了变化，所有的梯度必须重新计算
opt.zero_grad() #清除原来储存好的，基于上一个坐标点计算的梯度，为下一次计算梯度腾出空间

损失函数

一、回归

1.误差平方和SSE (MSE)

公式：

import torch
from torch.nn import MSELoss #类
yhat = torch.randn(size=(50,),dtype=torch.float32) 
y = torch.randn(size=(50,),dtype=torch.float32)
criterion = MSELoss() #实例化
loss = criterion(yhat,y)
loss #没有设置随机数种子，所以每次运行的数字都会不一致
#tensor(1.5714)

#在MSELoss中有重要的参数，reduction
#当reduction = "mean" (默认也是mean)，则输出MSE
#当reduction = "sum"，则输出SSE
criterion = MSELoss(reduction = "mean") #实例化
criterion(yhat,y)
#tensor(1.5714)
criterion = MSELoss(reduction = "sum")
criterion(yhat,y)
#tensor(78.5707)

二、分类

1.交叉熵损失函数

1. 二分类 交叉熵损失函数 (sigmoid) (BCEWithLogitsLoss / BCELoss)

• BCEWithLogitsLoss内置了sigmoid函数与交叉熵函数，它会自动计算输入值的sigmoid值，因此需要输入zhat与真实标签，且顺序不能变化，zhat必须在前。
• BCELoss中只有交叉熵函数，没有sigmoid层，因此需要输入sigma与真实标签，且顺序不能变化。

import torch
import time
N = 3*pow(10,3)
torch.random.manual_seed(420) 
X = torch.rand((N,4),dtype=torch.float32) 
w = torch.rand((4,1),dtype=torch.float32,requires_grad=True) 
y = torch.randint(low=0,high=2,size=(N,1),dtype=torch.float32) #high取不到
zhat = torch.mm(X,w)
sigma = torch.sigmoid(zhat)

import torch.nn as nn
#调用nn模块下的类
criterion = nn.BCELoss() #实例化
loss = criterion(sigma,y) #真实标签在后
loss
#tensor(0.8685, grad_fn=<BinaryCrossEntropyBackward0>)

criterion2 = nn.BCEWithLogitsLoss() #实例化
loss = criterion2(zhat,y) #真实标签在后
loss
#tensor(0.8685, grad_fn=<BinaryCrossEntropyWithLogitsBackward0>)

第二种方法很少用，我们了解一下即可：

from torch.nn import functional as F #直接调用functional库中的计算函数
F.binary_cross_entropy_with_logits(zhat,y) 
#tensor(0.8685, grad_fn=<BinaryCrossEntropyWithLogitsBackward0>)

F.binary_cross_entropy(sigma,y)
#tensor(0.8685, grad_fn=<BinaryCrossEntropyBackward0>)

2.多分类交叉熵损失函数(softmax) (CrossEntropyLoss / logsoftmax+NLLLoss实 )

在PyTorch中实现交叉熵函数的时候，有两种办法：

• 方法一：调用logsoftmax和NLLLoss实现

import torch
import torch.nn as nn
N = 3*pow(10,2)
torch.random.manual_seed(420) 
X = torch.rand((N,4),dtype=torch.float32) 
w = torch.rand((4,3),dtype=torch.float32,requires_grad=True) 
#定义y时应该怎么做？应该设置为矩阵吗？
y = torch.randint(low=0,high=3,size=(N,),dtype=torch.float32)
zhat = torch.mm(X,w) #从这里开始调用softmax和NLLLoss

logsm = nn.LogSoftmax(dim=1) #实例化
logsigma = logsm(zhat)

criterion = nn.NLLLoss() #实例化
#由于交叉熵损失需要将标签转化为独热形式，因此不接受浮点数作为标签的输入
#对NLLLoss而言，需要输入logsigma
criterion(logsigma,y.long()) #y一维、整型
#tensor(1.1591, grad_fn=<NllLossBackward0>)

• 方法二：直接调用CrossEntropyLoss

criterion = nn.CrossEntropyLoss()
#对打包好的CorssEnrtopyLoss而言，只需要输入zhat
criterion(zhat,y.long()) #一维、整型
#tensor(1.1591, grad_fn=<NllLossBackward0>)

可以发现，两种输出方法得到的损失函数结果是一致的。与其他损失函数一致，CrossEntropyLoss也有参数reduction，可以设置为mean、sum以及None，大家可以自行尝试其代码并查看返回结果。

激活函数

非线性激活函数

1.sigmoid函数 (torch.nn.Sigmoid)

2.RELU （torch.nn.ReLU）