La fonction d'erreur d'entropie croisée dans les réseaux de neurones

115

Dans le MNIST For ML Beginners, ils définissent l’entropie croisée comme

H_{y^{'}} (y) := - \sum_{i} y_{i}^{'} \log (y_{i})

$H_{y'} (y) := - \sum_{i} y_{i}' \log (y_i)$

$y_i$ est la valeur de probabilité prédite pour la classe et est la probabilité vraie pour cette classe. $i$ $y_i'$

question 1

N'est-ce pas un problème que (dans ) puisse être 0? Cela voudrait dire que nous avons bien sûr un très mauvais classificateur. Mais pensez à une erreur dans notre ensemble de données, par exemple une "évidence" étiquetée . Cela tomberait-il simplement en panne? Est-ce que le modèle que nous avons choisi (activation de softmax à la fin) ne donne fondamentalement jamais la probabilité 0 pour la classe correcte? $y_i$ $\log(y_i)$ 13

question 2

J'ai appris que l'entropie croisée est définie comme

H_{y^{'}} (y) := - \sum_{i} (y_{i}^{'} \log (y_{i}) + (1 - y_{i}^{'}) \log (1 - y_{i}))

$H_{y'}(y) := - \sum_{i} ({y_i' \log(y_i) + (1-y_i') \log (1-y_i)})$

Qu'est-ce qui est correct? Avez-vous des références de manuels scolaires pour l'une ou l'autre version? Comment ces fonctions diffèrent-elles dans leurs propriétés (en tant que fonctions d'erreur pour les réseaux de neurones)?

machine-learning tensorflow

— Martin Thoma
source

Voir aussi: stats.stackexchange.com/questions/80967/…

— Piotr Migdal

Voir aussi: article de blog de Kullback-Leibler Divergence Explained .

— Piotr Migdal

101

Une façon d'interpréter l'entropie croisée consiste à le voir comme une log-vraisemblance (moins) pour les données , sous un modèle . $y_i'$ $y_i$

Supposons que vous ayez un modèle fixe ("hypothèse"), qui prédit pour classes leurs probabilités d’apparition hypothétiques . Supposons que vous maintenant (en réalité) instances de classe , instances de classe , instances de classe , etc. Selon votre modèle, la probabilité que cela se produise est la suivante: Utilisation du logarithme et modification du signe: $n$ $\{1,2,\dots, n\}$ $y_1, y_2,\dots, y_n$ $k_1$ $1$ $k_2$ $2$ $k_n$ $n$

P [d a t a | m o d e l] := y_{1}^{k_{1}} y_{2}^{k_{2}} \dots y_{n}^{k_{n}} .

$P[data|model] := y_1^{k_1}y_2^{k_2}\dots y_n^{k_n}.$

- \log P [d a t a | m o d e l] = - k_{1} \log y_{1} - k_{2} \log y_{2} - \dots - k_{n} \log y_{n} = - \sum_{i} k_{i} \log y_{i}

$-\log P[data|model] = -k_1\log y_1 -k_2\log y_2 - \dots -k_n\log y_n = -\sum_i k_i \log y_i$

Si vous divisez maintenant la somme de droite par le nombre d'observations et notez les probabilités empiriques sous la forme , vous obtiendrez une entropie croisée:

N = k_{1} + k_{2} + \dots + k_{n}

$N = k_1+k_2+\dots+k_n$

y_{i}^{'} = k_{i} / N

$y_i'=k_i/N$

- \frac{1}{N} \log P [d a t a | m o d e l] = - \frac{1}{N} \sum_{i} k_{i} \log y_{i} = - \sum_{i} y_{i}^{'} \log y_{i} =: H (y^{'}, y)

$-\frac{1}{N} \log P[data|model] = -\frac{1}{N}\sum_i k_i \log y_i = -\sum_i y_i'\log y_i =: H(y', y)$

De plus, la vraisemblance log d'un ensemble de données donné à un modèle peut être interprétée comme une mesure de la "longueur de codage" - le nombre de bits que vous prévoyez dépenser pour coder cette information si votre schéma de codage serait basé sur votre hypothèse.

Cela découle de l'observation selon laquelle un événement indépendant de probabilité nécessite au moins bits pour le coder (en supposant un codage efficace) et, par conséquent, l'expression est littéralement la longueur attendue du codage. , où les longueurs de codage pour les événements sont calculées à l'aide de la distribution "supposée", tandis que l'attente est remplacée par la distribution réelle. $y_i$ $-\log_2 y_i$

- \sum_{i} y_{i}^{'} \log_{2} y_{i},

$-\sum_i y_i'\log_2 y_i,$

Enfin, au lieu de dire "mesure de la longueur de codage attendue", j'aime beaucoup utiliser le terme informel "mesure de surprise". Si vous avez besoin de beaucoup de bits pour coder un événement attendu d'une distribution, la distribution est "vraiment surprenante" pour vous.

Avec ces intuitions en tête, les réponses à vos questions peuvent être vues comme suit:

Question 1 . Oui. C'est un problème lorsque le correspondant est différent de zéro en même temps $y_i'$ . Cela correspond à la situation dans laquelle votre modèle estime qu'une classe a une probabilité d'occurrence nulle, mais que la classe apparaît en réalité. En conséquence, la "surprise" de votre modèle est infiniment grande: votre modèle n’a pas pris en compte cet événement et a maintenant besoin d’un nombre infini de bits pour le coder. C'est pourquoi vous obtenez l'infini comme entropie croisée.

Pour éviter ce problème, vous devez vous assurer que votre modèle ne fait pas de suppositions irréfléchies sur le fait que quelque chose est impossible alors que cela peut arriver. En réalité, les gens ont tendance à utiliser des fonctions sigmoïdes ou "softmax" comme modèles d'hypothèse, suffisamment conservateurs pour laisser au moins une chance à chaque option.

Si vous utilisez un autre modèle d’hypothèses, il vous appartient de le régulariser (ou «lisser») pour qu’il ne suppose pas des zéros là où il ne devrait pas.
Question 2 . Dans cette formule, on suppose habituellement pour être soit ou , tandis que est l'hypothèse de probabilité du modèle pour l'entrée correspondante. Si vous regardez de plus près, vous verrez que c'est simplement un pour les données binaires, un équivalent de la deuxième équation de cette réponse. $y_i'$ $0$ $1$ $y_i$ $-\log P[data|model]$

Par conséquent, à proprement parler, bien que cela reste un log-vraisemblance, cela n’est pas syntaxiquement équivalent à l’entropie croisée. Ce que certaines personnes veulent dire en parlant d'une telle expression comme entropie croisée, c'est qu'il s'agit en fait d'une somme sur des entropies croisées binaires pour des points individuels du jeu de données: où et doit être interprété comme les distributions binaires correspondantes et .
$\sum_{i} H (y_{i}^{'}, y_{i}),$ $\sum_i H(y_i', y_i),$ $y_i'$ $y_i$ $(y_i', 1-y_i')$ $(y_i, 1-y_i)$

— KT.
source

1

Pouvez-vous fournir une source où ils définissent ? Ici, ils le définissent comme une distribution one-hot pour le label de classe actuel. Quelle est la différence?

y' i = \frac{k i}{N}

$y′i=\frac{ki}{N}$

— Lenar Hoyt

1

Dans le didacticiel MNIST TensorFlow, ils le définissent également en termes de vecteurs one-hot.

— Lenar Hoyt

@LenarHoyt Lorsque , serait équivalent à one-hot. Vous pouvez considérer one-hot comme le codage d'un élément basé sur sa probabilité catégorique empirique (réelle).

N = 1

$N=1$

k_{i} / N

$k_i/N$

— THN

"un événement indépendant nécessite ... de l'encoder" - pourriez-vous expliquer ce bit s'il vous plaît?

— Alex

@Alex Cela nécessitera peut-être des explications plus longues pour bien comprendre - lisez sur les codes de Shannon-Fano et sur la relation entre le codage optimal et l'équation d'entropie de Shannon. Pour mettre les choses en sourdine, si un événement a la probabilité 1/2, votre meilleur pari est de le coder en utilisant un seul bit. Si elle a une probabilité de 1/4, vous devriez dépenser 2 bits pour la coder, etc. En général, si votre ensemble d'événements a des probabilités de la forme 1/2 ^ k, vous devriez leur donner des longueurs k - ainsi votre code approcher la longueur optimale de Shannon.

— KT.

22

La première formule de perte de journal que vous utilisez concerne la perte de journal multiclass, où l' indice énumère les différentes classes dans un exemple. La formule suppose qu'un seul dans chaque exemple est à 1 et que les autres sont tous égaux à 0. $i$ $y_i'$

Cela signifie que la formule ne capture que les erreurs sur la classe cible. Il supprime toute notion d'erreur que vous pourriez considérer comme "faux positif" et ne se soucie pas de la façon dont les probabilités prédites sont distribuées autres que la probabilité prédite de la classe vraie.

Une autre hypothèse est que pour les prédictions de chaque exemple. Cela se fait automatiquement par une couche softmax - si vous utilisez quelque chose de différent, vous devrez redimensionner les sorties pour répondre à cette contrainte. $\sum_i y_i = 1$

question 1

N'est-ce pas un problème que le (dans le ) puisse être 0? $y_i$ $log(y_i)$

Oui, cela peut être un problème, mais ce n’est généralement pas pratique. Il est très peu probable qu'une couche softmax initialisée de manière aléatoire produise un résultat exact 0dans une classe. Mais c'est possible, donc cela vaut la peine de le permettre. D'abord, n'évaluez pas le pour aucun , car les classes négatives contribuent toujours à 0 à l'erreur. Deuxièmement, dans le code pratique, vous pouvez limiter la valeur à quelque chose comme pour la stabilité numérique - dans de nombreux cas, cela n’est pas obligatoire, mais c’est une programmation défensive judicieuse. $log(y_i)$ $y_i'=0$ log( max( y_predict, 1e-15 ) )

question 2

J'ai appris que l'entropie croisée est définie comme $H_{y'}(y) := - \sum_{i} ({y_i' \log(y_i) + (1-y_i') \log (1-y_i)})$

Cette formulation est souvent utilisée pour un réseau avec une sortie prédisant deux classes (généralement, appartenance à une classe positive pour 1 et négative pour une sortie 0). Dans ce cas, ne peux avoir qu'une seule valeur - vous pouvez perdre la somme sur . $i$ $i$

Si vous modifiez un tel réseau pour qu'il ait deux sorties opposées et utilisez softmax plus la première définition de perte de journal, vous constaterez qu'il s'agit en fait de la même mesure d'erreur mais en repliant la métrique d'erreur de deux classes en une seule sortie.

S'il y a plus d'une classe dont on peut prédire l'appartenance et que les classes ne sont pas exclusives, c'est-à-dire qu'un exemple peut être n'importe quelle classe ou toutes les classes en même temps, vous devrez alors utiliser cette deuxième formulation. Pour la reconnaissance de chiffres, ce n'est pas le cas (un chiffre écrit ne doit avoir qu'une seule "vraie" classe)

— Neil Slater
source

Notez qu'il y a une certaine ambiguïté dans la présentation de la seconde formule - elle pourrait en théorie ne supposer qu'une classe et énumérerais ensuite les exemples.

i

$i$

— Neil Slater

Je suis désolé, j'ai demandé quelque chose de différent de ce que je voulais savoir. Je ne vois pas de problème dans , mais dans , à cause de . Pourriez-vous ajuster votre réponse à cela?

\log (y_{i}) = 0

$\log(y_i) = 0$

y_{i} = 0

$y_i = 0$

\log (y_{i})

$\log(y_i)$

— Martin Thoma

@NeilSlater si les classes ne sont pas mutuellement exclusives, le vecteur de sortie de chaque entrée peut contenir plus d'un 1, devrions-nous utiliser la deuxième formule?

— Médias

1

@ Media: Pas vraiment. Vous souhaitez cependant examiner des éléments tels que la classification hiérarchique. . .

— Neil Slater

1

@Javi: Dans la question du PO, est la vérité au sol, donc généralement 0 ou 1. C'est qui est la sortie softmax. Cependant, peut finir par être nul en pratique en raison de l'arrondi en virgule flottante. Cela se produit réellement.

y_{i}^{'}

$y'_i$

y_{i}

$y_i$

y_{i}

$y_i$

— Neil Slater

11

Compte tenu , vous souhaitez optimiser votre méthode d'apprentissage de la machine pour obtenir le le plus près possible de . $y_{true}$ $y_{predict}$ $y_{true}$

Première question:

La réponse ci-dessus a expliqué le contexte de votre première formule, l’entropie croisée définie dans la théorie de l’information.

D'une opinion autre que la théorie de l'information:

vous pouvez examiner vous-même que la première formule n'entraîne aucune pénalité pour les faux positifs (la vérité est fausse, mais votre modèle prédit qu'elle est juste), tandis que la seconde formule prévoit des pénalités pour les faux positifs. Par conséquent, le choix de la première formule ou de la seconde affectera vos mesures (autrement dit, quelle quantité statistique vous souhaitez utiliser pour évaluer votre modèle).

En mot profane:

Si vous voulez accepter que presque toutes les bonnes personnes soient votre ami mais acceptent que certaines mauvaises personnes deviennent votre ami, utilisez la première formule comme critère.

Si vous voulez vous punir d'accepter que certaines personnes mauvaises soient votre ami, mais que votre taux d'acceptation des bonnes personnes soit peut-être inférieur à la première condition, utilisez la deuxième formule.

Tandis que, je suppose que la plupart d’entre nous sommes critiques et aimerions choisir le second (de sorte que beaucoup de paquets ML supposent ce qui est de l’entropie croisée).

Deuxième question:

Entropie croisée par échantillon par classe:

- y_{t r u e} \log (y_{p r e d i c t})

$-y_{true}\log{(y_{predict})}$

Entropie croisée pour des ensembles de données entiers:

\sum_{i}^{n} \sum_{k}^{K} - y_{t r u e}^{(k)} \log (y_{p r e d i c t}^{(k)})

$\sum_i^n \sum_k^K -y_{true}^{(k)}\log{(y_{predict}^{(k)})}$

Ainsi, quand il n'y aura que deux classes (K = 2), vous aurez la deuxième formule.

— Intelligence artificielle
source

5

Ces problèmes sont résolus par l'utilisation de softmax dans le tutoriel.

Pour 1), vous avez raison de dire que softmax garantit une sortie non nulle car il expose son entrée. Pour les activations qui ne donnent pas cette garantie (comme relu), il est simple d'ajouter un très petit terme positif à chaque sortie pour éviter ce problème.

Quant à 2), ils ne sont évidemment pas les mêmes, mais la formulation de softmax qu’ils ont donnée s’occupe de la question. Si vous n'utilisiez pas softmax, cela vous ferait apprendre d'énormes termes de biais qui supposent 1 pour chaque classe, quelle que soit l'entrée. Mais comme ils normalisent le softmax dans toutes les classes, le seul moyen de maximiser le résultat de la classe correcte est de le rendre relativement grand par rapport aux classes incorrectes.

— Jamesmf
source

"vous avez raison de dire que softmax garantit une sortie non nulle" - je sais que c'est théoriquement le cas. En réalité, peut-il arriver que (en raison de problèmes numériques) cela devienne 0?

— Martin Thoma

Bonne question. Je suppose qu'il est parfaitement possible que la fonction d'exponentiation produise 0.0 si votre entrée est trop petite pour la précision de votre float. Cependant, je suppose que la plupart des implémentations ajoutent le minuscule terme positif pour garantir une entrée non nulle.

— jamesmf

0

N'est-ce pas un problème que (dans ) puisse être 0? $y_i$ $\log(y_i)$

Oui, puisque n'est pas défini, mais ce problème est évité en utilisant en pratique. $\log(0)$ $\log(y_i + \epsilon)$

Qu'est-ce qui est correct?
(a) ou (b) ? $H_{y'} (y) := - \sum_{i} y_{i}' \log (y_i)$
$H_{y'}(y) := - \sum_{i} ({y_i' \log(y_i) + (1-y_i') \log(1-y_i)})$

(a) est correct pour une prédiction à plusieurs classes (il s’agit en fait d’une double somme), (b) est identique à (a) pour une prédiction à deux classes. Les deux sont entropie croisée.

Exemple:

Supposons que chaque donnée d'apprentissage porte l'étiquette et que le modèle prédit . $x_i$ $c_i' \in \{0, 1\}$ $c_i \in [0, 1]$

Pour 5 points de données, l'étiquette vraie et la prédiction du modèle sont: $c_i'$ $c_i$

$(c_i', c_i)=\{(0, 0.1), (0, 0.4), (0, 0.8), (1, 0.8), (1, 0.2)\}$ (1),

Définir les vecteurs et comme $y_i'$ $y_i$

$y_{ik}':=1$ si , et sinon, $c_i'=k$ $:=0$
$y_{ik}:=p(k|x_i)$ est la probabilité que appartienne à la classe , qui est estimée par le modèle. $x_i$ $k$

Exemple (1) en notation se transforme en: $(y_i', y_i)$

$(y_i', y_i)=\{([1, 0], [0.9, 0.1]),$ $([1, 0], [0.6, 0.4]),$ $([1, 0], [0.2, 0.8]),$ $([0, 1], [0.2, 0.8]),$ $([0, 1], [0.8, 0.2])\}$ ,

(A) et (b) sont calculés comme suit:

$H_{y'}(y)=-1/5([log(0.9)+log(0.6) + log(0.2)]_{c_i=0} + [log(0.8) + log(0.2)]_{c_i=1}) = 0.352$

Dérivation:

Supposons qu'il y ait plusieurs classes à . Pour le point d’entraînement , est équivalent à ce qui correspond à 1 dans la position et à 0 ailleurs. Lorsque , nous voulons que la sortie du modèle soit proche de 1. Par conséquent, la perte de peut être définie comme , ce qui donne . Les pertes sur toutes les classes peuvent être combinées comme suit: $1$ $K$
$(x_i, c_i')$ $c_i' = k$ $y_i'=[0,..,1,0,..]$ $k^{th}$ $y_{ik}'=1$ $y_{ik}=p(k|x_i)$ $(x_i, k)$ $-log(y_{ik})$ $y_{ik} \rightarrow 1 \Rightarrow -log(y_{ik}) \rightarrow 0$

$L(y_i', y_i) = -\sum_{k=1}^{K}y_{ik}'log(y_{ik})$ .

Lorsque , la perte de toutes les autres classes est désactivée, car , ainsi, par exemple, si true est , la perte serait être: $y_{ik}' = 1$ $k' \neq k$ $0log(y_{ik'})=0$ $y_{im}'=1$

$L(y_i', y_i)=-log(y_{im})$ .

La formule finale sur tous les points d'entraînement est la suivante:

$H_{y'}(y)=-\sum_{(x_i, y_i')}\sum_{k=1}^{K}y_{ik}'log(y_{ik})$ .

Pour la classification binaire, nous avons (étiquettes vraies) et (prédictions du modèle), donc (a) peut être réécrit comme suit: $y_{i0}' = 1 - y_{i1}'$ $y_{i0} = 1 - y_{i1}$

$\begin{align*} H_{y'}(y)&=-\sum_{(x_i, y_i')}y_{i1}'log(y_{i1})+y_{i0}'log(y_{i0})\\ &=-\sum_{(x_i, y_i')}y_{i1}'log(y_{i1})+(1-y_{i1}')log(1-y_{i1}) \end{align*}$

qui est le même que (b).

Entropie croisée (a) sur les classes (une somme)

L'entropie croisée (a) sur les classes est:

$H_{y'}(y)=-\sum_{k=1}^{K}y_{k}'log(y_{k})$ ,

Cette version ne peut pas être utilisée pour la tâche de classification. Permet de réutiliser les données de l'exemple précédent:

$(c_i', c_i)=\{(0, 0.1), (0, 0.4), (0, 0.8), (1, 0.8), (1, 0.2)\}$

Les probabilités de classe empiriques sont: , et , $y'_0 = 3/5 = 0.6$ $y'_1 = 0.4$

Les probabilités de classe estimées par le modèle sont les suivantes: et $y_0 = 3/5 = 0.6$ $y_1 = 0.4$

(a) est calculé comme : . $-y'_0logy_0 - y'_1logy_1 = - 0.6log(0.6) -0.4log(0.4) = 0.292$

Deux points de données et ont été classés, mais et ont été estimés correctement! $(0, 0.8)$ $(1, 0.2)$ $y'_0$ $y'_1$

Si tous les 5 points ont été classés correctement comme : ,
$(c_i', c_i)=\{(0, 0.1), (0, 0.4), (0, \color{blue}{0.2}), (1, 0.8), (1, \color{blue}{0.8})\}$

(a) reste le même, puisque est à nouveau estimé à . $y'_0$ $y_0=3/5$

— Esmailien
source