A função de erro de entropia cruzada em redes neurais

115

No MNIST para iniciantes em ML, eles definem entropia cruzada como

H_{y^{'}} (y) : = - \sum_{Eu} y_{Eu}^{'} registro (y_{Eu})

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

$y_i$ é o valor de probabilidade previsto para a classe $i$ e $y_i'$ é a verdadeira probabilidade para essa classe.

Questão 1

Não é um problema que $y_i$ (no $\log(y_i)$ ) possa ser 0? Isso significa que temos um classificador muito ruim, é claro. Mas pense em um erro em nosso conjunto de dados, por exemplo, um "óbvio" 1rotulado como 3. Simplesmente falharia? O modelo que escolhemos (ativação softmax no final) basicamente nunca fornece a probabilidade 0 para a classe correta?

Questão 2

Aprendi que a entropia cruzada é definida como

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)})$

O que é correto? Você tem alguma referência de livro para qualquer versão? Como essas funções diferem em suas propriedades (como funções de erro para redes neurais)?

machine-learning tensorflow

— Martin Thoma
fonte

Veja também: stats.stackexchange.com/questions/80967/…

— Piotr Migdal

Veja também: Kullback-Leibler Divergence Explained post no blog.

— Piotr Migdal

101

Uma maneira de interpretar a entropia cruzada é vê-la como uma probabilidade de log (menos) para os dados $y_i'$ , sob um modelo $y_i$ .

Ou seja, suponha que você tenha algum modelo fixo (também conhecido como "hipótese"), que prediz para $n$ classes $\{1,2,\dots, n\}$ suas probabilidades hipotéticas de ocorrência $y_1, y_2,\dots, y_n$ . Suponha que agora você observe (na realidade) $k_1$ instâncias da classe $1$ , $k_2$ instâncias da classe $2$ , $k_n$ instâncias da classe $n$ etc. De acordo com o seu modelo, a probabilidade de isso acontecer é:

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}.$

Tomando o logaritmo e alterando o sinal:

- \log P [d uma t uma | m o d e eu] = - k_{1} registro y_{1} - k_{2} registro y_{2} - \dots - k_{n} registro y_{n} = - \sum_{Eu} k_{Eu} registro y_{Eu}

$-\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$ Se você agora divide a soma da direita pelo número de observações

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

$N = k_1+k_2+\dots+k_n$ , e denota as probabilidades empíricas como

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

$y_i'=k_i/N$ , você obterá a entropia cruzada:

- \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)$

Além disso, a probabilidade de log de um conjunto de dados dado um modelo pode ser interpretada como uma medida do "comprimento da codificação" - o número de bits que você espera gastar para codificar essas informações se o seu esquema de codificação se basear em sua hipótese.

Isto resulta da observação de que um evento independente com probabilidade $y_i$ requer, pelo menos, $-\log_2 y_i$ bits para codificar ela (assumindo que a codificação eficiente), e, consequentemente, a expressão

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

$-\sum_i y_i'\log_2 y_i,$ é literalmente o esperado comprimento da codificação, em que os comprimentos de codificação dos eventos são calculados usando a distribuição "hipotética", enquanto a expectativa é assumida sobre a real.

Finalmente, em vez de dizer "medida do comprimento esperado da codificação", gosto muito de usar o termo informal "medida de surpresa". Se você precisar de muitos bits para codificar um evento esperado de uma distribuição, a distribuição será "realmente surpreendente" para você.

Com essas intuições em mente, as respostas para suas perguntas podem ser vistas da seguinte maneira:

Pergunta 1 . Sim. É um problema sempre que o correspondente $y_i'$ for diferente de zero ao mesmo tempo. Corresponde à situação em que seu modelo acredita que alguma classe tem probabilidade zero de ocorrência e, no entanto, a classe aparece na realidade. Como resultado, a "surpresa" do seu modelo é infinitamente grande: seu modelo não foi responsável por esse evento e agora precisa de infinitos bits para codificá-lo. É por isso que você obtém o infinito como sua entropia cruzada.

Para evitar esse problema, você precisa se certificar de que seu modelo não faça suposições precipitadas de que algo é impossível enquanto isso pode acontecer. Na realidade, as pessoas tendem a usar funções sigmóides ou "softmax" como modelos de hipóteses, que são conservadoras o suficiente para deixar pelo menos alguma chance para cada opção.

Se você usar algum outro modelo de hipótese, é sua responsabilidade regularizá-lo (também conhecido como "suave") para que ele não faça a hipótese de zeros onde não deveria.
Questão 2 . Nesta fórmula, um geralmente assume $y_i'$ a ser $0$ ou $1$ , enquanto $y_i$ é hipótese probabilidade do modelo para a entrada correspondente. Se você olhar de perto, verá que é simplesmente $-\log P[data|model]$ para dados binários, equivalente à segunda equação nesta resposta.

Portanto, estritamente falando, embora ainda seja uma probabilidade logarítmica, isso não é sintaticamente equivalente a entropia cruzada. O que algumas pessoas querem dizer quando se refere a uma expressão tal como cruzada entropia é que é, na verdade, uma soma sobre transversais entropias binários de pontos individuais no conjunto de dados:
$\sum_{i} H (y_{i}^{'}, y_{i}),$ $\sum_i H(y_i', y_i),$ onde $y_i'$ e $y_i$ devem ser interpretados como as distribuições binárias correspondentes $(y_i', 1-y_i')$ e $(y_i, 1-y_i)$ .

— KT.
fonte

1

Você pode fornecer uma fonte na qual eles definem

? Aquieles a definem como uma distribuição única para o rótulo de classe atual. Qual é a diferença?

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

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

— Lenar Hoyt

1

No tutorial do MNIST TensorFlow, eles também o definem em termos de vetores quentes.

— Lenar Hoyt

@LenarHoyt Quando

,

seria equivalente a um ponto quente. Você pode pensar em "quente" como a codificação de um item com base em sua probabilidade categórica empírica (real).

N = 1

$N=1$

k_{i} / N

$k_i/N$

— THN

'evento independente requer ... para codificá-lo' - você poderia explicar este pouco, por favor?

— Alex

@ Alex Isso pode precisar de mais explicações para entender corretamente - leia os códigos de Shannon-Fano e a relação da codificação ideal com a equação de entropia de Shannon. Para simplificar, se um evento tem probabilidade 1/2, sua melhor aposta é codificá-lo usando um único bit. Se tiver probabilidade 1/4, você deve gastar 2 bits para codificá-lo, etc. Em geral, se o seu conjunto de eventos tiver probabilidades do formato 1/2 ^ k, deverá fornecer comprimentos k - desta forma, seu código será aproxime-se do comprimento ideal de Shannon.

— KT.

22

A primeira fórmula de perda de log que você está usando é para perda de log em várias classes, em que o subscrito enumera as diferentes classes em um exemplo. A fórmula pressupõe que um único em cada exemplo seja 1 e o restante seja 0. $i$ $y_i'$

Isso significa que a fórmula captura apenas erros na classe de destino. Ele descarta qualquer noção de erro que você possa considerar "falso positivo" e não se importa com a distribuição das probabilidades previstas, além da probabilidade prevista da classe verdadeira.

Outra hipótese é que $\sum_i y_i = 1$ para as previsões de cada exemplo. Uma camada softmax faz isso automaticamente - se você usar algo diferente, precisará escalar as saídas para atender a essa restrição.

Questão 1

Não é um problema que o (em ) poderia ser 0? $y_i$ $log(y_i)$

Sim, isso pode ser um problema, mas geralmente não é prático. É extremamente improvável que uma camada softmax inicializada aleatoriamente produza uma exata 0em qualquer classe. Mas é possível, então vale a pena permitir. Em primeiro lugar, não avaliam para qualquer , porque as classes negativos sempre contribuem 0 para o erro. Segundo, no código prático, você pode limitar o valor a algo como $log(y_i)$ $y_i'=0$ log( max( y_predict, 1e-15 ) ) estabilidade numérica - em muitos casos, não é necessário, mas é uma programação defensiva sensata.

Questão 2

Aprendi que cruz-entropia é definido como $H_{y'}(y) := - \sum_{i} ({y_i' \log(y_i) + (1-y_i') \log (1-y_i)})$

Essa formulação é freqüentemente usada para uma rede com uma saída prevendo duas classes (geralmente associação de classe positiva para 1 e negativa para saída de 0). Nesse caso, posso ter apenas um valor - você pode perder a soma de . $i$ $i$

Se você modificar essa rede para ter duas saídas opostas e usar softmax mais a primeira definição de perda de log, poderá ver que, na verdade, é a mesma medição de erro mas dobrando a métrica de erro para duas classes em uma única saída.

Se houver mais de uma classe para prever a associação, e as classes não forem exclusivas, ou seja, um exemplo pode ser uma ou todas as classes ao mesmo tempo, você precisará usar esta segunda formulação. Para o reconhecimento de dígitos, esse não é o caso (um dígito escrito deve ter apenas uma classe "verdadeira")

— Neil Slater
fonte

Note que há alguma ambiguidade na apresentação da segunda fórmula - que poderia, em teoria, assumir apenas uma classe e

, então, enumerar os exemplos.

i

$i$

— Neil Slater

Sinto muito, perguntei algo diferente do que eu queria saber. Não vejo problema no

, mas em

, devido ao

. Você poderia ajustar sua resposta a isso?

\log (y_{i}) = 0

$\log(y_i) = 0$

y_{i} = 0

$y_i = 0$

\log (y_{i})

$\log(y_i)$

— Martin Thoma

@NeilSlater se as classes não forem mutuamente exclusivas, o vetor de saída para cada entrada poderá conter mais de um 1, devemos usar a segunda fórmula?

— Meios

1

@ Media: Na verdade não. Você deseja observar coisas como classificação hierárquica. . .

— Neil Slater

1

@Javi: No OP questão

é a verdade chão, assim normalmente 0 ou 1. É

que é a saída softmax. No entanto

pode acabar de zero, na prática, devido ao arredondamento flutuante ponto. Isso realmente acontece.

y_{i}^{'}

$y'_i$

y_{i}

$y_i$

y_{i}

$y_i$

— Neil Slater

11

Dado , você quer otimizar o seu método de aprendizagem de máquina para obter o tão perto quanto possível . $y_{true}$ $y_{predict}$ $y_{true}$

Primeira pergunta:

A resposta acima explicou o contexto de sua primeira fórmula, a entropia cruzada definida na teoria da informação.

De uma opinião diferente da teoria da informação:

você pode examinar a si mesmo que a primeira fórmula não possui penalidade na falsa positividade (a verdade é falsa, mas seu modelo prevê que ela está correta), enquanto a segunda fórmula penaliza a falsa positividade. Portanto, a escolha da primeira fórmula ou da segunda afetará suas métricas (também conhecida como quantidade estatística que você gostaria de usar para avaliar seu modelo).

Na palavra leigo:

Se você deseja aceitar quase todas as pessoas boas para ser seu amigo, mas disposto a aceitar que pessoas más se tornem suas amigas, use a primeira fórmula como critério.

Se você deseja se punir aceitando que pessoas más sejam suas amigas, mas ao mesmo tempo sua taxa de aceitação de pessoas boas pode ser menor que a primeira condição, use a segunda fórmula.

Embora, eu acho que a maioria de nós seja crítica e gostaria de escolher o segundo (assim, muitos pacotes ML assumem o que é entropia cruzada).

Segunda questão:

Entropia cruzada por amostra por classe:

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

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

Entropia cruz para conjuntos de dados inteiros classes inteiras:

\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)})}$

Assim, quando houver apenas duas classes (K = 2), você terá a segunda fórmula.

— ArtificiallyIntelligence
fonte

5

Esses problemas são tratados pelo uso do softmax pelo tutorial.

Para 1) você está certo de que o softmax garante uma saída diferente de zero, porque exponencia sua entrada. Para ativações que não dão essa garantia (como relu), é simples adicionar um termo positivo muito pequeno a cada saída para evitar esse problema.

Quanto a 2), obviamente, eles não são os mesmos, mas a formulação softmax que eles deram cuida do problema. Se você não usasse o softmax, isso faria com que você aprendesse enormes termos de preconceito que adivinham 1 para cada classe para qualquer entrada. Mas como eles normalizam o softmax em todas as classes, a única maneira de maximizar a saída da classe correta é que ela seja grande em relação às classes incorretas.

— jamesmf
fonte

"você está certo de que o softmax garante uma saída diferente de zero" - eu sei que esse é teoricamente o caso. Na realidade, pode acontecer que (devido a problemas numéricos) isso se torne 0?

— Martin Thoma

Boa pergunta. Suponho que seja perfeitamente possível que a função de exponenciação produza 0,0 se sua entrada for muito pequena para a precisão do seu float. No entanto, eu acho que a maioria das implementações adiciona o pequeno termo positivo para garantir uma entrada diferente de zero.

— jamesmf

0

$y_i$ $\log(y_i)$

$\log(0)$ $\log(y_i + \epsilon)$

O que é correto?
(a) $H_{y'} (y) := - \sum_{i} y_{i}' \log (y_i)$ ou
(b) $H_{y'}(y) := - \sum_{i} ({y_i' \log(y_i) + (1-y_i') \log(1-y_i)})$

(a) está correto para a previsão de várias classes (na verdade, é um somatório duplo), (b) é o mesmo que (a) para a previsão de duas classes. Ambos são entropia cruzada.

Exemplo:

$x_i$ $c_i' \in \{0, 1\}$ $c_i \in [0, 1]$

$c_i'$ $c_i$

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

$y_i'$ $y_i$

$y_{ik}':=1$ $c_i'=k$ $:=0$
$y_{ik}:=p(k|x_i)$ $x_i$ $k$

$(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])\}$

Ambos (a) e (b) são calculados como:

$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$

Derivação:

$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})$

$y_{ik}' = 1$ $k' \neq k$ $0log(y_{ik'})=0$ $y_{im}'=1$

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

A fórmula final sobre todos os pontos de treinamento é:

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

$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*}$

que é o mesmo que (b).

Entropia cruzada (a) sobre classes (uma soma)

A entropia cruzada (a) sobre as classes é:

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

Esta versão não pode ser usada para a tarefa de classificação. Permite reutilizar os dados do exemplo anterior:

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

$y'_0 = 3/5 = 0.6$ $y'_1 = 0.4$

$y_0 = 3/5 = 0.6$ $y_1 = 0.4$

$-y'_0logy_0 - y'_1logy_1 = - 0.6log(0.6) -0.4log(0.4) = 0.292$

$(0, 0.8)$ $(1, 0.2)$ $y'_0$ $y'_1$

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

$y'_0$ $y_0=3/5$

— Esmailiano
fonte