1. Descripción

En este artículo, todas las funciones de pérdida comunes utilizadas en el aprendizaje profundo se analizan e implementan en NumPy, PyTorch y TensorFlow.

2. Resumen

La función de costo de la que estamos hablando en este artículo se enumera a continuación:

Pérdida del error cuadrático medio (MSE)
Pérdida de entropía cruzada binaria
Pérdida de entropía cruzada binaria ponderada
Pérdida de entropía cruzada categórica
Pérdida de entropía cruzada categórica escasa
pérdida de dados
Pérdida de divergencia de Kuala Lumpur
Error absoluto medio (MAE)/pérdida L1
pérdida de Huber

A continuación, demostraremos los diferentes métodos de implementación uno por uno.

3. Pérdida del error cuadrático medio (MSE)

La pérdida del error cuadrático medio (MSE) es una función de pérdida de uso común en problemas de regresión donde el objetivo es predecir una variable continua. La pérdida se calcula como el promedio de las diferencias al cuadrado entre los valores predichos y verdaderos. La fórmula para la pérdida de MSE es:

Pérdida de MSE = (1/n) * sum((y_pred — y_true)²)

aquí:

n es el número de muestras en el conjunto de datos
El valor predicho de la variable de destino y_pred
y_true es el valor verdadero de la variable de destino

La pérdida de MSE es sensible a los valores atípicos y penaliza en gran medida los errores grandes, lo que puede no ser deseable en algunos casos. En este caso, se pueden utilizar otras funciones de pérdida, como el error absoluto medio (MAE) o la pérdida de Huber.

Implementación en NumPy

import numpy as np

def mse_loss(y_pred, y_true):
    """
    Calculates the mean squared error (MSE) loss between predicted and true values.
    
    Args:
    - y_pred: predicted values
    - y_true: true values
    
    Returns:
    - mse_loss: mean squared error loss
    """
    n = len(y_true)
    mse_loss = np.sum((y_pred - y_true) ** 2) / n
    return mse_loss

En esta implementación, y son matrices NumPy que contienen valores predichos y verdaderos, respectivamente. La función primero calcula la diferencia al cuadrado entre y y luego promedia estos valores para obtener la pérdida de MSE. Esta variable representa el número de muestras en el conjunto de datos y se utiliza para la pérdida de normalización.y_predy_truey_predy_truen

Implementación en TensorFlow

import tensorflow as tf

def mse_loss(y_pred, y_true):
    """
    Calculates the mean squared error (MSE) loss between predicted and true values.
    
    Args:
    - y_pred: predicted values
    - y_true: true values
    
    Returns:
    - mse_loss: mean squared error loss
    """
    mse = tf.keras.losses.MeanSquaredError()
    mse_loss = mse(y_true, y_pred)
    return mse_loss

En esta implementación, y son tensores de TensorFlow que contienen valores predichos y verdaderos, respectivamente. Esta función calcula la pérdida de MSE entre y . Esta variable contiene la pérdida calculada.y_predy_truetf.keras.losses.MeanSquaredError()y_predy_truemse_loss

Implementación en PyTorch

import torch

def mse_loss(y_pred, y_true):
    """
    Calculates the mean squared error (MSE) loss between predicted and true values.
    
    Args:
    - y_pred: predicted values
    - y_true: true values
    
    Returns:
    - mse_loss: mean squared error loss
    """
    mse = torch.nn.MSELoss()
    mse_loss = mse(y_pred, y_true)
    return mse_loss

En esta implementación, y son tensores de PyTorch que contienen valores predichos y verdaderos, respectivamente. Esta función calcula la pérdida de MSE entre y . Esta variable contiene la pérdida calculada.y_predy_truetorch.nn.MSELoss()y_predy_truemse_loss

4. Pérdida de entropía cruzada binaria

La pérdida de entropía cruzada binaria, también conocida como pérdida de registro, es una función de pérdida común utilizada en problemas de clasificación binaria. Mide la diferencia entre la distribución de probabilidad predicha y la distribución de etiquetas binarias real.

La fórmula para la pérdida de entropía cruzada binaria es la siguiente:

L（y， ŷ） = -[y * log（ŷ） + （1 — y） * log（1 — ŷ）]

donde y es la etiqueta binaria verdadera (0 o 1), ŷ es la probabilidad predicha (que va de 0 a 1) y log es el logaritmo natural.

El primer término de la ecuación calcula la pérdida cuando la etiqueta verdadera es 1 y el segundo término calcula la pérdida cuando la etiqueta verdadera es 0. La pérdida total es la suma de los dos términos.

La pérdida es menor cuando la probabilidad pronosticada está cerca de la etiqueta verdadera y mayor cuando la probabilidad pronosticada está lejos de la etiqueta verdadera. Esta función de pérdida se usa típicamente en modelos de redes neuronales que usan una función de activación sigmoidea en la capa de salida para predecir etiquetas binarias.

4.1 Implementación en NumPy

En numpy, la pérdida de entropía cruzada binaria se puede implementar usando la fórmula que describimos anteriormente. Aquí hay un ejemplo de cómo calcularlo:

# define true labels and predicted probabilities
y_true = np.array([0, 1, 1, 0])
y_pred = np.array([0.1, 0.9, 0.8, 0.3])

# calculate the binary cross-entropy loss
loss = -(y_true * np.log(y_pred) + (1 - y_true) * np.log(1 - y_pred)).mean()

# print the loss
print(loss)

4.2 Implementación en TensorFlow

En TensorFlow, la pérdida de entropía cruzada binaria se puede implementar mediante la función tf.keras.loss.BinaryCrossentropy(). Aquí hay un ejemplo de cómo usarlo:

import tensorflow as tf

# define true labels and predicted probabilities
y_true = tf.constant([0, 1, 1, 0])
y_pred = tf.constant([0.1, 0.9, 0.8, 0.3])

# define the loss function
bce_loss = tf.keras.losses.BinaryCrossentropy()

# calculate the loss
loss = bce_loss(y_true, y_pred)

# print the loss
print(loss)

4.3 Implementación en PyTorch

En PyTorch, la pérdida de entropía cruzada binaria se puede implementar usando esta función. Aquí hay un ejemplo de cómo usarlo:torch.nn.BCELoss()

import torch

# define true labels and predicted probabilities
y_true = torch.tensor([0, 1, 1, 0], dtype=torch.float32)
y_pred = torch.tensor([0.1, 0.9, 0.8, 0.3], dtype=torch.float32)

# define the loss function
bce_loss = torch.nn.BCELoss()

# calculate the loss
loss = bce_loss(y_pred, y_true)

# print the loss
print(loss)

4.4 Pérdida de entropía cruzada binaria ponderada

La pérdida de entropía cruzada binaria ponderada es una variante de la pérdida de entropía cruzada binaria que permite asignar diferentes pesos a la entropía positiva y los ejemplos negativos. Esto es útil cuando se trata de conjuntos de datos desequilibrados, donde una clase tiene una potencia significativamente baja en comparación con la otra.

La fórmula para la pérdida de entropía cruzada binaria ponderada es la siguiente:

L（y， ŷ） = -[w_pos * y * log（ŷ） + w_neg * （1 — y） * log（1 — ŷ）]

donde y es la etiqueta binaria verdadera (0 o 1), ŷ es la probabilidad predicha (que va de 0 a 1), log es el logaritmo natural y w_pos y w_neg son pesos positivos y negativos, respectivamente.

Se pueden elegir pesos positivos y negativos en función de la importancia relativa de cada clase. Por ejemplo, si la clase positiva es más importante, se le puede asignar un peso mayor. Asimismo, si las clases negativas son más importantes, se les puede asignar pesos más altos.

5. Pérdida de entropía cruzada de clasificación

La pérdida de entropía cruzada categórica es una función de pérdida común utilizada en problemas de clasificación de clases múltiples. Mide la diferencia entre la etiqueta verdadera y la probabilidad predicha para cada clase.

La fórmula para la pérdida de entropía cruzada categórica es:

L = -1/N * sum(sum(Y * log(Y_hat)))

donde es la matriz de etiquetas verdadera en formato codificado one-hot, es la matriz de probabilidad predicha para cada clase, es el número de muestras y representa el logaritmo natural.YY_hatNlog

En esta fórmula, la forma es , donde es el número de muestras y es el número de clases. Cada fila representa la distribución de etiquetas verdaderas para una sola muestra, con un valor de 1 en una columna correspondiente a la etiqueta verdadera y 0 para todas las demás columnas.Y(N, C)NCY

De manera similar, tiene la forma de , donde cada fila representa la distribución de probabilidad predicha para una sola muestra, con un valor de probabilidad para cada clase.Y_hat(N, C)

La función se aplica una por una a la matriz de probabilidad predicha. La función se usa dos veces para sumar las dos dimensiones de la matriz.logY_hatsumY

El valor resultante representa la pérdida de entropía cruzada promedio sobre todas las muestras en el conjunto de datos. El objetivo de entrenar una red neuronal es minimizar esta función de pérdida.LN

La función de pérdida penaliza más al modelo por cometer grandes errores al predecir clases con baja probabilidad. El objetivo es minimizar la función de pérdida, lo que significa hacer que las probabilidades predichas se acerquen lo más posible a las etiquetas verdaderas.

5.1 Implementación en NumPy

En numpy, la pérdida de entropía cruzada categórica se puede implementar usando la fórmula que describimos anteriormente. Aquí hay un ejemplo de cómo calcularlo:

import numpy as np

# define true labels and predicted probabilities as NumPy arrays
y_true = np.array([[0, 1, 0], [0, 0, 1], [1, 0, 0]])
y_pred = np.array([[0.8, 0.1, 0.1], [0.2, 0.3, 0.5], [0.1, 0.6, 0.3]])

# calculate the loss
loss = -1/len(y_true) * np.sum(np.sum(y_true * np.log(y_pred)))

# print the loss
print(loss)In this example, y_true represents the true labels (in integer format), and y_pred represents the predicted probabilities for each class (in a 2D array). The eye() function is used to convert the true labels to one-hot encoding, which is required for the loss calculation. The categorical cross-entropy loss is calculated using the formula we provided earlier, and the mean() function is used to average the loss over the entire dataset. Finally, the calculated loss is printed to the console.

En este ejemplo, representa la etiqueta verdadera en formato codificado one-hot y representa la probabilidad pronosticada para cada clase, tanto como matrices NumPy. Calcule la pérdida usando la fórmula anterior, luego use la función para imprimir en la consola. Tenga en cuenta que la función se usa dos veces para sumar las dos dimensiones de la matriz.y_truey_predprintnp.sumY

5.2 Implementación en TensorFlow

En TensorFlow, la pérdida de entropía cruzada categórica se puede calcular fácilmente usando esta clase. Aquí hay un ejemplo de cómo usarlo:tf.keras.losses.CategoricalCrossentropy

import tensorflow as tf

# define true labels and predicted probabilities as TensorFlow Tensors
y_true = tf.constant([[0, 1, 0], [0, 0, 1], [1, 0, 0]])
y_pred = tf.constant([[0.8, 0.1, 0.1], [0.2, 0.3, 0.5], [0.1, 0.6, 0.3]])

# create the loss object
cce_loss = tf.keras.losses.CategoricalCrossentropy()

# calculate the loss
loss = cce_loss(y_true, y_pred)

# print the loss
print(loss.numpy())

En este ejemplo, las etiquetas verdaderas se representan en un formato codificado one-hot y las probabilidades previstas para cada clase se representan, ambos como tensores de TensorFlow. Esta clase se usa para crear una instancia de la función de pérdida y luego calcular la pérdida pasando la etiqueta verdadera y la probabilidad prevista como parámetros. Finalmente, use el método para imprimir la pérdida calculada en la consola.y_truey_predCategoricalCrossentropy.numpy()

Tenga en cuenta que esta clase maneja la conversión interna de las etiquetas de verdad en tierra a una codificación one-hot, por lo que no hay necesidad de hacer esto explícitamente. Si sus etiquetas de verdad en tierra ya están en formato de codificación one-hot, puede pasarlas directamente a la función de pérdida sin ningún problema.CategoricalCrossentropy

5.3 Implementación en PyTorch

En PyTorch, la pérdida de entropía cruzada categórica se puede calcular fácilmente usando esta clase. Aquí hay un ejemplo de cómo usarlo:torch.nn.CrossEntropyLoss

import torch

# define true labels and predicted logits as PyTorch Tensors
y_true = torch.LongTensor([1, 2, 0])
y_logits = torch.Tensor([[0.8, 0.1, 0.1], [0.2, 0.3, 0.5], [0.1, 0.6, 0.3]])

# create the loss object
ce_loss = torch.nn.CrossEntropyLoss()

# calculate the loss
loss = ce_loss(y_logits, y_true)

# print the loss
print(loss.item())

En este ejemplo, representa la etiqueta verdadera en formato entero y representa el registro de predicciones para cada clase, tanto como tensores de PyTorch. Esta clase se usa para crear una instancia de la función de pérdida y luego calcular la pérdida pasando el registro predicho y la etiqueta verdadera como parámetros. Finalmente, use el método para imprimir la pérdida calculada en la consola.y_truey_logitsCrossEntropyLoss.item()

Tenga en cuenta que esta clase combina la función de activación de softmax y la pérdida de entropía cruzada categórica en una sola operación, por lo que no necesita aplicar softmax por separado. También tenga en cuenta que las etiquetas reales deben estar en formato de número entero, no codificadas en caliente.CrossEntropyLoss

[Todas las funciones de pérdida para aprendizaje profundo] Implementadas en NumPy, TensorFlow y PyTorch (1/2)