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

Je passais par le tensorflow API docs ici. Dans le tensorflow de la documentation, ils ont utilisé un mot clé appelé logits. Quel est-il? Dans un grand nombre de méthodes dans l'API docs il est écrit comme

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

Si ce qui est écrit est ceux logits ne sont Tensors, pourquoi garder un nom différent comme logits?

Autre chose, c'est qu'il y a deux méthodes, je ne pouvais pas faire la différence. Ils ont été

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 docs ne sont pas claires pour moi. Je sais ce que tf.nn.softmax n'. Mais pas les autres. Un exemple sera vraiment utile.

InformationsquelleAutor Shubhashis | 2015-12-12

384

Logits signifie simplement que la fonction fonctionne sur le non mis à l'échelle de la sortie des premières couches et que l'échelle relative à comprendre les unités est linéaire. Il signifie, en particulier, la somme des entrées ne peuvent pas égal à 1, que les valeurs sont pas des probabilités que vous pourriez avoir une entrée de 5).

tf.nn.softmax produit juste le résultat de l'application de la la fonction softmax à une entrée du tenseur. Le softmax "squishes" les entrées de sorte que sum(input) = 1: c'est une façon de normaliser. La forme de la sortie d'un softmax est le même que l'entrée: il normalise les valeurs. Les sorties de softmax peut ê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_logits calcule la croix de l'entropie du résultat après l'application de la fonction softmax (mais elle le fait tous ensemble dans un plus mathématiquement de précaution). Il est similaire au résultat de:
```
sm = tf.nn.softmax(x)
ce = cross_entropy(sm)
```
La croix entropie est un résumé de la métrique: c'sommes à travers les éléments. La sortie de tf.nn.softmax_cross_entropy_with_logits sur une forme [2,5] tenseur est de la forme [2,1] (la première dimension est considérée comme le traitement par lot).

Si vous voulez faire de l'optimisation pour minimiser le cross-entropie ET vous êtes softmaxing après votre dernière couche, vous devez utiliser tf.nn.softmax_cross_entropy_with_logits au lieu de le faire vous-même, car il couvre numériquement instable coin des cas dans les mathématiquement droit chemin. Sinon, vous finirez par le piratage en ajoutant peu epsilons ici et là.

Édité 2016-02-07:
Si vous avez une seule étiquettes de classe, où un objet ne peut appartenir qu'à une seule catégorie, vous pouvez envisager d'utiliser tf.nn.sparse_softmax_cross_entropy_with_logits de sorte que vous n'avez pas à convertir vos étiquettes à un dense " one-hot tableau. Cette fonction a été ajoutée après la version 0.6.0.
- Sur le softmax_cross_entropy_with_logits, je ne sais pas si je l'utiliser correctement. Le résultat n'est pas stable dans mon code. Le même code s'exécute deux fois, le total de la précision des changements de 0,6 à 0,8. cross_entropy = tf.nn.softmax_cross_entropy_with_logits(tf.nn.softmax(tf.add(tf.matmul(x,W),b)),y) cost=tf.reduce_mean(cross_entropy). Mais quand j'utilise un autre moyen, pred=tf.nn.softmax(tf.add(tf.matmul(x,W),b)) cost =tf.reduce_mean(-tf.reduce_sum(y*tf.log(pred),reduction_indices=1)) le résultat est stable et mieux.
- Vous êtes en double-softmaxing dans votre première ligne. softmax_cross_entropy_with_logits attend non mis à l'échelle logits, pas la sortie de la tf.nn.softmax. Vous voulez juste tf.nn.softmax_cross_entropy_with_logits(tf.add(tf.matmul(x, W, b)) dans votre cas.
- Je pense que vous avez une erreur dans votre code, le b doit être en dehors de la fourchette, tf.nn.softmax_cross_entropy_with_logits(tf.add(tf.matmul(x, W), b)
- que signifie "que l'échelle relative à comprendre les unités est linéaire." une partie de votre première phrase signifie?
- Re: "parce qu'il couvre numériquement instable coin des affaires" je me demande si c'est vrai. Par définition de Softmax, il est numériquement stable, même si toutes les valeurs sont nuls ou négatifs.
- Upvoted-mais votre réponse est un peu incorrect lorsque vous dites que "[l]a forme de sortie d'un softmax est le même que l'entrée - il normalise les valeurs". Softmax ne pas "écraser" les valeurs de sorte que leur somme soit égale à 1. Il a également redistribue, et c'est probablement la raison principale pour laquelle il est utilisé. Voir stackoverflow.com/questions/17187507/..., surtout Piotr Czapla de réponse.
InformationsquelleAutor dga
255

Version courte:

Supposons que vous avez deux tenseurs, où y_hat contient calculé des scores pour chaque classe (par exemple, à partir de y = W*x +b) et y_true contient un chaud codé vrai étiquettes.
```
y_hat  = ... # Predicted label, e.g. y = tf.matmul(X, W) + b
y_true = ... # True label, one-hot encoded
```
Si vous interpréter les notes de y_hat comme unnormalized journal des probabilités, alors qu'ils sont logits.

En outre, le total de l'entropie croisée calculé 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 l'équivalent du total de la croix-entropie 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 aurez probablement calculer un tableau qui contient la classe des scores pour chacun de vos instances de formation, comme à partir d'un calcul y_hat = W*x + b. Pour servir d'exemple, ci-dessous, j'ai créé un y_hat de 2 x 3 tableau, où les lignes correspondent à la formation des instances et les colonnes correspondent à des classes. Donc, ici, il y a 2 formation des instances 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]])
```
Remarque que les valeurs ne sont pas normalisées (c'est à dire les lignes de ne pas ajouter jusqu'à 1). Afin de les normaliser, nous pouvons appliquer la fonction softmax, qui interprète l'entrée comme unnormalized journal des probabilités (aka logits) et les sorties normalisées linéaire des probabilités.
```
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 l'softmax de sortie, c'est dire. Ci-dessous, j'ai montré un tableau plus clair représente la sortie ci-dessus. Il peut être vu que, par exemple, la probabilité de formation de l'instance 1 "Classe 2" est 0.619. La classe de probabilités pour chaque formation de l'instance sont normalisées, de sorte que la somme de chaque ligne est 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
```
Alors maintenant, nous avons la classe probabilités pour chaque formation de l'instance, où l'on peut prendre le argmax() de chaque ligne pour générer un classement final. À partir de ci-dessus, on peut générer que de la formation de l'instance 1 appartient à la "Classe 2" et de la formation de l'instance 2 appartient à la "Classe 1".

Sont ces classifications correctes? Nous avons besoin de mesurer contre le vrai étiquettes à partir de l'ensemble de la formation. Vous aurez besoin d'un "one-hot" codé y_true tableau, où encore une fois les lignes sont des instances de formation et les colonnes sont des classes. Ci-dessous, j'ai créé un exemple y_true "one-hot" tableau où la véritable label pour la formation de l'instance 1 est de "Classe 2" et la véritable label pour la formation de l'instance 2 est de "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.]])
```
Est la distribution de probabilité dans y_hat_softmax proche de la distribution de probabilité dans y_true? Nous pouvons utiliser entropie croisée de mesurer l'erreur.

Nous pouvons calculer l'entropie croisée sur une ligne sage de base et voir les résultats. Ci-dessous, nous pouvons voir que la formation à l'exemple 1 a une perte de 0.479, tandis que la formation de l'instance de 2 a plus de perte de 1.200. Ce résultat est logique car dans notre exemple ci-dessus, y_hat_softmax a montré que la formation de l'instance 1 de la probabilité la plus élevée était de "Classe 2", qui correspond à la formation de l'instance 1 dans y_true; toutefois, la prévision pour la formation de l'instance 2 ont montré une plus grande probabilité de "Classe 1", ce 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. On peut 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
```
À l'aide de softmax_cross_entropy_with_logits()

On peut, au lieu de calculer le total de la croix entropie à l'aide de la tf.nn.softmax_cross_entropy_with_logits() fonction, comme illustré 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
```
Noter que total_loss_1 et total_loss_2 produire essentiellement des résultats équivalents avec quelques légères différences dans la finale chiffres. Cependant, vous pourriez aussi bien utiliser la deuxième approche: il faut une moindre ligne de code et accumule le moins d'erreur numérique parce que le softmax est fait pour vous à l'intérieur de softmax_cross_entropy_with_logits().
- C'est l'une des meilleures illustrations de la perte de la minimisation j'ai vu!
- Merci pour votre effort de l'écrire si joliment!
- 么么哒， vous aime pour ce
- Incroyable explication étape par étape. Merci!!!!
- la meilleure explication pour les débutants
InformationsquelleAutor stackoverflowuser2010
45

tf.nn.softmax calcule la propagation de l'avant par l'intermédiaire d'un softmax couche. Vous l'utilisez pendant évaluation du modèle lorsque vous calculez les probabilités que les sorties du modèle.

tf.nn.softmax_cross_entropy_with_logits calcule le coût d'un softmax couche. Il est uniquement utilisé lors de formation.

Les logits sont les unnormalized journal des probabilités de sortie du modèle (les valeurs de sortie avant la softmax la normalisation est appliquée).
- - Je l'obtenir. Pourquoi ne pas appeler la fonction, de la tf.nn.softmax_cross_entropy_sans_normalization?
- parce qu'il normalise les valeurs (en interne) au cours de la croix-calcul de l'entropie. Le point de tf.nn.softmax_cross_entropy_with_logits est d'évaluer combien le modèle s'écarte de l'or, des étiquettes, de ne pas fournir un normalisée de sortie.
- Dans le cas de l'utilisation de la tf.nn.sparse_softmax_cross_entropy_with_logits() calcule le coût d'un éparses softmax couche, et donc ne doit être utilisée lors de la formation de ce que serait l'alternative lors de l'exécution du modèle par rapport à de nouvelles données, est-il possible d'obtenir les probabilités de celui-ci.
- il n'est pas possible d'obtenir les probabilités de tf.nn.sparse_softmax_cross_entropy_with_logits. Pour obtenir les probabilités d'utiliser tf.nn.softmax.
InformationsquelleAutor Ian Goodfellow
3

Réponses ci-dessus ont assez de description pour la question posée.

Ajoutant à cela, Tensorflow a optimisé le fonctionnement de l'application de la fonction d'activation, puis en calculant les coûts à l'aide de sa propre activation suivie par des fonctions de coût. Par conséquent, il est une bonne pratique à utiliser: tf.nn.softmax_cross_entropy() sur tf.nn.softmax(); tf.nn.cross_entropy()

Vous pouvez trouver de différence importante entre eux dans une exploitation intensive des ressources de modèle.
- la réponse ci-dessus n'ont manifestement pas lu la question.. Ils disent tous les mêmes choses, qui sont connus, mais ne pas répondre à la question elle-même
- Vouliez-vous dire, tf.nn.softmax suivi de tf.losses.softmax_cross_entropy?
InformationsquelleAutor Abish

Vous devez vous connecter pour publier un commentaire.