Qu'est-ce que logits, softmax et softmax_cross_entropy_with_logits?

Je parcourais les documents de l'API tensorflow ici . Dans la documentation tensorflow, ils ont utilisé un mot-clé appelé logits. Qu'Est-ce que c'est? Dans de nombreuses méthodes des documents API, il est écrit comme

tf.nn.softmax(logits, name=None)

Si ce qui est écrit est que ce logitssont seulement Tensors, pourquoi garder un nom différent comme logits?

Une autre chose est qu'il y a deux méthodes que je ne pouvais pas différencier. Ils étaient

tf.nn.softmax(logits, name=None)
tf.nn.softmax_cross_entropy_with_logits(logits, labels, name=None)

Quelles sont les différences entre eux? Les documents ne sont pas clairs pour moi. Je sais ce que tf.nn.softmaxça fait. Mais pas l'autre. Un exemple sera vraiment utile.

Logits signifie simplement que la fonction fonctionne sur la sortie non mise à l'échelle des couches précédentes et que l'échelle relative pour comprendre les unités est linéaire. Cela signifie, en particulier, que la somme des entrées peut ne pas être égale à 1, que les valeurs ne sont pas des probabilités (vous pouvez avoir une entrée de 5).

tf.nn.softmaxproduit juste le résultat de l'application de la fonction softmax à un tenseur d'entrée. Le softmax "écrase" les entrées pour que sum(input) = 1: c'est une façon de normaliser. La forme de sortie d'un softmax est la même que l'entrée: elle normalise juste les valeurs. Les sorties de softmax peuvent être interprétées comme des probabilités.

a = tf.constant(np.array([[.1, .3, .5, .9]]))
print s.run(tf.nn.softmax(a))
[[ 0.16838508  0.205666    0.25120102  0.37474789]]

En revanche, tf.nn.softmax_cross_entropy_with_logitscalcule l'entropie croisée du résultat après avoir appliqué la fonction softmax (mais il le fait tous ensemble d'une manière mathématiquement plus prudente). Il est similaire au résultat de:

sm = tf.nn.softmax(x)
ce = cross_entropy(sm)

L'entropie croisée est une métrique récapitulative: elle résume les éléments. La sortie de tf.nn.softmax_cross_entropy_with_logitssur un [2,5]tenseur de forme est de forme [2,1](la première dimension est traitée comme le lot).

Si vous souhaitez faire une optimisation pour minimiser l'entropie croisée ET que vous effectuez un softmaxing après votre dernière couche, vous devez utiliser tf.nn.softmax_cross_entropy_with_logitsau lieu de le faire vous-même, car il couvre les cas d'angle numériquement instables de la bonne manière mathématique. Sinon, vous finirez par le pirater en ajoutant de petits epsilons ici et là.

Modifié le 07/02/2016: Si vous avez des étiquettes à classe unique, où un objet ne peut appartenir qu'à une seule classe, vous pouvez désormais envisager d'utiliser tf.nn.sparse_softmax_cross_entropy_with_logitsafin de ne pas avoir à convertir vos étiquettes en un tableau dense à une seule zone. Cette fonction a été ajoutée après la version 0.6.0.

Version courte:

Supposons que vous ayez deux tenseurs, où y_hatcontient les scores calculés pour chaque classe (par exemple, à partir de y = W * x + b) et y_truecontient les véritables étiquettes codées à chaud.

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

Si vous interprétez les scores y_hatcomme des probabilités logarithmiques non normalisées, ce sont des logits .

De plus, la perte totale d'entropie croisée calculée de cette manière:

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

est essentiellement équivalent à la perte d'entropie croisée totale calculée avec la fonction softmax_cross_entropy_with_logits():

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

Version longue:

Dans la couche de sortie de votre réseau de neurones, vous calculerez probablement un tableau qui contient les scores de classe pour chacune de vos instances d'entraînement, par exemple à partir d'un calcul y_hat = W*x + b. Pour servir d'exemple, ci-dessous, j'ai créé un y_hattableau 2 x 3, où les lignes correspondent aux instances de formation et les colonnes correspondent aux classes. Il y a donc ici 2 instances de formation et 3 classes.

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

Notez que les valeurs ne sont pas normalisées (c'est-à-dire que les lignes ne totalisent pas 1). Afin de les normaliser, nous pouvons appliquer la fonction softmax, qui interprète l'entrée comme des probabilités de log non normalisées (alias logits ) et génère des probabilités linéaires normalisées.

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

Il est important de bien comprendre ce que la sortie softmax dit. Ci-dessous, j'ai montré un tableau qui représente plus clairement la sortie ci-dessus. On peut voir que, par exemple, la probabilité que l'instance de formation 1 soit de "classe 2" est de 0,619. Les probabilités de classe pour chaque instance de formation sont normalisées, la somme de chaque ligne est donc de 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

Nous avons donc maintenant des probabilités de classe pour chaque instance de formation, où nous pouvons prendre l'argmax () de chaque ligne pour générer une classification finale. De ci-dessus, nous pouvons générer que l'instance de formation 1 appartient à la "classe 2" et l'instance de formation 2 appartient à la "classe 1".

Ces classifications sont-elles correctes? Nous devons mesurer par rapport aux véritables étiquettes de l'ensemble de formation. Vous aurez besoin d'un y_truetableau codé à chaud , où encore les lignes sont des instances d'apprentissage et les colonnes sont des classes. Ci-dessous, j'ai créé un exemple d' y_trueun tableau à chaud où la véritable étiquette pour l'instance de formation 1 est "Classe 2" et la véritable étiquette pour l'instance de formation 2 est "Classe 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.]])

La distribution de probabilité est-elle y_hat_softmaxproche de la distribution de probabilité de y_true? Nous pouvons utiliser la perte d'entropie croisée pour mesurer l'erreur.

Nous pouvons calculer la perte d'entropie croisée par ligne et voir les résultats. Ci-dessous, nous pouvons voir que l'instance de formation 1 a une perte de 0,479, tandis que l'instance de formation 2 a une perte plus élevée de 1,200. Ce résultat est logique parce que dans notre exemple ci-dessus, a y_hat_softmaxmontré que la probabilité la plus élevée de l'instance de formation 1 était pour "Classe 2", qui correspond à l'instance de formation 1 dans y_true; cependant, la prévision pour l'instance de formation 2 a montré une probabilité la plus élevée pour "Classe 1", qui ne correspond pas à la vraie classe "Classe 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])

Ce que nous voulons vraiment, c'est la perte totale sur toutes les instances de formation. Nous pouvons donc calculer:

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

Utilisation de softmax_cross_entropy_with_logits ()

Nous pouvons plutôt calculer la perte d'entropie croisée totale en utilisant la tf.nn.softmax_cross_entropy_with_logits()fonction, comme indiqué ci-dessous.

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

Notez cela total_loss_1et total_loss_2produisez des résultats essentiellement équivalents avec quelques petites différences dans les tout derniers chiffres. Cependant, vous pourriez aussi bien utiliser la deuxième approche: elle prend une ligne de code en moins et accumule moins d'erreur numérique car le softmax est fait pour vous à l'intérieur de softmax_cross_entropy_with_logits().

tf.nn.softmaxcalcule la propagation directe à travers une couche softmax. Vous l'utilisez lors de l' évaluation du modèle lorsque vous calculez les probabilités de sortie du modèle.

tf.nn.softmax_cross_entropy_with_logitscalcule le coût d'une couche softmax. Il n'est utilisé que pendant l' entraînement .

Les logits sont les probabilités logarithmiques non normalisées générées par le modèle (les valeurs générées avant que la normalisation softmax ne leur soit appliquée).

Les réponses ci-dessus ont suffisamment de description pour la question posée.

De plus, Tensorflow a optimisé le fonctionnement de l'application de la fonction d'activation, puis le calcul des coûts à l'aide de sa propre activation suivie des fonctions de coût. Par conséquent, c'est une bonne pratique à utiliser: tf.nn.softmax_cross_entropy()surtf.nn.softmax(); tf.nn.cross_entropy()

Vous pouvez trouver une différence importante entre eux dans un modèle gourmand en ressources.

Ce qui va toujours au softmaxlogit, c'est ce que J. Hinton répète tout le temps dans les vidéos coursera.

Réponse compatible Tensorflow 2.0 : Les explications dgaet stackoverflowuser2010les détails de Logits et des fonctions associées sont très détaillés.

Toutes ces fonctions, lorsqu'elles sont utilisées dans Tensorflow 1.x, fonctionneront correctement, mais si vous migrez votre code de 1.x (1.14, 1.15, etc)vers 2.x (2.0, 2.1, etc..), l'utilisation de ces fonctions entraînera une erreur.

Par conséquent, en spécifiant les appels compatibles 2.0 pour toutes les fonctions, nous avons discuté ci-dessus, si nous migrons de 1.x to 2.x, au profit de la communauté.

Fonctions en 1.x :

1. tf.nn.softmax
2. tf.nn.softmax_cross_entropy_with_logits
3. tf.nn.sparse_softmax_cross_entropy_with_logits

Fonctions respectives lors de la migration de 1.x vers 2.x :

1. tf.compat.v2.nn.softmax
2. tf.compat.v2.nn.softmax_cross_entropy_with_logits
3. tf.compat.v2.nn.sparse_softmax_cross_entropy_with_logits

Pour plus d'informations sur la migration de 1.x vers 2.x, veuillez consulter ce Guide de migration .

Une dernière chose que je voudrais certainement souligner car logit est juste une sortie brute, généralement la sortie de la dernière couche. Cela peut également être une valeur négative. Si nous l'utilisons tel qu'il est pour l'évaluation de «l'entropie croisée» comme mentionné ci-dessous:

-tf.reduce_sum(y_true * tf.log(logits))

alors ça ne marchera pas. Le journal de -ve n'est pas défini. Ainsi, l'utilisation de l'activation o softmax résoudra ce problème.

C'est ma compréhension, veuillez me corriger si je me trompe.