Ermitteln Sie den Wert des binären Kreuzentropieverlusts mit TensorFlow

Dieser kurze Artikel erklärt die beiden Methoden zur Berechnung der binären Kreuzentropie (d. h. die integrierten Funktionen des TensorFlow-Frameworks und die benutzerdefinierte Implementierung der Formel in Roh-Python). Es beweist ferner, dass beide Methoden die gleichen Ergebnisse liefern.

Bevor wir den Kreuzentropieverlust berechnen, müssen wir zuerst den binären Kreuzentropieverlust verstehen und warum er geschätzt wird. Dann werden wir seine Formel mit rohem Python und gemäß dem TensorFlow-Framework implementieren.

Ermitteln Sie den Wert des binären Kreuzentropieverlusts mit TensorFlow

Die loss-Funktion wird beim maschinellen Lernen verwendet, um die Modellleistung zu messen. Ist der Verlust hoch, schneidet das Modell schlecht ab.

Im Gegensatz dazu, wenn es niedrig ist, funktioniert das Modell gut und generiert Ergebnisse nahe der Grundwahrheit.

Die Kreuzentropie ist auch ein Maß für den Verlust (auch bekannt als Log-Verlust). Es wird im Allgemeinen verwendet, um den Verlust bei binären Klassifikationsproblemen zu berechnen.

Binäre Kreuzentropie ist der negative Durchschnitt des Logs der korrigierten vorhergesagten Wahrscheinlichkeiten.

Wir berechnen die binäre Kreuzentropie mit der folgenden Formel.

$$
\text { Log-Verlust }=\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)
$$

Lassen Sie uns die obige Formel mit Python implementieren.

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

Lassen Sie uns den obigen Code Zeile für Zeile verstehen. Wir haben eine Funktion BinaryCrossEntropy definiert, die zwei Argumente akzeptiert, y_true und y_pred.

Diese Argumente sind 1D-Arrays in binärer Klassifikation. y_true sind tatsächliche Werte und y_pred sind die vorhergesagten Werte des ML-Modells.

Der Aufruf np.clip(array, min_val, max_val) schneidet nur das Eingabearray ab. Zum Beispiel wird [0,0,1] auf [1e^-7, 1e^-7, 0.9999999] gekürzt.

np.mean() findet den Mittelwert des Eingabearrays, indem es ihn durch die Stapelgrösse N dividiert.

Warum verwenden wir einen minimalen Wert wie 1*e^-7 für das Clipping?

Die obige Formel enthält einige logarithmische Terme. Denn log(0) (d.h. natürlicher Logarithmus von Null) erzeugt undefiniert (unendlich).

Wenn unendlich durch N geteilt wird (d. h. Stapelgröße von vorhergesagten/wahren Werten), gibt es einen Fehler. Daher haben wir für das Clipping einen Minimalwert von 1*e^-7 verwendet.

Der obige Code ergibt die folgende Ausgabe.

[5.14164949]

Jetzt werden wir TensorFlow verwenden, um binäre Kreuzentropieverlustwerte zu finden. Schauen wir uns den folgenden Code an.

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

Die eingebaute Funktion tf.keras.losses.BinaryCrossentropy( from_logits=False , reduction=tf.keras.losses.Reduction.SUM_OVER_BATCH_SIZE) berechnet den Kreuzentropieverlust zwischen wahren Labels und vorhergesagten Labels.

Im obigen Code benötigt bce( y_true, y_pred) zwei Argumente.

1. y_true (wahres Label): Dies ist entweder 0 oder 1.
2. y_pred (vorhergesagter Wert): Dies ist die Vorhersage des Modells, d. h. ein einzelner Gleitkommawert, der entweder einen logit darstellt (d. h. einen Wert in [-inf, inf], wenn from_logits=True) oder eine Wahrscheinlichkeit (d. h. Wert in [0., 1.], wenn from_logits=False).

Weitere Details zu Binary Cross-Entropy finden Sie hier.

Der obige Code ergibt den folgenden binären Kreuzentropiewert.

5.1416497230529785

Dies wird durch die Ergebnisse deutlich, dass die Binary Cross Entropy Loss-Werte unter Verwendung von TensorFlow und aus der Formel gleich sind.