Funzioni di perdita e metriche

  • Articolo

CNTK contiene una serie di funzioni di perdita predefinite comuni (o criteri di training, per ottimizzare per il training) e metriche (o criteri di valutazione, per il rilevamento delle prestazioni). Inoltre, le funzioni/metriche di perdita personalizzate possono essere definite come espressioni BrainScript.

CrossEntropy(), CrossEntropyWithSoftmax()

Calcola la perdita di entropia incrociata categorica (o solo l'entropia incrociata tra due distribuzioni di probabilità).

CrossEntropy (y, p)
CrossEntropyWithSoftmax (y, z)

Parametri

  • y: etichette (one-hot) o, più in generale, distribuzione dei riferimenti. Deve sommare fino a 1.
  • p (per CrossEntropy()): distribuzione della probabilità posterior per assegnare un punteggio rispetto al riferimento. Deve sommare fino a 1.
  • z (per CrossEntropyWithSoftmax()): input per un'operazione Softmax per calcolare la distribuzione di probabilità posterior per assegnare un punteggio al riferimento

Valore restituito

Questa operazione calcola l'entropia incrociata tra due distribuzioni y di probabilità e p, definite come:

ce = E_y{-log p} = -sum_i y_i log p_i

con i iterazione su tutti gli elementi di y e p. Per CrossEntropyWithSoftmax(), p viene calcolato dal parametro z di input come

p = Softmax (z)

Descrizione

Queste funzioni calcolano l'entropia incrociata di due distribuzioni di probabilità. L'entropia incrociata categorica è il criterio di training più comune (funzione di perdita) per la classificazione a classe singola, in cui y codifica un'etichetta categorica come vettore one-hot. Un altro uso è una funzione di perdita per la regressione della distribuzione di probabilità, dove y è una distribuzione di destinazione corrispondente p .

Se usato come funzione di perdita, CNTK processo SGD somma i valori di entropia incrociata di tutti i singoli campioni in un minibatch e calcola la perdita per periodo aggregandole in un intero periodo. Questo viene quindi riportato in questo formato: L * S dove L è la perdita media per campione e S il numero di campioni. Ad esempio, -1.213 * 3600000, indica una perdita media di entropia incrociata pari a -1,213, calcolata in media in un periodo di 3.600.000 campioni.

CrossEntropyWithSoftmax() è un'ottimizzazione per il caso d'uso più comune di entropia trasversale categorica, che sfrutta la forma specifica di Softmax. Anziché una probabilità normalizzata, accetta come input l'argomento per l'operazione Softmax, che corrisponde a una versione non normalizzata del log Softmax, nota anche come "logit". Questo è il modo consigliato per CNTK calcolare il criterio di entropia incrociata categorica.

Si noti che l'entropia incrociata categorica non è una funzione di perdita adatta per le etichette multiclasse, dove y contiene più di una posizione contenente un valore 1. Per questo caso, prendere in considerazione l'uso Sigmoid() invece di Softmax, con una Logistic() perdita. Vedere anche questo articolo.

Definizione alternativa

CrossEntropyWithSoftmax()è attualmente una primitiva CNTK che presenta limitazioni. Un'alternativa più flessibile e consigliata consiste nel definirlo manualmente come segue:

CrossEntropyWithSoftmax (y, z) = ReduceLogSum (z) - TransposeTimes (y, z)

Etichette di tipo sparse

Per calcolare l'entropia incrociata con etichette di tipo sparse (ad esempio, leggere usando Input(./Inputs#input){..., sparse=true}), è necessario usare il modulo alternativo precedente.

Softmax su tensori con rango>1

Per calcolare CrossEntropyWithSoftmax() su Quando applicato ai tensori di rango>1, ad esempio dove l'attività consiste nel determinare una posizione in una griglia 2D, è necessario usare un altro modulo alternativo:

CrossEntropyWithSoftmax (y, z, axis=None) = ReduceLogSum (z, axis=axis) - ReduceSum (y .* z, axis=axis)

Questo modulo consente inoltre di applicare l'operazione Softmax solo su un asse specifico. Ad esempio, se gli input e le etichette hanno la forma [10 x 20]e Softmax devono essere calcolati su ognuna delle 20 colonne in modo indipendente, specificare axis=1.

Esempio

labels = Input {9000}
...
z = W * h + b
ce = CrossEntropyWithSoftmax (labels, z)
criterionNodes = (ce)

Lo stesso con le etichette di tipo sparse:

labels = Input {9000, sparse=true}
...
z = W * h + b
ce = ReduceLogSum (z) - TransposeTimes (labels, z)
criterionNodes = (ce)

Logistica{}, WeightedLogistic{}

Calcola la funzione di perdita logistica.

Logistic (y, p)
WeightedLogistic (y, p, instanceWeight)

Parametri

  • y: etichetta ground-truth, 0 o 1
  • p: probabilità posterior di essere di classe 1

Valore restituito

Calcola la perdita logistica (ponderata), definita come:

ll = -sum_i { y_i * log(p_i) + (1-y_i)*log(1-p_i))} * weight

(dove per Logistic(), il peso è 1).

Descrizione

Questa funzione è la funzione di perdita logistica.

Logistic (y, Softmax (z)) è identico a per i problemi a CrossEntropyWithSoftmax (y, z) due classi, in cui solo una delle due etichette di verità di base (complementari) viene assegnata a Logistic().

Vedere anche questo articolo sul training di classificatori multiclasse.

Esempio

multiLabels = Input {1000}                     # 0 or 1 for each value
...
p = DenseLayer {1000, activation=Sigmoid} (h)  # element-wise predictor for 1000 values
ll = Logistic (multiLabels, p)
trainingCriterion = (ll)

ClassificationError{}

Calcola la frequenza di errore per la stima delle etichette categoriche. Per le etichette binarie è possibile usare la perdita dimming.

ClassificationError (y, z)

Parametri

  • y: etichette categoriche in formato one-hot
  • z: vettore di punteggi di stima, ad esempio probabilità di log

Valore restituito

1 se il valore massimo di z è in una posizione in cui y ha un valore 1; 0 in caso contrario; sommato su un intero minibatch.

Descrizione

Questa funzione accetta un vettore di probabilità posterior, logits o altri punteggi corrispondenti, in cui ogni elemento rappresenta il punteggio corrispondente di una classe o di una categoria. La funzione determina se la classe con punteggio più alto è uguale alla classe indicata dall'input ydell'etichetta , verificando se la posizione di punteggio più alto contiene un valore 1.

Se usato come criterio di valutazione, il processo SGD aggrega tutti i valori in un periodo e segnala la media, ovvero la frequenza di errore.

ClassificationError() non può essere utilizzato con etichette di tipo sparse.

Nota: in CNTK precedente alla versione 1.7, questa operazione è stata chiamata ErrorPrediction(). Il nome può ancora essere usato, ma è deprecato.

Esempio

labels = Input {9000}
...
z = W * h + b
errs = ClassificationError (labels, z)
evaluationNodes = (errs)