Come scegliere la perdita di entropia incrociata in tensorflow?

Problemi di classificazione, come regressione logistica o regressione logistica multinomiale, ottimizzano una perdita di entropia incrociata . Normalmente, lo strato di entropia incrociata segue lo strato di softmax , che produce la distribuzione di probabilità.

In tensorflow, ci sono almeno una dozzina di diverse funzioni di perdita di entropia incrociata :

  • 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

Quali funzionano solo per la classificazione binaria e quali sono adatti per problemi multi-class? Quando dovresti usare softmax invece di softmax ? In che modo le funzioni sparse sono diverse dagli altri e perché è solo softmax ?

Discussione correlata (più matematica): jung cross-entropy .

Fatti preliminari

  • In senso funzionale, il sigmoid è un caso parziale della funzione softmax , quando il numero di classi è uguale a 2. Entrambi eseguono la stessa operazione: trasformare i logits (vedi sotto) in probabilità.

    Nella semplice classificazione binaria, non c’è una grande differenza tra i due, tuttavia, in caso di classificazione multinomiale, sigmoid consente di gestire etichette non esclusive (anche multi-label ), mentre softmax si occupa di classi esclusive (vedi sotto).

  • Un logit (detto anche punteggio) è un valore non graduato non elaborato associato a una class , prima di calcolare la probabilità. In termini di architettura di rete neurale, ciò significa che un logit è un output di un livello denso (completamente connesso).

    La denominazione di Tensorflow è un po ‘strana: tutte le funzioni sottostanti accettano logits, non probabilità , e applicano la trasformazione stessa (che è semplicemente più efficiente).

Famiglia di funzioni sigmoidali

  • 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 ( tf.contrib.losses.sigmoid_cross_entropy )

Come affermato in precedenza, la funzione di perdita sigmoid è per la classificazione binaria. Ma le funzioni di tensorflow sono più generali e permettono di fare una classificazione multi-label, quando le classi sono indipendenti. In altre parole, tf.nn.sigmoid_cross_entropy_with_logits risolve N classificazioni binarie contemporaneamente.

Le etichette devono essere codificate a una temperatura elevata o possono contenere probabilità di classi morbide.

tf.losses.sigmoid_cross_entropy consente inoltre di impostare i pesi in-batch , ovvero rendere alcuni esempi più importanti di altri. tf.nn.weighted_cross_entropy_with_logits consente di impostare i pesi delle classi (ricorda che la classificazione è binaria), cioè rendere gli errori positivi più grandi degli errori negativi. Questo è utile quando i dati di allenamento sono sbilanciati.

Softmax funziona in famiglia

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

Queste funzioni di perdita dovrebbero essere utilizzate per la classificazione multinomiale mutuamente esclusiva, ovvero scegliere una delle classi N Applicabile anche quando N = 2 .

Le etichette devono essere codificate a una temperatura elevata o possono contenere probabilità di classi soft: un particolare esempio può appartenere alla class A con probabilità del 50% e class B con probabilità del 50%. Si noti che in senso stretto non significa che appartenga a entrambe le classi, ma si possono interpretare le probabilità in questo modo.

Proprio come nella famiglia tf.losses.softmax_cross_entropy , tf.losses.softmax_cross_entropy consente di impostare i pesi in-batch , ovvero rendere alcuni esempi più importanti di altri. Per quanto ne so, a partire da tensorflow 1.3, non esiste un modo integrato per impostare i pesi delle classi .

[UPD] In tensorflow 1.5, è stata introdotta la versione v2 e la perdita originale di softmax_cross_entropy_with_logits stata deprecata. L’unica differenza tra loro è che in una versione più recente, il backpropagation avviene sia in logiti sia in etichette ( ecco una discussione sul perché questo può essere utile).

Famiglia di funzioni sparse

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

Come per la softmax ordinaria sopra, queste funzioni di perdita dovrebbero essere utilizzate per la classificazione multinomiale mutuamente esclusiva, ovvero scegliere una delle classi N La differenza è nella codifica delle etichette: le classi vengono specificate come numeri interi (indice di class), non come vettori unici. Ovviamente, questo non consente classi leggere, ma può salvare un po ‘di memoria quando ci sono migliaia o milioni di classi. Tuttavia, si noti che logits argomento logits deve ancora contenere logits per ogni class, quindi consuma almeno la [batch_size, classs] .

Come sopra, la versione di tf.losses ha un argomento di weights che consente di impostare i pesi in-batch.

Famiglia di funzioni softmax campionate

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

Queste funzioni forniscono un’altra alternativa per gestire un numero enorme di classi. Invece di calcolare e confrontare una distribuzione di probabilità esatta, calcolano una stima di perdita da un campione casuale.

Gli argomenti weights e biases specificano un layer separato completamente connesso che viene utilizzato per calcolare i logits per un campione scelto.

Come sopra, le labels non sono codificate una sola volta, ma hanno la forma [batch_size, num_true] .

Le funzioni campionate sono adatte solo per l’allenamento. In fase di test, si consiglia di utilizzare una perdita standard di softmax (sparsa o one-hot) per ottenere una distribuzione effettiva.

Un’altra perdita alternativa è tf.nn.nce_loss , che esegue una stima del contrasto del rumore (se sei interessato, vedi questa discussione molto dettagliata ). Ho incluso questa funzione nella famiglia softmax, perché NCE garantisce l’approssimazione a softmax nel limite.

tuttavia per la versione 1.5, softmax_cross_entropy_with_logits_v2 , deve essere usato softmax_cross_entropy_with_logits_v2 , mentre si usa il suo argomento con l’ argument key=... come segue>

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