Table des matières
Fonctions de perte et rétropropagation
Fonctions de perte et rétropropagation
Les fonctions de calcul de perte requises se trouvent toutes dans LossFunctions de torch.nn. Le site Web officiel est : torch.nn - documentation PyTorch 2.0 . Les exemples incluent L1Loss , MSELoss et CrossEntropyLoss .
Dans l'utilisation de ces fonctions de perte, il y a les points suivants à noter :
(1) Le paramètre reduction='mean', la valeur par défaut est 'mean' pour signifier la somme des différences, et il peut aussi être 'sum' pour pas calculer la moyenne.
(2) Assurez-vous de faire attention à la forme de l'entrée et de la cible.
Perte L1
Créez un critère qui mesure Entrée : x xx et cible : y yy entre chaque élément de la mesure.
Créez un critère qui mesure l'erreur absolue moyenne (MAE) (norme L 1 L_1L 1) entre chaque élément dans Input: x xx et target: y yy .
Forme :
Entrée : (∗ *∗), où ∗ *∗ signifie n'importe quel nombre de dimensions. La perte de toutes les dimensions sera moyennée
Cible : (∗ *∗), même forme que l'entrée. Même forme que l'entrée Sortie
: scalaire. La valeur de retour est un scalaire.
En supposant que aa est un scalaire, alors :
type(a) = torche.Tensor
a.shape = torche.Taille([])
a.dim = 0
MSELOSS
Créez un critère qui mesure l'erreur quadratique moyenne (norme L2 au carré) entre chaque élément dans Entrée : x xx et cible : y yy .
Forme:
Entrée : (∗ *∗), où ∗ *∗ signifie n'importe quel nombre de dimensions. La perte sera calculée pour toutes les dimensions.
Cible : (∗ *∗), même forme que l'entrée. Même forme que l'entrée.
Sortie : scalaire. Le la valeur de retour est scalaire.
CrossEntropyLoss
Ce critère calcule la perte d'entropie croisée entre l'entrée et la cible.
Il est très approprié pour la formation des problèmes de classification de classe C CC (c'est-à-dire des problèmes de multi-classification, s'il s'agit d'un problème de classification binaire, BCELoss peut être utilisé). Si un poids de paramètre facultatif est fourni, le poids doit être défini sur un tenseur 1D pour attribuer des poids à chaque classe. Ceci est particulièrement utile lorsque l'ensemble d'entraînement est déséquilibré.
L'entrée souhaitée doit contenir les scores bruts non normalisés pour chaque classe. L'entrée doit être de taille C CC (l'entrée n'est pas batch), (minibatch , C minibatch,Cminibatch,C) ou (minibatch , C , d 1 , d 2 , . . . d kminibatch,C,d_1,d_2,. .d_kminibatch,C,d 1,d 2,...d k ) Tenseur. La dernière méthode convient aux entrées de grande dimension, telles que le calcul de la perte d'entropie croisée par pixel des images 2D.
La cible attendue doit contenir l'un des éléments suivants :
(1) (cible contient) index de catégorie dans [ 0 , C ) [0,C)[0,C) intervalle, C CC est le nombre total de catégories. Si ignore_index est spécifié, cette perte accepte également de tels index (cet index n'est pas nécessairement à l'échelle de la classe). La perte dans le cas de reduction='none' est
Remarque : log loglog est par défaut en base 10.
x est l'entrée, y yy est la cible, w ww est le poids, C CC est le nombre de catégories, N NN couvre les dimensions du mini-lot et d 1 , d 2 . . . , dk d_1,d_2...,d_kd 1,d 2 .., d k représentent respectivement la kième dimension. (N est trop difficile à traduire, j'ai toujours l'impression que la traduction est fausse) Si réduction='moyenne' ou 'somme',
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)