neural-network @{ - Quelle est la différence entre sparse_softmax_cross_entropy_with_logits et softmax_cross_entropy_with_logits?




see loss (4)

Je voudrais juste ajouter 2 choses à la réponse acceptée que vous pouvez également trouver dans la documentation TF.

Premier:

tf.nn.softmax_cross_entropy_with_logits

NOTE: Bien que les classes soient mutuellement exclusives, leurs probabilités ne doivent pas l'être. Tout ce qui est requis est que chaque rangée d'étiquettes soit une distribution de probabilité valide. Si ce n'est pas le cas, le calcul du gradient sera incorrect.

Seconde:

tf.nn.sparse_softmax_cross_entropy_with_logits

NOTE: Pour cette opération, la probabilité d'une étiquette donnée est considérée comme exclusive. C'est-à-dire que les classes souples ne sont pas autorisées et que le vecteur des étiquettes doit fournir un seul index spécifique pour la classe vraie pour chaque ligne de logits (chaque entrée de minibatch).

Je suis récemment tombé sur tf.nn.sparse_softmax_cross_entropy_with_logits et je ne peux pas comprendre quelle est la différence par rapport à tf.nn.softmax_cross_entropy_with_logits .

La seule différence est-elle que les vecteurs de formation doivent être codés à chaud lors de l'utilisation de sparse_softmax_cross_entropy_with_logits ?

En lisant l'API, je n'ai trouvé aucune autre différence par rapport à softmax_cross_entropy_with_logits . Mais pourquoi avons-nous besoin de la fonction supplémentaire alors?

Est-ce que softmax_cross_entropy_with_logits ne devrait pas produire les mêmes résultats que sparse_softmax_cross_entropy_with_logits , s'il est fourni avec des données / vecteurs d'entraînement codés à chaud?


Les deux fonctions calculent les mêmes résultats et tf.nn.sparse_softmax_cross_entropy_with_logits calcule l'entropie croisée directement sur les étiquettes tf.nn.sparse_softmax_cross_entropy_with_logits au lieu de les convertir avec un codage à un seul codage .

Vous pouvez le vérifier en exécutant le programme suivant:

import tensorflow as tf
from random import randint

dims = 8
pos  = randint(0, dims - 1)

logits = tf.random_uniform([dims], maxval=3, dtype=tf.float32)
labels = tf.one_hot(pos, dims)

res1 = tf.nn.softmax_cross_entropy_with_logits(       logits=logits, labels=labels)
res2 = tf.nn.sparse_softmax_cross_entropy_with_logits(logits=logits, labels=tf.constant(pos))

with tf.Session() as sess:
    a, b = sess.run([res1, res2])
    print a, b
    print a == b

Ici, je crée un vecteur de logits aléatoires de logits de longueur et génère des étiquettes codées à chaud unique (où l'élément dans pos est 1 et les autres sont 0).

Après cela, je calcule softmax et softmax clairsemée et compare leur sortie. Essayez de le réexécuter plusieurs fois pour vous assurer qu'il produit toujours la même sortie


Avoir deux fonctions différentes est une commodité , car ils produisent le même résultat.

La différence est simple:

  • Pour sparse_softmax_cross_entropy_with_logits , les labels doivent avoir la forme [batch_size] et le dtype int32 ou int64. Chaque étiquette est un int dans la plage [0, num_classes-1] .
  • Pour softmax_cross_entropy_with_logits , les étiquettes doivent avoir la forme [batch_size, num_classes] et dtype float32 ou float64.

Les étiquettes utilisées dans softmax_cross_entropy_with_logits sont la seule version à chaud des étiquettes utilisées dans sparse_softmax_cross_entropy_with_logits .

Une autre petite différence est qu'avec sparse_softmax_cross_entropy_with_logits , vous pouvez donner -1 comme label pour avoir la perte 0 sur cette étiquette.


Faits préliminaires

  • Sur le plan fonctionnel, le sigmoïde est un cas partiel de la fonction softmax , lorsque le nombre de classes est égal à 2. Les deux effectuent la même opération: transforme les logits (voir ci-dessous) en probabilités.

    Dans une classification binaire simple, il n'y a pas de grande différence entre les deux. Toutefois, dans le cas d'une classification multinomiale, sigmoid permet de traiter des étiquettes non exclusives (ou multi-étiquettes ), tandis que softmax traite des classes exclusives (voir ci-dessous).

  • Un logit (également appelé score) est une valeur brute non mise à l'échelle associée à une classe , avant de calculer la probabilité. En termes d'architecture de réseau neuronal, cela signifie qu'un logit est la sortie d'une couche dense (entièrement connectée).

    La dénomination Tensorflow est un peu étrange: toutes les fonctions ci-dessous acceptent les logits, pas les probabilités , et appliquent la transformation elles-mêmes (ce qui est tout simplement plus efficace).

Famille des fonctions sigmoïdes

Comme indiqué précédemment, la fonction de perte sigmoid est destinée à la classification binaire. Mais les fonctions tensorflow sont plus générales et permettent d’effectuer une classification multi-étiquettes, lorsque les classes sont indépendantes. En d'autres termes, tf.nn.sigmoid_cross_entropy_with_logits résout tf.nn.sigmoid_cross_entropy_with_logits N classifications binaires.

Les étiquettes doivent être codées à une seule étape ou peuvent contenir des probabilités de classe variables.

tf.losses.sigmoid_cross_entropy permet en outre de définir les poids dans le lot , c'est -à- dire de rendre certains exemples plus importants que d'autres. tf.nn.weighted_cross_entropy_with_logits permet de définir des poids de classe (rappelez-vous, la classification est binaire), c'est-à-dire que les erreurs positives sont plus grandes que les erreurs négatives. Ceci est utile lorsque les données d'apprentissage sont déséquilibrées.

Famille de fonctions Softmax

Ces fonctions de perte doivent être utilisées pour une classification multinomiale mutuellement exclusive, c'est-à-dire une classe sur N Également applicable lorsque N = 2 .

Les étiquettes doivent être codées à chaud ou peuvent contenir des probabilités de classe variables: un exemple particulier peut appartenir à la classe A avec une probabilité de 50% et la classe B à une probabilité de 50%. Notez que, à proprement parler, cela ne signifie pas qu'il appartient aux deux classes, mais on peut interpréter les probabilités de cette façon.

Tout comme dans la famille sigmoid , tf.losses.softmax_cross_entropy permet de définir les poids dans le lot , c'est -à- dire de rendre certains exemples plus importants que d'autres. Autant que je sache, à partir de tensorflow 1.3, il n’existe aucun moyen intégré de définir des poids de classe .

[UPD] Dans tensorflow 1.5, la version v2 a été introduite et la perte originale de softmax_cross_entropy_with_logits obsolète. La seule différence entre eux est que dans une version plus récente, la rétropropagation se produit à la fois dans les logits et les libellés (expliquez pourquoi cela peut être utile).

Famille de fonctions clairsemées

Comme pour softmax ordinaire ci-dessus, ces fonctions de perte devraient être utilisées pour la classification multinomiale mutuellement exclusive, c'est-à-dire pour choisir l'une des N classes. La différence réside dans le codage des étiquettes: les classes sont spécifiées sous forme d’entiers (index de classe) et non de vecteurs one-hot. Évidemment, cela n'autorise pas les classes logicielles, mais cela peut économiser de la mémoire lorsqu'il existe des milliers ou des millions de classes. Cependant, notez que l'argument logits doit toujours contenir des logits pour chaque classe. Par conséquent, il consomme au moins [batch_size, classes] mémoire.

Comme ci-dessus, la version de tf.losses a un argument de weights qui permet de définir les pondérations dans le lot.

Famille de fonctions softmax échantillonnées

Ces fonctions offrent une autre alternative pour traiter un grand nombre de classes. Au lieu de calculer et de comparer une distribution de probabilité exacte, ils calculent une estimation de la perte à partir d'un échantillon aléatoire.

Les arguments weights et biases spécifient une couche distincte entièrement connectée, utilisée pour calculer les logits pour un échantillon choisi.

Comme ci-dessus, les labels ne sont pas encodées à chaud, mais ont la forme [batch_size, num_true] .

Les fonctions échantillonnées ne conviennent que pour la formation. En période d’essai, il est recommandé d’utiliser une perte softmax standard (peu abondante ou ponctuelle) pour obtenir une distribution réelle.

tf.nn.nce_loss est une autre tf.nn.nce_loss perte, qui effectue une estimation contrastée par le bruit (si cela vous intéresse, voir cette discussion très détaillée ). J'ai inclus cette fonction dans la famille softmax, car NCE garantit une approximation de softmax dans la limite.