Como escolher a perda de entropia cruzada em tensor de stream?

Problemas de sorting, como a regressão logística ou a regressão logística multinomial, otimizam uma perda de entropia cruzada . Normalmente, a camada de entropia cruzada segue a camada softmax , que produz distribuição de probabilidade.

Em tensorflow, há pelo menos uma dúzia de diferentes funções de perda de entropia cruzada :

  • tf.losses.softmax_cross_entropy
  • tf.losses.sparse_softmax_cross_entropy
  • tf.losses.sigmoid_cross_entropy
  • tf.contrib.losses.softmax_cross_entropy
  • tf.contrib.losses.sigmoid_cross_entropy
  • tf.nn.softmax_cross_entropy_with_logits
  • tf.nn.sigmoid_cross_entropy_with_logits

Quais funcionam apenas para sorting binária e quais são adequados para problemas de múltiplas classs? Quando você deve usar sigmoid vez de softmax ? Como as funções sparse são diferentes das outras e por que é apenas o softmax ?

Discussão relacionada (mais orientada para matemática): selva de entropia cruzada .

Fatos preliminares

  • No sentido funcional, o sigmóide é um caso parcial da function softmax , quando o número de classs é igual a 2. Ambos executam a mesma operação: transformar os logits (veja abaixo) em probabilidades.

    Na sorting binária simples, não há grande diferença entre os dois, no entanto, no caso de sorting multinomial, sigmoid permite lidar com labels não exclusivos ( multi-labels ), enquanto o softmax lida com classs exclusivas (veja abaixo).

  • Um logit (também chamado de pontuação) é um valor bruto não escalonado associado a uma class , antes de calcular a probabilidade. Em termos de arquitetura de neural network, isso significa que um logit é uma saída de uma camada densa (totalmente conectada).

    A nomeação do Tensorflow é um pouco estranha: todas as funções abaixo aceitam logits, não probabilidades , e aplicam a transformação (que é simplesmente mais eficiente).

Família de funções sigmóides

  • tf.nn.sigmoid_cross_entropy_with_logits
  • tf.nn.weighted_cross_entropy_with_logits
  • tf.losses.sigmoid_cross_entropy
  • tf.contrib.losses.sigmoid_cross_entropy (DEPRECATED)

Como afirmado anteriormente, a function perda sigmoid é para sorting binária. Mas as funções de tensorflow são mais gerais e permitem a sorting multi-label, quando as classs são independentes. Em outras palavras, tf.nn.sigmoid_cross_entropy_with_logits resolve as classificações binárias N uma só vez.

As etiquetas devem ser codificadas com uma das extremidades ou podem conter probabilidades de class flexíveis.

tf.losses.sigmoid_cross_entropy , além disso, permite definir os pesos em lote , ou seja, tornar alguns exemplos mais importantes do que outros. tf.nn.weighted_cross_entropy_with_logits permite definir pesos de classs (lembre-se, a sorting é binária), ou seja, fazer erros positivos maiores do que erros negativos. Isso é útil quando os dados de treinamento estão desequilibrados.

Família de funções Softmax

  • tf.nn.softmax_cross_entropy_with_logits ( tf.nn.softmax_cross_entropy_with_logits EM 1.5)
  • tf.nn.softmax_cross_entropy_with_logits_v2
  • tf.losses.softmax_cross_entropy
  • tf.contrib.losses.softmax_cross_entropy (DEPRECATED)

Essas funções de perda devem ser usadas para sorting multinomial exclusiva, ou seja, escolher uma das N classs. Também aplicável quando N = 2 .

Os labels devem ser codificados com um único clique ou podem conter probabilidades de classs flexíveis: um exemplo específico pode pertencer à class A com 50% de probabilidade e class B com 50% de probabilidade. Observe que, estritamente falando, isso não significa que ele pertence a ambas as classs, mas é possível interpretar as probabilidades dessa maneira.

Assim como na família sigmoid , tf.losses.softmax_cross_entropy permite definir os pesos em lote , ou seja, tornar alguns exemplos mais importantes que outros. Tanto quanto eu sei, a partir do tensorflow 1.3, não há uma maneira interna de definir pesos de classs .

[UPD] No tensorflow 1.5, a versão v2 foi introduzida e a perda original do softmax_cross_entropy_with_logits foi descontinuada. A única diferença entre eles é que, em uma versão mais recente, a retropropagação acontece nos logits e nos labels ( aqui está uma discussão sobre o motivo pelo qual isso pode ser útil).

Família de funções esparsas

  • tf.nn.sparse_softmax_cross_entropy_with_logits
  • tf.losses.sparse_softmax_cross_entropy
  • tf.contrib.losses.sparse_softmax_cross_entropy ( tf.contrib.losses.sparse_softmax_cross_entropy )

Como o softmax comum acima, essas funções de perda devem ser usadas para sorting multinomial exclusiva, ou seja, escolher uma das N classs. A diferença está na codificação de labels: as classs são especificadas como inteiros (índice de class), e não como vetores com um único clique. Obviamente, isso não permite classs soft, mas pode economizar memory quando existem milhares ou milhões de classs. No entanto, observe que o argumento logits ainda deve conter logits por cada class, portanto, consome pelo menos a [batch_size, classs] .

Como acima, a versão tf.losses possui um argumento de weights que permite definir os pesos em lote.

Amostra da família de funções softmax

  • tf.nn.sampled_softmax_loss
  • tf.contrib.nn.rank_sampled_softmax_loss
  • tf.nn.nce_loss

Essas funções fornecem outra alternativa para lidar com um grande número de classs. Em vez de computar e comparar uma distribuição de probabilidade exata, eles calculam uma estimativa de perda de uma amostra aleatória.

Os weights e biases argumentos especificam uma camada separada totalmente conectada que é usada para calcular os logits de uma amostra escolhida.

Como acima, os labels não são codificados com um [batch_size, num_true] , mas têm a forma [batch_size, num_true] .

As funções amostradas são adequadas apenas para treinamento. No tempo de teste, recomenda-se usar uma perda padrão de softmax (esparsa ou quente) para obter uma distribuição real.

Outra perda alternativa é tf.nn.nce_loss , que realiza uma estimativa de contraste de ruído (se você estiver interessado, veja esta discussão muito detalhada ). Eu incluí essa function na família softmax, porque o NCE garante a aproximação do softmax no limite.

no entanto, para a versão 1.5, softmax_cross_entropy_with_logits_v2 deve ser usado em seu lugar, enquanto usa seu argumento com o argument key=... like following>

 softmax_cross_entropy_with_logits_v2(_sentinel=None, labels=y,\ logits = my_prediction, dim=-1, name=None) 
    Intereting Posts