Was ist logits, softmax und softmax_cross_entropy_with_logits?

Kurze version:

Angenommen, Sie haben zwei Tensoren, wo y_hat enthält berechnete Werte für jede einzelne Klasse (Z. B. aus y = W*x +b) und y_true enthält eine one-hot codiert true-Etiketten.

y_hat  = ... # Predicted label, e.g. y = tf.matmul(X, W) + b
y_true = ... # True label, one-hot encoded

Interpretiert man das erreicht souverän in y_hat als nicht normalisierte log-Wahrscheinlichkeiten, dann sind Sie logits.

Zusätzlich, die gesamte cross-Entropie-Verlust berechnet, die in dieser Weise:

y_hat_softmax = tf.nn.softmax(y_hat)
total_loss = tf.reduce_mean(-tf.reduce_sum(y_true * tf.log(y_hat_softmax), [1]))

ist im wesentlichen äquivalent zu der Gesamtmenge cross-Entropie-Verlust berechnet mit der Funktion softmax_cross_entropy_with_logits():

total_loss = tf.reduce_mean(tf.nn.softmax_cross_entropy_with_logits(y_hat, y_true))

Lange version:

In der output-Schicht Ihr neuronales Netzwerk, werden Sie wahrscheinlich berechnen, die ein array enthält, die die Klasse souverän für jedes Ihrer Ausbildung Instanzen, wie aus einer Berechnung y_hat = W*x + b. Zu dienen, wie ein Beispiel weiter unten habe ich einen y_hat 2 x 3-array, wobei die Zeilen entsprechen der Trainings-Instanzen und die Spalten entsprechen den Klassen. Also hier gibt es 2 Trainings-Instanzen und 3 Klassen.

import tensorflow as tf
import numpy as np

sess = tf.Session()

# Create example y_hat.
y_hat = tf.convert_to_tensor(np.array([[0.5, 1.5, 0.1],[2.2, 1.3, 1.7]]))
sess.run(y_hat)
# array([[ 0.5,  1.5,  0.1],
#        [ 2.2,  1.3,  1.7]])

Beachten, dass die Werte werden nicht normalisiert (d.h. die Zeilen nicht summieren sich zu 1). Um zu normalisieren, können wir die softmax-Funktion, die, interpretiert die Eingabe als nicht normalisierte log-Wahrscheinlichkeiten (aka logits) - und Ausgänge normalisiert lineare Wahrscheinlichkeiten.

y_hat_softmax = tf.nn.softmax(y_hat)
sess.run(y_hat_softmax)
# array([[ 0.227863  ,  0.61939586,  0.15274114],
#        [ 0.49674623,  0.20196195,  0.30129182]])

Es ist wichtig zu verstehen, was die softmax-Ausgabe sagt. Unten habe ich gezeigt, dass eine Tabelle, die mehr ist offensichtlich der obigen Ausgabe. Es kann gesehen werden, dass, zum Beispiel, die Wahrscheinlichkeit der Ausbildung Beispiel 1 wird mit der Klasse "class 2" ist 0.619. Die Klasse Wahrscheinlichkeiten für jede Schulung Instanz sind normalisiert, so dass die Summe jeder Zeile 1.0.

                      Pr(Class 1)  Pr(Class 2)  Pr(Class 3)
                    ,--------------------------------------
Training instance 1 | 0.227863   | 0.61939586 | 0.15274114
Training instance 2 | 0.49674623 | 0.20196195 | 0.30129182

So, jetzt haben wir Klasse Wahrscheinlichkeiten für jede Schulung Beispiel, wo können wir das argmax() für jede Zeile generieren, die eine endgültige Einstufung. Von oben, wir können generieren, dass die Ausbildung von Beispiel 1 gehört zu der Klasse "class 2" - und Weiterbildung Beispiel 2 gehört der "Class 1".

Sind diese Klassifizierungen korrekt? Wir Messen müssen, gegen die wahren Bezeichnungen aus dem Trainings-set. Sie benötigen einen one-hot kodiert y_true array, wobei wieder die Zeilen-training-Instanzen und-Spalten sind Klassen. Unten habe ich ein Beispiel erstellt y_true one-hot-array, wo die wahre Bezeichnung für die Ausbildung Instanz 1 ist "Klasse 2" und die wahre Bezeichnung für die Ausbildung Beispiel 2 ist "Klasse 3".

y_true = tf.convert_to_tensor(np.array([[0.0, 1.0, 0.0],[0.0, 0.0, 1.0]]))
sess.run(y_true)
# array([[ 0.,  1.,  0.],
#        [ 0.,  0.,  1.]])

Ist die Wahrscheinlichkeitsverteilung in y_hat_softmax Nähe der Wahrscheinlichkeitsverteilung in y_true? Wir können cross-Entropie-Verlust zur Messung der Fehler.

Können wir die Berechnung der Kreuz-Entropie-Verlust bei einem row-wise basis, und die Ergebnisse sehen. Unten sehen wir, dass die Ausbildung der Instanz 1 hat einen Verlust von 0.479, während die Schulung Beispiel 2 hat einen höheren Verlust von 1.200. Dieses Ergebnis macht Sinn, weil in unserem Beispiel oben y_hat_softmax zeigte, dass die Ausbildung von Beispiel 1 die höchste Wahrscheinlichkeit für "Klasse 2", was mit Ausbildung Instanz 1 in y_true; aber die Vorhersage für die Ausbildung Beispiel 2 zeigte eine höchste Wahrscheinlichkeit für "Klasse 1", das entspricht nicht der wahren Klasse "Klasse 3".

loss_per_instance_1 = -tf.reduce_sum(y_true * tf.log(y_hat_softmax), reduction_indices=[1])
sess.run(loss_per_instance_1)
# array([ 0.4790107 ,  1.19967598])

Was wir wirklich wollen, ist der totale Verlust über alle Trainings-Instanzen. So können wir berechnen:

total_loss_1 = tf.reduce_mean(-tf.reduce_sum(y_true * tf.log(y_hat_softmax), reduction_indices=[1]))
sess.run(total_loss_1)
# 0.83934333897877944

Mit softmax_cross_entropy_with_logits()

Stattdessen können wir die Berechnung der Gesamt-Kreuz-Entropie-Verlust mit dem tf.nn.softmax_cross_entropy_with_logits() - Funktion, wie unten gezeigt.

loss_per_instance_2 = tf.nn.softmax_cross_entropy_with_logits(y_hat, y_true)
sess.run(loss_per_instance_2)
# array([ 0.4790107 ,  1.19967598])

total_loss_2 = tf.reduce_mean(tf.nn.softmax_cross_entropy_with_logits(y_hat, y_true))
sess.run(total_loss_2)
# 0.83934333897877922

Beachten Sie, dass total_loss_1 und total_loss_2 produzieren im wesentlichen gleichwertige Ergebnisse mit einigen kleinen unterschieden in der sehr Endziffern. Jedoch, Sie könnte genauso gut verwenden Sie die zweite Methode: man nimmt eine weniger code-Zeile und sammelt sich weniger numerische Fehler, weil die softmax erfolgt für Sie innerhalb von softmax_cross_entropy_with_logits().

Oben Antworten, die haben genug Beschreibung für die gestellte Frage.

Hinzu kommt, dass Tensorflow optimiert die Bedienung der Anwendung die Aktivierung der Funktion dann die Berechnung der Kosten, die mit eigenen Aktivierung, gefolgt von Kosten-Funktionen. Daher ist es eine gute Praxis zu verwenden: tf.nn.softmax_cross_entropy() über tf.nn.softmax(); tf.nn.cross_entropy()

Finden Sie markante Unterschied zwischen Ihnen in eine ressourcenintensive Modell.