Encuentre el valor de pérdida de entropía cruzada binaria usando TensorFlow

Este breve artículo explica los dos métodos para calcular la entropía cruzada binaria (es decir, las funciones integradas del marco TensorFlow y la implementación personalizada de la fórmula en Python sin formato). Además, demuestra que ambos métodos producen los mismos resultados.

Antes de calcular la pérdida de entropía cruzada, primero debemos comprender la pérdida de entropía cruzada binaria y por qué se estima. Luego implementaremos su fórmula usando Python sin procesar y según el marco TensorFlow.

Encuentre el valor de pérdida de entropía cruzada binaria usando TensorFlow

La función pérdida se utiliza en Machine Learning para medir el rendimiento del modelo. Si la pérdida es alta, el modelo está funcionando mal.

Por el contrario, si es bajo, el modelo funciona bien y genera resultados cercanos a la realidad.

Cross Entropy es también una medida de pérdida (también conocida como pérdida de registro). Generalmente se utiliza para calcular la pérdida en problemas de clasificación binaria.

La entropía cruzada binaria es el promedio negativo del logaritmo de las probabilidades predichas corregidas.

Calculamos la entropía cruzada binaria usando la siguiente fórmula.

$$
\text { Log loss }=\frac{1}{N} \sum_{i=1}^{N}-\left(y_{i} * \log \left(p_{i}\right)+\left (1-y_{i}\right) * \log \left(1-p_{i}\right)\right)
$$

Implementemos la fórmula anterior usando Python.

import numpy as np


def BinaryCrossEntropy(y_true, y_pred):
    y_pred = np.clip(y_pred, 1e-7, 1 - 1e-7)
    term_0 = y_true * np.log(y_pred + 1e-7)
    term_1 = (1 - y_true) * np.log(1 - y_pred + 1e-7)
    return -np.mean(term_0 + term_1, axis=0)


print(
    BinaryCrossEntropy(
        np.array([1, 0, 1]).reshape(-1, 1), np.array([0, 0, 1]).reshape(-1, 1)
    )
)

Entendamos el código anterior línea por línea. Definimos una función BinaryCrossEntropy que toma dos argumentos, y_true y y_pred.

Estos argumentos son matrices 1D en clasificación binaria. Los y_true son valores reales y los y_pred son los valores predichos del modelo de ML.

La llamada np.clip(array, min_val, max_val) simplemente recorta la matriz de entrada. Por ejemplo, [0,0,1] se recortará a [1e^-7, 1e^-7, 0.9999999].

El np.mean() encuentra la media de la matriz de entrada dividiéndola por el tamaño del lote N.

¿Por qué usamos un valor mínimo como 1*e^-7 para recortar?

La fórmula anterior contiene algunos términos logarítmicos. Dado que log(0) (es decir, logaritmo natural de cero) produce indefinido (infinito).

Cuando el infinito se divide por N (es decir, el tamaño del lote de valores predichos/verdaderos), da un error. Por lo tanto, usamos un valor mínimo de 1*e^-7 para el recorte.

El código anterior da el siguiente resultado.

[5.14164949]

Ahora, usaremos TensorFlow para encontrar valores de pérdida de entropía cruzada binaria. Veamos el siguiente código.

import tensorflow as tf
import numpy as np

y_true = np.array([1.0, 1.0, 1.0]).reshape(-1, 1)
y_pred = np.array([1.0, 1.0, 0.0]).reshape(-1, 1)

bce = tf.keras.losses.BinaryCrossentropy(
    from_logits=False, reduction=tf.keras.losses.Reduction.SUM_OVER_BATCH_SIZE
)
loss = bce(y_true, y_pred)

print(loss.numpy())

La función integrada tf.keras.losses.BinaryCrossentropy( from_logits=False, reducción=tf.keras.losses.Reduction.SUM_OVER_BATCH_SIZE) calcula la pérdida de entropía cruzada entre las etiquetas verdaderas y las etiquetas predichas.

En el código anterior, bce( y_true, y_pred) toma dos argumentos.

1. y_true (etiqueta verdadera): Esto es 0 o 1.
2. y_pred (valor predicho): esta es la predicción del modelo, es decir, un único valor de coma flotante que representa un logit, (es decir, valor en [-inf, inf] cuando from_logits =Verdadero) o una probabilidad (es decir, valor en [0., 1.] cuando from_logits=False).

Puede encontrar más detalles sobre la entropía cruzada binaria aquí.

El código anterior da el siguiente valor de entropía cruzada binaria.

5.1416497230529785

Esto es evidente por los resultados de que los valores de pérdida de entropía cruzada binaria usando TensorFlow y de la fórmula son iguales.