Funciones de pérdida de PyTorch

Introducción

Las funciones de pérdida son fundamentales en el entrenamiento de modelos de ML, y en la mayoría de los proyectos de aprendizaje automático, no hay manera de dirigir su modelo a hacer predicciones correctas sin una función de pérdida. En términos simples, una función de pérdida es una función matemática o expresión utilizada para medir cuán bien está haciendo un modelo en un conjunto de datos determinado. Sabiendo cuán bien está haciendo un modelo en un conjunto de datos particular le da al desarrollador pistas para tomar muchas decisiones durante el entrenamiento, como utilizar un nuevo modelo más potente o incluso cambiar la función de pérdida a otro tipo. Hablando de los tipos de funciones de pérdida, a lo largo de los años se han desarrollado varias de estas funciones de pérdida, cada una adaptada para su uso en una tarea de entrenamiento particular.

Prerrequisitos

Este artículo requiere un entendimiento de las redes neuronales. A nivel alto, las redes neuronales están compuestas por nodos interconectados (“neuronas”) organizados en capas. Aprenden y hacen predicciones a través de un proceso llamado “entrenamiento” que ajusta las ponderaciones y los sesgos de las conexiones entre neuronas. Un entendimiento de las redes neuronales incluye el conocimiento de sus diferentes capas (capa de entrada, capas ocultas, capa de salida), funciones de activación, algoritmos de optimización (variantes de descenso de gradiente), funciones de pérdida, etc.

Además, la familiaridad con la sintaxis de Python y la biblioteca PyTorch es fundamental para comprender los fragmentos de código presentados en este artículo.

En este artículo, exploraremos diferentes funciones de pérdida que forman parte del módulo PyTorch nn. Además, profundizaremos cómo PyTorch expone estas funciones de pérdida a los usuarios como parte de su API de módulo nn construyendo una personalizada.

Como ya hemos adquirido un entendimiento de nivel alto de qué son las funciones de pérdida, exploraremos detalles técnicos más específicos sobre cómo funcionan las funciones de pérdida.

¿Qué son las funciones de pérdida?

Anteriormente mencionamos que las funciones de pérdida nos dicen cómo bien un modelo se desempeña en un conjunto de datos particular. Técnicamente, esto lo hace mediante la medición de qué tan cerca se encuentra una predicción de valor real. Cuando nuestro modelo hace predicciones que están muy cerca de los valores reales tanto en nuestro conjunto de datos de entrenamiento como en el de pruebas, significa que tenemos un modelo bastante robusto.

Aunque las funciones de pérdida nos proporcionan información crucial sobre el rendimiento de nuestro modelo, esta no es su función principal, ya que existen técnicas más robustas para evaluar a nuestros modelos, como la precisión y los índices F. El importancia de las funciones de pérdida se realiza principalmente durante el entrenamiento, donde nudjamos los pesos de nuestro modelo en la dirección que reduce la pérdida. Al hacer esto, aumentamos la probabilidad de que nuestro modelo haya predicho correctamente, algo que probablemente no habría sido posible sin una función de pérdida.

Diferentes funciones de pérdida se adecuan a diferentes problemas, cada una elaborada cuidadosamente por investigadores para asegurar un flujo de gradiente estable durante el entrenamiento.

A veces, las expresiones matemáticas de las funciones de pérdida pueden ser un poco intimidadoras, y esto ha llevado a algunos desarrolladores a tratarlas como cajas negras. Vamos a descubrir algunas de las funciones de pérdida más utilizadas de PyTorch más adelante, pero antes de eso, veamos cómo usamos las funciones de pérdida en el mundo de PyTorch.

Funciones de pérdida en PyTorch

PyTorch viene con un montón de funciones de pérdida canónicas con patrones de diseño simple que permiten a los desarrolladores iterar sobre estas diferentes funciones de pérdida muy rápidamente durante el entrenamiento. Todas las funciones de pérdida de PyTorch están empaquetadas en el módulo nn, la clase base de PyTorch para todas las redes neuronales. Esto hace que agregar una función de pérdida a tu proyecto sea tan fácil como agregar una sola línea de código. Veamos cómo agregar una función de pérdida de error cuadrático medio en PyTorch.

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

La función devuelta por el código de arriba se puede usar para calcular cuán lejos una predicción está de los valores reales utilizando el formato siguiente.

#predicted_value es la predicción de nuestra red neuronal
#target es el valor real en nuestro conjunto de datos
#loss_value es la pérdida entre el valor predicho y el valor real
Loss_value = MSE_loss_fn(predicted_value, target)

Ahora que tenemos una idea de cómo utilizar funciones de pérdida en PyTorch, vamos a adentrarnos en lo que sucede detrás de las escenas de varias de las funciones de pérdida que ofrece PyTorch.

¿Qué funciones de pérdida están disponibles en PyTorch?

Muchas de las funciones de pérdida que viene con PyTorch se dividen ampliamente en 3 grupos – pérdida de regresión, pérdida de clasificación y pérdida de ranking.

Las pérdidas de regresión se preocupan principalmente por valores continuos que pueden tomar cualquier valor entre dos límites. Un ejemplo de esto sería las predicciones de los precios de las casas de una comunidad.

Las funciones de pérdida de clasificación se ocupan de valores discretos, como la tarea de clasificar un objeto como una caja, bolígrafo o botella.

Las pérdidas de ranking predicen las distancias relativas entre valores. Un ejemplo de esto sería la verificación facial, donde queremos saber qué imágenes de caras pertenecen a una cara particular y podemos hacerlo clasificando qué caras pertenecen y qué no pertenecen al original por su grado de aproximación relativa a la cara objetivo.

Función de pérdida L1 / Error Absoluto Medio

La función de pérdida L1 calcula la media absoluta del error entre cada valor del tensor predicho y el del objetivo. Primero calcula la diferencia absoluta entre cada valor del tensor predicho y el del objetivo, y computa la suma de todos los valores devueltos por cada cálculo de diferencia absoluta. Finalmente, calcula la media de este valor de suma para obtener la media absoluta de error (MAE). La función de pérdida L1 es muy resistente para manejar ruido.

import torch.nn as nn

#size_average and reduce are deprecated

#reduction especifica el método de reducción a aplicar a la salida. Los valores posibles son 'mean' (predeterminado) donde calculamos la media de la salida, 'sum' donde la salida es sumada y 'none' que aplica ninguna reducción a la salida

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>)

El valor único devuelto es la pérdida calculada entre dos tensores de dimensión 3×5.

Error Cuadrático Medio

La media cuadrada del error comparte algunas similitudes inusuales con la MAE. En lugar de calcular la diferencia absoluta entre valores en el tensor de predicción y el objetivo, como ocurre con el error absoluto medio, calcula la diferencia cuadrada entre valores en el tensor de predicción y el del tensor de objetivo. Al hacer esto, las diferencias relativamente grandes son penalizadas más, mientras que las diferencias relativamente pequeñas son penalizadas menos. La MSE se considera menos robusta para manejar outliers y ruido que la MAE, sin embargo.

import torch.nn as nn

loss = nn.MSELoss(size_average=None, reduce=None, reduction='mean')
Aquí se aplican los mismos parámetros de función de pérdida L1.

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>)

Pérdida de Cross-Entropy

La pérdida de cross-entropy se utiliza en problemas de clasificación que involucran un número de clases discretas. Mide la diferencia entre dos distribuciones de probabilidad para un conjunto determinado de variables aleatorias. Normalmente, cuando se utiliza la pérdida de cross-entropy, la salida de nuestra red es una capa softmax, que garantiza que la salida de la red neural es un valor de probabilidad (valor entre 0-1).

La capa softmax consta de dos partes: el exponente de la predicción para una clase particular.

yi es la salida de la red neural para una clase particular. La salida de esta función es un número cercano a cero, pero nunca cero, si yi es grande y negativo, y más cercano a 1 si yi es positivo y muy grande.

import numpy as np

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

La segunda parte es un valor de normalización y se utiliza para asegurar que la salida de la capa softmax siempre sea un valor de probabilidad.

Esto se obtiene sumando todos los exponentes de cada valor de clase. La ecuación final de softmax se parece a esto:

]

En el módulo nn de PyTorch, la pérdida de cross-entropía combina la función log-softmax y la pérdida negativa de likelihood (NLL) en una sola función de pérdida.

Observe cómo la función de gradiente en la salida impresa es una pérdida NLL. Esto revela de hecho que la pérdida de cross-entropía combina la pérdida NLL debajo de los suelos con una capa log-softmax.

Pérdida de Negativo de Likelihood (NLL)

La función de pérdida NLL funciona muy similar a la función de pérdida de cross-entropía. La pérdida de cross-entropía combina una capa log-softmax y la pérdida NLL para obtener el valor de la pérdida de cross-entropía. Esto significa que la pérdida NLL se puede utilizar para obtener el valor de la pérdida de cross-entropía teniendo la última capa de la red neuronal una capa log-softmax en lugar de una capa softmax normal.

m = nn.LogSoftmax(dim=1)
loss = nn.NLLLoss()
El tamaño del input es de N x C = 3 x 5
input = torch.randn(3, 5, requires_grad=True)
Cada elemento en el target debe tener 0 <= valor < C
target = torch.tensor([1, 0, 4])
output = loss(m(input), target)
output.backward()
Ejemplo de pérdida 2D (utilizado, por ejemplo, con entradas de imagen)
N, C = 5, 4
loss = nn.NLLLoss()
El input tiene un tamaño de N x C x altura x anchura
data = torch.randn(N, 16, 10, 10)
conv = nn.Conv2d(16, C, (3, 3))
m = nn.LogSoftmax(dim=1)
Cada elemento en el target debe tener 0 <= valor < 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>)

Crédito NLLLoss — Documentación de PyTorch 1.9.0

Pérdida de cruce de entropía binaria

La pérdida de cruce de entropía binaria es una clase especial de pérdidas de cruce de entropía utilizadas para el problema especial de clasificar puntos de datos en solo dos clases. Las etiquetas para este tipo de problema son generalmente binarias, y por lo tanto, nuestro objetivo es empujar el modelo a predecir un número cercano a cero para una etiqueta cero y un número cercano a uno para una etiqueta uno. Normalmente, cuando se utiliza la pérdida BCE para clasificación binaria, la salida de la red neuronal es una capa sigmoidal para asegurar que la salida es cualquier valor cercano a cero o un valor cercano a uno.

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>)

Pérdida de cruce de entropía binaria con logits

Como mencionamos en la sección anterior, una pérdida de cruce de entropía binaria normalmente se emite como una capa de sigmoide para asegurar que los resultados se encuentren entre 0 y 1. Una pérdida de cruce de entropía binaria con logits combina estas dos capas en una sola. Según la documentación de PyTorch, esto es una versión numéricamente más estable ya que aprovecha la truco de log-sum exp.

import torch
import torch.nn as nn

target = torch.ones([10, 64], dtype=torch.float32)  # 64 clases, tamaño de lote = 10
output = torch.full([10, 64], 1.5)  # Una predicción (logit)
pos_weight = torch.ones([64])  # Todos los pesos son iguales a 1
criterion = torch.nn.BCEWithLogitsLoss(pos_weight=pos_weight)
loss = criterion(output, target)  # -log(sigmoid(1.5))
print(loss) #tensor(0.2014)

Pérdida Smooth L1

La función de pérdida L1 suave combina los beneficios de la pérdida MSE y la pérdida MAE a través de un valor heurístico beta. Este criterio fue presentado en el artículo Fast R-CNN. Cuando la diferencia absoluta entre el valor verdadero del ground truth y el valor predicho es menor que beta, el criterio utiliza una diferencia cuadrada, similar a la pérdida MSE. La gráfica de la pérdida MSE es una curva continua, lo que significa que la gradiente para cada valor de pérdida varía y se puede derivar en cualquier lugar. Además, a medida que el valor de pérdida disminuye, el gradiente disminuye, lo que es conveniente durante el descenso por gradiente. Sin embargo, para valores de pérdida muy grandes, el gradiente explota, de modo que el criterio cambia a MAE, para el cual la gradiente es casi constante para cada valor de pérdida, cuando la diferencia absoluta se hace mayor que beta y se elimina la posible explosión del gradiente.

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>)

Pérdida de Embedding de Angulo

La pérdida de embedding de angulo se utiliza principalmente en tareas de aprendizaje semi- supervisado para medir la similitud entre dos entradas. Se utiliza cuando hay un tensor de entrada y un tensor de etiquetas que contienen valores de 1 o -1. Generalmente se utiliza en problemas que involucran embeddings no lineales y aprendizaje semi- supervisado.

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)

#entrada:  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)
#objetivo:  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]])
#salida:  tensor(1.2103, grad_fn=<MeanBackward0>)

Pérdida de Rango de Margen

La pérdida de rango de margen pertenece a las pérdidas de ranking cuyo objetivo principal, a diferencia de otras funciones de pérdida, es medir la distancia relativa entre un conjunto de entradas en un conjunto de datos. La función de pérdida de rango de margen toma dos entradas y una etiqueta que contiene solo 1 o -1. Si la etiqueta es 1, se asume que la primera entrada debe tener una clasificación superior a la segunda entrada y si la etiqueta es -1, se asume que la segunda entrada debe tener una clasificación superior a la primera entrada. Esta relación se muestra por la ecuación y el código debajo.

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>)

Pérdida de Margen de Tripleta

Este criterio mide la similitud entre puntos de datos utilizando tripletes de muestras de datos de entrenamiento. Los tripletes involucrados son una muestra de referencia, una muestra positiva y una muestra negativa. El objetivo es 1) minimizar la distancia entre la muestra positiva y la referencia, y 2) que la distancia entre la referencia y la muestra negativa sea mayor que la suma del valor de margen más la distancia entre la muestra positiva y la referencia. Normalmente, la muestra positiva pertenece a la misma clase que la referencia, pero la muestra negativa no. Por lo tanto, al utilizar esta función de pérdida, buscamos utilizar la pérdida de margen de tripleta para predecir un alto valor de similitud entre la referencia y la muestra positiva y un bajo valor de similitud entre la referencia y la muestra negativa.

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>)

Pérdida de Embedición Coseno

La pérdida de embeddings coseno mide la pérdida dadas las entradas x1, x2 y una etiqueta tensor y que contiene valores 1 o -1. Se utiliza para medir el grado de similitud o diferencia entre dos entradas.

El criterio mide la similitud calculando la distancia coseno entre los dos puntos de datos en espacio. La distancia coseno se correlaciona con el ángulo entre los dos puntos, lo que significa que el menor el ángulo, más cercanos son las entradas y por lo tanto más similares son.

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>)

Pérdida de Divergencia de Kullback-Leibler

Dada dos distribuciones, P y Q, la pérdida de divergencia de Kullback-Leibler (KL) mide cuánta información se pierde cuando P (supuestamente la distribución verdadera) es reemplazada por Q. Mediendo cuánta información se pierde al usar Q para aproximar P, podemos obtener la similitud entre P y Q y, por lo tanto, dirigir nuestro algoritmo para producir una distribución muy cercana a la distribución verdadera, P. La pérdida de información cuando se utiliza Q para aproximar P no es la misma cuando se utiliza P para aproximar Q, de modo que la divergencia KL no es simétrica.

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>)

Construcción de una Función de Pérdida Personalizada

PyTorch nos proporciona dos formas populares para construir nuestra propia función de pérdida personalizada para nuestro problema; estas son, en particular, la implementación de una clase y la implementación de una función. Veamos cómo podemos implementar ambos métodos empezando por la implementación de una función.

Este es sin duda la forma más simple de escribir su propia función de pérdida personalizada. Es tan fácil como crear una función, pasando los inputs requeridos y otros parámetros, realizando alguna operación utilizando el API central de PyTorch o la API funcional y devolviendo un valor. Veamos una demostración con una función de pérdida de error cuadrático medio personalizada.

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

En el código anterior, definimos una función de pérdida personalizada para calcular el error cuadrático medio dada una tensor de predicción y una tensor de objetivo

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)

#custom loss:  tensor(2.3134, grad_fn=<MeanBackward0>)
#pytorch loss:  tensor(2.3134, grad_fn=<MseLossBackward>)

Podemos calcular la pérdida utilizando nuestra función de pérdida personalizada y la función de pérdida de error cuadrático medio de PyTorch para observar que obtenemos los mismos resultados.

Pérdida Personalizada con Clases de Python

Este enfoque es probablemente la forma estándar y recomendada para definir pérdidas personalizadas en PyTorch. La función de pérdida se crea como un nodo en el gráfico de red neuronal mediante la subclasificación del módulo nn. Esto significa que nuestra función de pérdida personalizada es una capa de PyTorch exactamente de la misma manera que una capa convolucional lo es. Veamos una demostración de cómo funciona esto con una función de pérdida de ECM personalizada.

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

Pensamientos finales

Hemos hablado mucho sobre las funciones de pérdida disponibles en PyTorch y también hemos profundizado en el funcionamiento interno de la mayoría de estas funciones de pérdida. El elegir la función de pérdida correcta para un problema particular puede ser una tarea abrumadora. Esperamos que este tutorial, junto con la documentación oficial de PyTorch, sirva de guía cuando se intenta comprender qué función de pérdida es adecuada para su problema.