[Todas as funções de perda para aprendizagem profunda] Implementado em NumPy, TensorFlow e PyTorch (1/2)

1. Descrição

Neste artigo, todas as funções de perda comuns usadas no aprendizado profundo são discutidas e implementadas em NumPy, PyTorch e TensorFlow.

2. Resumo 

A função de custo de que estamos falando neste artigo está listada a seguir:

1. Perda de erro quadrático médio (MSE)
2. Perda de entropia cruzada binária
3. Perda de entropia cruzada binária ponderada
4. Perda de entropia cruzada categórica
5. Perda de entropia cruzada categórica esparsa
6. perda de dados
7. Perda de Divergência de Kuala Lumpur
8. Erro Absoluto Médio (MAE) / Perda L1
9. perda de huber

        A seguir, demonstraremos os diferentes métodos de implementação, um por um. 

3. Perda de erro quadrático médio (MSE)

        A perda de erro quadrado médio (MSE) é uma função de perda comumente usada em problemas de regressão em que o objetivo é prever uma variável contínua. A perda é calculada como a média das diferenças ao quadrado entre os valores previstos e verdadeiros. A fórmula para a perda MSE é:

Perda MSE = (1/n) * soma((y_pred — y_true)²)

        aqui:

• n é o número de amostras no conjunto de dados
• O valor previsto da variável de destino y_pred
• y_true é o valor verdadeiro da variável de destino

        A perda MSE é sensível a outliers e penaliza fortemente erros grandes, o que pode não ser desejável em alguns casos. Nesse caso, outras funções de perda, como erro absoluto médio (MAE) ou perda de Huber, podem ser usadas.

        Implementação no 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

        Nesta implementação, e são matrizes NumPy contendo valores previstos e verdadeiros, respectivamente. A função primeiro calcula a diferença quadrada entre e e depois calcula a média desses valores para obter a perda de MSE. Essa variável representa o número de amostras no conjunto de dados e é usada para perda de normalização.y_predy_truey_predy_truen

Implementação no 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

Nesta implementação, e são Tensores TensorFlow contendo valores previstos e verdadeiros, respectivamente. Esta função calcula a perda MSE entre e . Esta variável contém a perda calculada.y_predy_truetf.keras.losses.MeanSquaredError()y_predy_truemse_loss

Implementação em 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

Nesta implementação, e são tensores PyTorch contendo valores previstos e verdadeiros, respectivamente. Esta função calcula a perda MSE entre e . Esta variável contém a perda calculada.y_predy_truetorch.nn.MSELoss()y_predy_truemse_loss

4. Perda de entropia cruzada binária

        A perda de entropia cruzada binária, também conhecida como perda de log, é uma função de perda comum usada em problemas de classificação binária. Ele mede a diferença entre a distribuição de probabilidade prevista e a distribuição de rótulo binário real.

        A fórmula para perda de entropia cruzada binária é a seguinte:

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

        onde y é o verdadeiro rótulo binário (0 ou 1), ŷ é a probabilidade prevista (variando de 0 a 1) e log é o logaritmo natural.

        O primeiro termo da equação calcula a perda quando o rótulo verdadeiro é 1 e o segundo termo calcula a perda quando o rótulo verdadeiro é 0. A perda total é a soma dos dois termos.

        A perda é menor quando a probabilidade prevista está próxima do rótulo verdadeiro e maior quando a probabilidade prevista está longe do rótulo verdadeiro. Essa função de perda é normalmente usada em modelos de rede neural que usam uma função de ativação sigmoide na camada de saída para prever rótulos binários.

4.1 Implementação no NumPy

        Em numpy, a perda de entropia cruzada binária pode ser implementada usando a fórmula que descrevemos anteriormente. Veja um exemplo de como calcular:

# 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 Implementação no TensorFlow

        No TensorFlow, a perda de entropia binária pode ser implementada usando a função tf.keras.loss.BinaryCrossentropy(). Aqui está um exemplo de como usá-lo:

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 Implementação no PyTorch

        No PyTorch, a perda de entropia cruzada binária pode ser implementada usando esta função. Aqui está um exemplo de como usá-lo: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 Perda de entropia cruzada binária ponderada

        A perda de entropia cruzada binária ponderada é uma variante da perda de entropia cruzada binária que permite atribuir diferentes pesos à entropia positiva e aos exemplos negativos. Isso é útil ao lidar com conjuntos de dados desbalanceados, em que uma classe é significativamente fraca em comparação com a outra.

        A fórmula para perda de entropia cruzada binária ponderada é a seguinte:

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

        onde y é o verdadeiro rótulo binário (0 ou 1), ŷ é a probabilidade prevista (variando de 0 a 1), log é o logaritmo natural e w_pos e w_neg são pesos positivos e negativos, respectivamente.

        O primeiro termo da equação calcula a perda quando o rótulo verdadeiro é 1 e o segundo termo calcula a perda quando o rótulo verdadeiro é 0. A perda total é a soma de dois termos, cada um ponderado por um peso correspondente.

        Pesos positivos e negativos podem ser escolhidos com base na importância relativa de cada classe. Por exemplo, se a classe positiva for mais importante, pode-se atribuir a ela um peso maior. Da mesma forma, se as classes negativas forem mais importantes, elas podem receber pesos maiores.

        A perda é menor quando a probabilidade prevista está próxima do rótulo verdadeiro e maior quando a probabilidade prevista está longe do rótulo verdadeiro. Essa função de perda é normalmente usada em modelos de rede neural que usam uma função de ativação sigmoide na camada de saída para prever rótulos binários.

5. Classificação da perda de entropia cruzada

        A perda de entropia cruzada categórica é uma função de perda comum usada em problemas de classificação multiclasse. Ele mede a diferença entre o rótulo verdadeiro e a probabilidade prevista para cada classe.

        A fórmula para perda categórica de entropia cruzada é:

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

        onde é a matriz de rótulos verdadeira no formato codificado one-hot, é a matriz de probabilidade prevista para cada classe, é o número de amostras e representa o logaritmo natural.YY_hatNlog

        Nesta fórmula, a forma é , onde é o número de amostras e é o número de classes. Cada linha representa a distribuição de rótulo verdadeiro para uma única amostra, com um valor de 1 em uma coluna correspondente ao rótulo verdadeiro e 0 para todas as outras colunas.Y(N, C)NCY

        Da mesma forma, tem a forma de , onde cada linha representa a distribuição de probabilidade prevista para uma única amostra, com um valor de probabilidade para cada classe.Y_hat(N, C)

        A função é aplicada uma a uma à matriz de probabilidade prevista. A função é usada duas vezes para somar as duas dimensões da matriz.logY_hatsumY

        O valor resultante representa a perda média de entropia cruzada em todas as amostras no conjunto de dados. O objetivo de treinar uma rede neural é minimizar essa função de perda.LN

        A função de perda penaliza mais o modelo por cometer grandes erros na previsão de classes com baixa probabilidade. O objetivo é minimizar a função de perda, o que significa tornar as probabilidades previstas o mais próximo possível dos rótulos verdadeiros.

5.1 Implementação no NumPy

        Em numpy, a perda categórica de entropia cruzada pode ser implementada usando a fórmula que descrevemos anteriormente. Veja um exemplo de como calcular:

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.

        Neste exemplo, representa o rótulo verdadeiro no formato codificado one-hot e representa a probabilidade prevista para cada classe, tanto como matrizes NumPy. Calcule a perda usando a fórmula acima e use a função para imprimir no console. Observe que a função é usada duas vezes para somar as duas dimensões da matriz.y_truey_predprintnp.sumY

5.2 Implementação no TensorFlow

        No TensorFlow, a perda categórica de entropia cruzada pode ser facilmente calculada usando essa classe. Aqui está um exemplo de como usá-lo: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())

        Neste exemplo, os rótulos verdadeiros são representados no formato de codificação one-hot e as probabilidades previstas para cada classe são representadas, ambas como tensores do TensorFlow. Essa classe é usada para criar uma instância da função de perda e, em seguida, calcular a perda passando o rótulo verdadeiro e a probabilidade prevista como parâmetros. Por fim, use o método para imprimir a perda calculada no console.y_truey_predCategoricalCrossentropy.numpy()

Observe que essa classe lida com a conversão dos rótulos de verdade básica em codificação one-hot internamente, portanto, não há necessidade de fazer isso explicitamente. Se seus rótulos de informações básicas já estiverem no formato de codificação one-hot, você poderá passá-los diretamente para a função de perda sem problemas.CategoricalCrossentropy

5.3 Implementação no PyTorch

        No PyTorch, a perda categórica de entropia cruzada pode ser facilmente calculada usando esta classe. Aqui está um exemplo de como usá-lo: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())

        Neste exemplo, representa o rótulo verdadeiro no formato inteiro e representa o log de previsões para cada classe, ambos como tensores PyTorch. Essa classe é usada para criar uma instância da função de perda e, em seguida, calcular a perda passando o log previsto e o rótulo verdadeiro como parâmetros. Por fim, use o método para imprimir a perda calculada no console.y_truey_logitsCrossEntropyLoss.item()

        Observe que esta classe combina a função de ativação softmax e a perda categórica de entropia cruzada em uma operação, portanto, você não precisa aplicar softmax separadamente. Observe também que os rótulos reais devem estar no formato inteiro, não codificados em um ponto.CrossEntropyLoss