Verliesfuncties in PyTorch

Inleiding

Verliesfuncties zijn fundamenteel in het trainen van machine learning modellen en in de meeste machine learning projecten is er geen andere manier om uw model tot correcte voorspellingen te drijven dan met behulp van een verliesfunctie. In de volksmond is een verliesfunctie een wiskundige functie of expressie die wordt gebruikt om te meten hoe goed een model presteert op een bepaald dataset. Het begrip hoe goed een model presteert op een specifiek dataset geeft de ontwikkelaar inzichten om heel veel beslissingen te nemen tijdens het trainen, zoals het gebruiken van een nieuwere, sterkere model of zelfs het veranderen van de verliesfunctie zelf naar een ander type. Spreken we over typen van verliesfuncties, dan zijn er verschillende van deze verliesfuncties ontwikkeld over de jaren, elk geschikt om gebruikt te worden voor een specifieke trainings taak.

Vereisten

Dit artikel vereist dat u kennis heeft van neurale netwerken. op een hoog niveau bestaan neurale netwerken uit met elkaar verbonden knopen (neuronen) die zijn georganiseerd in lagen. Ze leren en voorspellen door middel van een proces dat “trainen” heet, dat de gewichten en bias’ van de verbindingen tussen neuronen aanpast. Kennis van neurale netwerken omvat kennis van hun verschillende lagen (inputlaag, verborgen lagen, outputlaag), activeringsfuncties, optimalisaties algoritmen (varianten van gradienten afname), verliesfuncties, enzovoort.

Ook het gemakkelijkheid van de Python syntaxis en de PyTorch-bibliotheek is essentieel voor het begrijpen van de code fragmenten die in dit artikel worden voorgesteld.

In dit artikel zullen we verschillende verliesfuncties verkennen die deel uitmaken van het PyTorch nn-module. We zullen verder diepgaand aan de hand van het bouwen van een aangepaste verliesfunctie kijken hoe PyTorch deze verliesfuncties aan gebruikers exposeert als onderdeel van zijn nn-module API.

Nu we een algemeen beeld hebben van wat verliesfuncties zijn, laten we ons verdiepen in de technische details over hoe verliesfuncties werken.

Wat zijn verliesfuncties?

We hebben eerder gezegd dat verliesfuncties ons vertellen hoe goed een model presteert op een bepaald dataset. Technisch gezien doet het dat door te meten hoe dicht de voorspeldelijke waarde bij de actuele waarde is. Als ons model voorspellingen maakt die erg dicht bij de actuele waarden zijn op zowel ons trainings- als testingsdataset, betekent dat we een relatief robuust model hebben.

Alhoewel verliesfuncties ons belangrijke informatie geven over de prestatie van ons model, is dat niet het primaire functie van de verliesfunctie, aangezien er minder gevoelige technieken zijn om onze modellen te beoordelen, zoals accuracy en F-scores. De belangrijkheid van verliesfuncties wordt voornamelijk realistisch gedurende het trainen, waar we de gewichten van ons model naar de richting beweegt die de verlieswaarden minimaliseert. Door dit te doen, vergroten we de kans dat ons model correcte voorspellingen doet, iets dat zonder een verliesfunctie waarschijnlijk niet mogelijk zou zijn.

Verschillende verliesfuncties passen bij verschillende problemen, elkemaal zeer nauwkeurig gemaakt door onderzoekers om een stabiele gradiëntstroom tijdens het trainen te waarborgen.

Soms kan de wiskundige expressie van verliesfuncties een beetje vervelend zijn, wat heeft geleid tot sommige ontwikkelaars die ze als zwarte doosen behandelen. We zullen later enkele van PyTorchs meest gebruikte verliesfuncties onthullen, maar voor dat komt, kijken we eens naar hoe we verliesfuncties gebruiken in de PyTorch-wereld.

Verliesfuncties in PyTorch

PyTorch beschikt bij de installatie over veel standaardverliesfuncties met een eenvoudige ontwerppatroon die ontwikkelaars toegestaan om deze verschillende verliesfuncties snel tijdens het trainen door te lopen. Alle verliesfuncties van PyTorch zijn in het nn-module gezet, de basisklasse van PyTorch voor alle neurale netwerken. Dit maakt het toevoegen van een verliesfunctie aan uw project zo eenvoudig als het toevoegen van slechts één regel code. Laten we kijken hoe je een gemiddelde kwadratische fout verliesfunctie in PyTorch toevoegt.

import torch.nn as nn
MSE_loss_fn = nn.MSELoss()

De functie die teruggegeven wordt vanuit de code hierboven kan gebruikt worden om te berekenen hoe ver een voorspelling vanaf de echte waarde ligt met het onderstaande formaat.

#voorspeld_waarde is de voorspelling van ons neurale netwerk
#doel is de echte waarde in ons dataset
#verlieswaarde is de verlies tussen de voorspeld en de echte waarde
Loss_value = MSE_loss_fn(predicted_value, target)

Nu dat we kennismaken hebben met het gebruik van verliesfuncties in PyTorch, zal hetij nu dieper delven in de achter de schermen van verschillende van de verliesfuncties die PyTorch biedt.

Welke verliesfuncties zijn beschikbaar in PyTorch?

PyTorch biedt een groot aantal verliesfuncties, die ruimtelijk in drie categorieën kunnen worden onderverdeeld – regressieverlies, classificatieverlies en rangschikkingverlies.

Regressieverliezen zijn vooral betrokken bij continue waarden die elke waarde tussen twee grenzen kunnen aannemen. Een voorbeeld hiervan zou de voorspelling van de huizenprijzen in een gemeenschap zijn.

Classificatieverliesfuncties werken met discrete waarden, zoals de taak om een object te classificeren als een doos, pen of fles.

Rangschikkingverliezen voorschrijven de relatieve afstanden tussen waarden. Een voorbeeld van dit laatste zou het gezichtsverificatie zijn, waar we willen weten welke gezichtsbeelden behoren tot een bepaald gezicht en dat kunnen doen door te rangschikken welke gezichten behoren en niet behoren tot de originele gezichtshouder door hun mate van relatieve benadering van het doel gezichtsscan.

L1-verliesfunctie / gemiddelde absolute fout

De L1-verliesfunctie berekent de gemiddelde absolute fout tussen elke waarde in de voorspelde tensor en de waarde van het doel. Hij berekt eerst de absolute verschillen tussen elke waarde in de voorspelde tensor en de waarde van het doel, en berekend de som van alle waarden die van elke absolute verschilberekening terugkomen. Uiteindelijk berekt hij het gemiddelde van deze somwaarde om de gemiddelde absolute fout (MAE) te verkrijgen. De L1-verliesfunctie is erg robuust voor het behandelen van ruis.

import torch.nn as nn

#size_average en reduce zijn verouderd

#reduction specificeert de methode van verminderen die moet worden toegepast op de uitvoer. Mogelijke waarden zijn 'mean' (standaard) waarin we het gemiddelde van de uitvoer berekenen, 'sum' waarin de uitvoer wordt opgeteld en 'none' die geen verminderen toepast op de uitvoer

Loss_fn = nn.L1Loss(size_average=None, reduce=None, reduction='mean')

input = torch.randn(3, 5, requires_grad=True)
target = torch.randn(3, 5)
output = loss_fn(input, target)
print(output) #tensor(0.7772, grad_fn=<L1LossBackward>)

De enkele waarde die wordt teruggegeven is de berekende verlies tussen twee tensor met dimensie 3 bij 5.

Gemiddelde kwadratische fout

De gemiddeldekwadraatfout (MSE) heeft enkele opvallende overeenkomsten met de MAE. In plaats van de absolute verschillen tussen de waarden in de voorspellingstensor en het doelwit te berekenen, zoals dat het geval is met de gemiddelde absolute fout, berekenen ze de kwadratische verschillen tussen de waarden in de voorspellingstensor en die van de doeltensor. Door dit te doen worden relatief grote verschillen meer gestraft terwijl relatief kleine verschillen minder gestraft worden. MSE wordt minder robuust geacht bij het behandelen van uitliers en ruis dan MAE echter.

import torch.nn as nn

loss = nn.MSELoss(size_average=None, reduce=None, reduction='mean')
#L1 verliesfunctie parameters uitleg gelden hier.

input = torch.randn(3, 5, requires_grad=True)
target = torch.randn(3, 5)
output = loss(input, target)
print(output) #tensor(0.9823, grad_fn=<MseLossBackward>)

Kruisentropieverlies

Kruisentropieverlies wordt gebruikt in classificatieproblemen die een aantal discreete klassen bevatten. Het meet de verschillen tussen twee kansdistributies voor een gegeven set van stochastische variabelen. Meestal, bij het gebruik van kruisentropieverlies, is de uitvoer van onze netwerk een softmaxlaag, die erop zorgt dat de uitvoer van het neurale netwerk een kanswaarde is (waarde tussen 0-1).

De softmaxlaag bestaat uit twee delen – de exponent van de voorspelling voor een bepaalde klasse.

yi is de uitvoer van het neurale netwerk voor een bepaalde klasse. De uitvoer van deze functie is een getal dat dicht bij nul ligt, maar nooit nul, als yi groot en negatief is, en dicht bij 1 als yi positief en erg groot is.

import numpy as np

np.exp(34) #583461742527454.9
np.exp(-34) #1.713908431542013e-15

Het tweede deel is een normalisatiefactor en wordt gebruikt om er voor te zorgen dat de uitkomst van de softmaxlaag altijd een waarde voor kans is.

Dit wordt verkregen door de exponenten van elke klasse waarde bij elkaar op te tellen. De uiteindelijke vergelijking van softmax ziet er als volgt uit:

]

In PyTorch’s nn module combineert cross-entropyloss de log-softmax en de negatieve log-waarschijnlijkheid (NLL) verlies in een enkele verliesfunctie.

Bekijk hoe de gradiëntfunctie in de afgedrukte uitvoer een NLL verlies is. Dit onthult eigenlijk dat cross-entropyloss onder de hood de NLL verlies combineert met een log-softmax laag.

Negatieve Log-Waarschijnlijkheid (NLL) Verlies

De NLL verliesfunctie werkt heel vergelijkbaar met de cross-entropylossfunctie. Cross-entropyloss combineert een log-softmax laag en NLL verlies om de waarde van het cross-entropyloos te krijgen. Dit betekend dat NLL verlies kan worden gebruikt om de waarde van het cross-entropyloos te krijgen door de laatste laag van de neurale netwerk een log-softmax laag in plaats van een normale softmax laag te hebben.

m = nn.LogSoftmax(dim=1)
loss = nn.NLLLoss()
Invoer is van grootte N x C = 3 x 5
input = torch.randn(3, 5, requires_grad=True)
Elk element in het doel moet een waarde hebben tussen 0 en C
target = torch.tensor([1, 0, 4])
output = loss(m(input), target)
output.backward()
2D verlies voorbeeld (gebruikt bijvoorbeeld met afbeeldingsinvoer)
N, C = 5, 4
loss = nn.NLLLoss()
Invoer is van grootte N x C x hoogte x breedte
data = torch.randn(N, 16, 10, 10)
conv = nn.Conv2d(16, C, (3, 3))
m = nn.LogSoftmax(dim=1)
Elk element in het doel moet een waarde hebben tussen 0 en C
target = torch.empty(N, 8, 8, dtype=torch.long).random_(0, C)
output = loss(m(conv(data)), target)
print(output) Tensor(1.4892, grad_fn=<NllLoss2DBackward>)

Credits NLLLoss — Documentatie PyTorch 1.9.0

Binaire Cross-Entropie Verlies

Binaire cross-entropie verlies is een speciaal type cross-entropie verliezen dat wordt gebruikt voor het specifieke probleem van classificeren van data punten in slechts twee klassen. Labels voor dit soort problemen zijn meestal binair, en ons doel is dus om de model te dwingen om een getal dicht bij nul te voorschijnen voor een nul label en een getal dicht bij één voor een één label. Meestal gebruikt men BCE verlies voor binaire classificatie, waarbij de uitvoer van de neurale netwerk een sigmoid laag bevat om erop te controleren dat de uitvoer een waarde dicht bij nul of een waarde dicht bij één is.

import torch.nn as nn

m = nn.Sigmoid()
loss = nn.BCELoss()
input = torch.randn(3, requires_grad=True)
target = torch.empty(3).random_(2)
output = loss(m(input), target)
print(output) Tensor(0.4198, grad_fn=<BinaryCrossEntropyBackward>)

Binaire Cross-Entropieverlies met Logits

We hebben in het vorige gedeelte gezegd dat een binaire cross-entropieverlies meestal wordt geoutput als een sigmoidlaag om te zorgen dat het output tussen 0 en 1 ligt. Een binaire cross-entropieverlies met logits combineert deze twee lagen in één enkele laag. Volgens de PyTorch documentatie is dit een numeriek stabielere versie omdat het voordeel uit de log-sum exp truc gaat halen.

import torch
import torch.nn as nn

target = torch.ones([10, 64], dtype=torch.float32)  # 64 klassen, batchgrootte = 10
output = torch.full([10, 64], 1.5)  # Een voorspelling (logit)
pos_weight = torch.ones([64])  # Alle gewichten zijn gelijk aan 1
criterion = torch.nn.BCEWithLogitsLoss(pos_weight=pos_weight)
loss = criterion(output, target)  # -log(sigmoid(1.5))
print(loss) #tensor(0.2014)

Smooth L1 Verlies

De gladde L1-verliesfunctie combineert de voordelen van de MSE-verliesfunctie en de MAE-verliesfunctie door middel van een heuristische waarde beta. Deze criteria werd geintroduceerd in het Fast R-CNN paper. Wanneer de absolute verschillen tussen de grondtrutswaarde en de voorspelde waarde onder beta liggen, gebruikt de criteria een kwadraatverschil, gelijkend op de MSE-verliesfunctie. Het diagram van de MSE-verliesfunctie is een continue curve, wat betekent dat de gradiënten voor elke verlieswaarde verschillen en overal afgeleid kunnen worden. Bovendien reduceert de gradiënt bij verminderde verlieswaarden, wat handig is tijdens de gradiënt daalt. Echter, voor zeer grote verlieswaarden kan de gradiënt exploderen, dus schakelt het criterium over naar MAE, waarvoor de gradiënt bijna constant is voor elke verlieswaarde, wanneer de absolute verschillen groter zijn dan beta en de potentiële gradiënt explosie wordt vermijd.

import torch.nn as nn

loss = nn.SmoothL1Loss()
input = torch.randn(3, 5, requires_grad=True)
target = torch.randn(3, 5)
output = loss(input, target)

print(output) #tensor(0.7838, grad_fn=<SmoothL1LossBackward>)

Hinge Embedding Verlies

Hinge embedding verlies wordt meestal gebruikt in halfgecontroleerde leeropdrachten om de overeenkomst tussen twee invoerwaarden te meten. Het wordt gebruikt wanneer er een invoer tensor en een label tensor zijn met waarden van 1 of -1. Het wordt meestal gebruikt in problemen die betrekking hebben op niet-lineaire embeddings en halfgecontroleerde leeropdrachten.

import torch
import torch.nn as nn

input = torch.randn(3, 5, requires_grad=True)
target = torch.randn(3, 5)

hinge_loss = nn.HingeEmbeddingLoss()
output = hinge_loss(input, target)
output.backward()

print('input: ', input)
print('target: ', target)
print('output: ', output)

#input:  Tensor([[ 1.4668e+00,  2.9302e-01, -3.5806e-01,  1.8045e-01,  1.1793e+00],
#       [-6.9471e-05,  9.4336e-01,  8.8339e-01, -1.1010e+00,  1.5904e+00],
#       [-4.7971e-02, -2.7016e-01,  1.5292e+00, -6.0295e-01,  2.3883e+00]],
#       requires_grad=True)
#target:  Tensor([[-0.2386, -1.2860, -0.7707,  1.2827, -0.8612],
#        [ 0.6747,  0.1610,  0.5223, -0.8986,  0.8069],
#        [ 1.0354,  0.0253,  1.0896, -1.0791, -0.0834]])
#output:  Tensor(1.2103, grad_fn=<MeanBackward0>)

Margin Ranking Verlies

Het margin ranking verlies behoort tot de rangschikkingsverliezen waarvan het voornaamste doel, anders dan bij andere verliezen, is om de relatieve afstand tussen een set invoer in een dataset te meten. De margin ranking functie neemt twee invoer en een label aan dat alleen 1 of -1 bevat. Als het label 1 is, wordt aangenomen dat de eerste invoer hoger moet worden gerangschikkt dan de tweede invoer, en als het label -1 is, wordt aangenomen dat de tweede invoer hoger moet worden gerangschikkt dan de eerste invoer. Deze relatie wordt weergegeven door de vergelijking en code hieronder.

import torch.nn as nn

loss = nn.MarginRankingLoss()
input1 = torch.randn(3, requires_grad=True)
input2 = torch.randn(3, requires_grad=True)
target = torch.randn(3).sign()
output = loss(input1, input2, target)
print('input1: ', input1)
print('input2: ', input2)
print('output: ', output)

#input1:   tensor([-1.1109,  0.1187,  0.9441], requires_grad=True)
#input2:   tensor([ 0.9284, -0.3707, -0.7504], requires_grad=True)
#output:   tensor(0.5648, grad_fn=<MeanBackward0>)

Triplet Margin Loss

Deze criteria meet de gelijkheid tussen data-punten door middel van tripletten van de trainingsdatasample te gebruiken. De betrokke tripletten bestaan uit een anchor-sample, een positief sample en een negatief sample. Het doel is 1) de afstand tussen het positief sample en het anchor zo klein mogelijk te krijgen, en 2) de afstand tussen het anchor en het negatieve sample groter dan een margin-waarde plus de afstand tussen het positief sample en het anchor te laten zijn. Normaal gesproken behoort het positief sample tot dezelfde klasse als het anchor, maar het negatieve sample niet. Daarom tracht deze verliesfunctie de triplet margin loss te gebruiken om een hoge gelijkheidswaarde tussen het anchor en het positief sample te voorschijn te brengen en een lage gelijkheidswaarde tussen het anchor en het negatieve sample.

import torch.nn as nn

triplet_loss = nn.TripletMarginLoss(margin=1.0, p=2)
anchor = torch.randn(100, 128, requires_grad=True)
positive = torch.randn(100, 128, requires_grad=True)
negative = torch.randn(100, 128, requires_grad=True)
output = triplet_loss(anchor, positive, negative)
print(output)  #tensor(1.1151, grad_fn=<MeanBackward0>)

Cosine Embedding Loss

Het cosine embedding verlies meet de verliesgegevens gegeven de invoer x1, x2 en een label tensor y die waarden 1 of -1 bevat. Het wordt gebruikt om de mate van overeenkomst of verschillen tussen twee invoerwaarden te meten.

Het kritiek meet de overeenkomst door de cosinusafstand tussen de twee data punten in ruimte te berekenen. De cosinusafstand correleert met de hoek tussen de twee punten, wat betekent dat de kleinere de hoek, hoe dichter de invoer en dus hoe meer ze op elkaar lijken.

import torch.nn as nn

loss = nn.CosineEmbeddingLoss()
input1 = torch.randn(3, 6, requires_grad=True)
input2 = torch.randn(3, 6, requires_grad=True)
target = torch.randn(3).sign()
output = loss(input1, input2, target)
print('input1: ', input1)
print('input2: ', input2)
print('output: ', output)

#input1:  tensor([[ 1.2969e-01,  1.9397e+00, -1.7762e+00, -1.2793e-01, #-4.7004e-01,
#         -1.1736e+00],
#        [-3.7807e-02,  4.6385e-03, -9.5373e-01,  8.4614e-01, -1.1113e+00,
#          4.0305e-01],
#        [-1.7561e-01,  8.8705e-01, -5.9533e-02,  1.3153e-03, -6.0306e-01,
#          7.9162e-01]], requires_grad=True)
#input2:  tensor([[-0.6177, -0.0625, -0.7188,  0.0824,  0.3192,  1.0410],
#        [-0.5767,  0.0298, -0.0826,  0.5866,  1.1008,  1.6463],
#        [-0.9608, -0.6449,  1.4022,  1.2211,  0.8248, -1.9933]],
#       requires_grad=True)
#output:  tensor(0.0033, grad_fn=<MeanBackward0>)

Kullback-Leibler-scheidingstekortverlies

Bij twee verdelingen, P en Q, wordt het Kullback-Leibler (KL) scheidingstekort verlies gebruikt om aan te geven hoeveel informatie verloren gaat als P (genomen als de ware verdeling) wordt vervangen door Q. door te meten hoeveel informatie wordt verloren als we Q gebruiken om P te benaderen, kunnen we de overeenkomst tussen P en Q bepalen en zo ons algoritme drijven om een verdeling dicht bij de ware verdeling P te produceren. Het informatieverlies bij het gebruik van Q om P te benaderen is niet hetzelfde als het gebruik van P om Q te benaderen, dus de KL-scheiding is niet symmetrisch.

import torch.nn as nn

loss = nn.KLDivLoss(size_average=None, reduce=None, reduction='mean', log_target=False)
input1 = torch.randn(3, 6, requires_grad=True)
input2 = torch.randn(3, 6, requires_grad=True)
output = loss(input1, input2)

print('output: ', output) #tensor(-0.0284, grad_fn=<KlDivBackward>)

Een aangepaste verliesfunctie bouwen

PyTorch biedt ons twee populaire manieren aan om onze eigen verliesfunctie te maken die aan ons probleem past; deze zijn het gebruiken van een klasse-implementatie en het gebruiken van een functie-implementatie. Laten we zien hoe we beide methodes kunnen implementeren, beginnend met de functie-implementatie.

Dit is zeker de eenvoudigste manier om uw eigen aangepaste verliesfunctie te schrijven. Het is net zo gemakkelijk als het aanmaken van een functie, het doorsturen van de vereiste invoer en andere parameters ertoe, het uitvoeren van een bepaalde bewerking met de core API van PyTorch of de Functional API en het teruggeven van een waarde. Laten we een demo zien met een aangepaste gemiddelde kwadratische fout.

def custom_mean_square_error(y_predictions, target):
  square_difference = torch.square(y_predictions - target)
  loss_value = torch.mean(square_difference)
  return loss_value

In het codeerbord hierboven definiëren we een aangepaste verliesfunctie om de gemiddelde kwadratische fout te berekenen, gegeven een voorspellingstensor en een doeltensor

y_predictions = torch.randn(3, 5, requires_grad=True);
target = torch.randn(3, 5)
pytorch_loss = nn.MSELoss();
p_loss = pytorch_loss(y_predictions, target)
loss = custom_mean_square_error(y_predictions, target)
print('custom loss: ', loss)
print('pytorch loss: ', p_loss)

#aangepaste verlies:  tensor(2.3134, grad_fn=<MeanBackward0>)
#PyTorch verlies:  tensor(2.3134, grad_fn=<MseLossBackward>)

We kunnen de verliesfunctionele berekenen met onze aangepaste verliesfunctie en de PyTorch MSE verliesfunctionele om te zien dat we dezelfde resultaten hebben behaald.

Aangepaste Verliesmeting met Python Klassen

Deze aanpak is waarschijnlijk de standaard en aanbevolen manier om aangepaste verliezen in PyTorch te definiëren. De verliesfunctie wordt als een knooppunt in het kunstmatige neural network diagram gecreëerd door deel te nemen van de nn module. Dit betekend dat onze aangepaste verliesfunctie net zo een PyTorch laag is als een convolutionele laag. Laten we een demo zien hoe dit werkt met een aangepaste MSE verlies.

class Custom_MSE(nn.Module):
  def __init__(self):
    super(Custom_MSE, self).__init__();

  def forward(self, predictions, target):
    square_difference = torch.square(predictions - target)
    loss_value = torch.mean(square_difference)
    return loss_value
  
  def __call__(self, predictions, target):
     square_difference = torch.square(y_predictions - target)
     loss_value = torch.mean(square_difference)
     return loss_value

Eindgedachten

We hebben veel over verliesfuncties in PyTorch gediscusseerd en ook een diepgaande kijk gehad in de binnenwerkingen van de meeste van deze verliesfuncties. Het kiezen van de juiste verliesfunctie voor een bepaald probleem kan een overweldigende taak zijn. Hopelijk helpt dit handleiding bij het begrijpen van welke verliesfunctie bij uw probleem past.