Tabla de contenido
Funciones de pérdida y retropropagación
Funciones de pérdida y retropropagación
Todas las funciones de cálculo de pérdida requeridas se encuentran en LossFunctions de torch.nn. El sitio web oficial es: torch.nn: documentación de PyTorch 2.0 . Los ejemplos incluyen L1Loss , MSELoss y CrossEntropyLoss .
En el uso de estas funciones de pérdida, hay que tener en cuenta los siguientes puntos:
(1) El parámetro reducción = 'media', el valor predeterminado es 'media' para indicar la suma de las diferencias, y también puede ser 'suma' para no calcular la media.
(2) Asegúrese de prestar atención a la forma de la entrada y el objetivo.
Pérdida L1
Cree un criterio que mida Input: x xx y target: y yy entre cada elemento de la medida.
Cree un criterio que mida el error absoluto medio (MAE) (L 1 L_1L 1 norma) entre cada elemento en Input: x xx y target: y yy .
Forma :
Entrada: (∗ *∗), donde ∗ *∗ significa cualquier número de dimensiones. Se promediará la pérdida de todas las dimensiones. Objetivo
: (∗ *∗), misma forma que la entrada. Misma forma que la entrada Salida
: escalar. El valor devuelto es un escalar
Suponiendo que aa es un escalar, entonces:
tipo(a) = antorcha.Tensor
a.forma = antorcha.Tamaño([])
a.dim = 0
MSELOSS
Cree un criterio que mida el error cuadrático medio (norma L2 cuadrada) entre cada elemento en Input: x xx y target: y yy .
Forma:
Entrada: (∗ *∗), donde ∗ *∗ significa cualquier número de dimensiones. La pérdida se calculará para todas las dimensiones.
Objetivo: (∗ *∗), misma forma que la entrada. Misma forma que la entrada. Salida
: escalar. La el valor de retorno es escalar.
CrossEntropyLoss
Este criterio calcula la pérdida de entropía cruzada entre la entrada y el objetivo.
Es muy adecuado para entrenar problemas de clasificación de clases C CC (es decir, problemas de clasificación múltiple, si es un problema de clasificación binaria, se puede usar BCELoss). Si se proporciona un peso de parámetro opcional, el peso debe establecerse en un tensor 1D para asignar pesos a cada clase. Esto es especialmente útil cuando el conjunto de entrenamiento está desequilibrado.
La entrada deseada debe contener las puntuaciones sin normalizar sin procesar para cada clase. La entrada debe ser de tamaño C CC (la entrada no se procesa por lotes), (minibatch , C minibatch,Cminibatch,C) o (minibatch , C , d 1 , d 2 , . . . d kminibatch,C,d_1,d_2,. .d_kminibatch,C,d 1,d 2,...d k ) Tensor. El último método es adecuado para entradas de alta dimensión, como calcular la pérdida de entropía cruzada por píxel de imágenes 2D.
El objetivo esperado debe contener uno de los siguientes:
(1) (objetivo contiene) índice de categoría en [ 0 , C ) [0,C)[0,C) intervalo, C CC es el número total de categorías. Si se especifica ignore_index, esta pérdida también acepta tales índices (este índice no es necesariamente para toda la clase). La pérdida en el caso de reducción='ninguna' es
Nota: log loglog tiene como valor predeterminado la base 10.
x es la entrada, y yy es el objetivo, w ww es el peso, C CC es el número de categorías, N NN cubre las dimensiones del minibatch y d 1 , d 2 . . . , dk d_1,d_2...,d_kd 1,d 2 .., d k representan la k-ésima dimensión respectivamente. (N es demasiado difícil de traducir, siempre siento que la traducción es incorrecta) Si reducción = 'media' o 'suma',
import torch
import torchvision
from torch import nn
from torch.nn import Conv2d, MaxPool2d, Flatten, Linear, Sequential
from torch.utils.data import DataLoader
from torchvision.transforms import transforms
dataset = torchvision.datasets.CIFAR10('./dataset', train=False, transform=transforms.ToTensor(), download=True)
dataloader = DataLoader(dataset, batch_size=2, shuffle=True)
class Model(nn.Module):
def __init__(self):
super(Model, self).__init__()
self.model = Sequential(
Conv2d(in_channels=3, out_channels=32, kernel_size=5, stride=1, padding=2),
MaxPool2d(kernel_size=2, stride=2),
Conv2d(in_channels=32, out_channels=32, kernel_size=5, stride=1, padding=2),
MaxPool2d(kernel_size=2, stride=2),
Conv2d(in_channels=32, out_channels=64, kernel_size=5, stride=1, padding=2),
MaxPool2d(kernel_size=2, stride=2),
Flatten(),
Linear(1024, 64),
Linear(64, 10)
)
def forward(self, x): # 模型前向传播
return self.model(x)
model = Model() # 定义模型
loss_cross = nn.CrossEntropyLoss() # 定义损失函数
for data in dataloader:
imgs, targets = data
outputs = model(imgs)
# print(outputs) # 先打印查看一下结果。outputs.shape=(2, 10) 即(N,C)
# print(targets) # target.shape=(2) 即(N)
# 观察outputs和target的shape，然后选择使用哪个损失函数
res_loss = loss_cross(outputs, targets)
res_loss.backward() # 损失反向传播
print(res_loss)
#
# inputs = torch.tensor([1, 2, 3], dtype=torch.float32)
# targets = torch.tensor([1, 2, 5], dtype=torch.float32)
#
# inputs = torch.reshape(inputs, (1, 1, 1, 3))
# targets = torch.reshape(targets, (1, 1, 1, 3))
#
# # -------------L1Loss--------------- #
# loss = nn.L1Loss()
# res = loss(inputs, targets) # 返回的是一个标量,ndim=0
# print(res) # tensor(1.6667)
#
# # -------------MSELoss--------------- #
# loss_mse = nn.MSELoss()
# res_mse = loss_mse(inputs, targets)
# print(res_mse)
#
# # -------------CrossEntropyLoss--------------- #
# x = torch.tensor([0.1, 0.2, 0.3]) # (N,C)
# x = torch.reshape(x, (1, 3))
# y = torch.tensor([1]) # (N)
# loss_cross = nn.CrossEntropyLoss()
# res_cross = loss_cross(x, y)
# print(res_cross)