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

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

$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

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

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 é:

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

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 y ' 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 $-\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),$$ 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)$ .

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 y ' i 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 l o g ( y i ) ) 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 y ' i = 0 , 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$$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")

Dado , você quer otimizar o seu método de aprendizagem de máquina para obter o y p r e d i c t tão perto quanto possível y t r u e .$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:

Entropia cruz para conjuntos de dados inteiros classes inteiras:

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

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.

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