Dela via

Förlustfunktioner och mått

  • Artikel

CNTK innehåller ett antal vanliga fördefinierade förlustfunktioner (eller träningskriterier för att optimera för i träning) och mått (eller utvärderingskriterier för prestandaspårning). Dessutom kan anpassade förlustfunktioner/mått definieras som BrainScript-uttryck.

CrossEntropy(), CrossEntropyWithSoftmax()

Beräknar den kategoriska korsentropinförlusten (eller bara korsentropin mellan två sannolikhetsfördelningar).

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

Parametrar

  • y: etiketter (en frekvent), eller mer allmänt referensdistribution. Måste summeras till 1.
  • p (för CrossEntropy()): posterior sannolikhetsfördelning för poäng mot referensen. Måste summeras till 1.
  • z (för CrossEntropyWithSoftmax()): indata till en Softmax-åtgärd för att beräkna den bakre sannolikhetsfördelningen för att bedöma mot referensen

Returvärde

Den här åtgärden beräknar korsentropi mellan två sannolikhetsfördelningar y och p, som definieras som:

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

med i itererande över alla element i y och p. p För CrossEntropyWithSoftmax()beräknas från indataparametern z som

p = Softmax (z)

Description

Dessa funktioner beräknar korsentropy för två sannolikhetsfördelningar. Kategorisk korsentropy är det vanligaste träningskriteriet (förlustfunktion) för klassificering av en klass, där y kodar en kategorisk etikett som en one-hot-vektor. En annan användning är som en förlustfunktion för sannolikhetsfördelningsregression, där y är en målfördelning som p ska matcha.

När den används som en förlustfunktion summerar CNTK SGD-process korsentropyvärdena för alla enskilda exempel i en minibatch och beräknar förlusten per epok genom att aggregera dessa över en hel epok. Detta rapporteras sedan i det här formatet: L * S var L är den genomsnittliga förlusten per prov och S antalet prover. Till exempel -1.213 * 3600000, innebär en genomsnittlig korsentropisk förlust på -1,213, i genomsnitt över en epok på 3 600 000 prover.

CrossEntropyWithSoftmax() är en optimering för det vanligaste användningsfallet av kategorisk korsentropy, som drar nytta av den specifika formen av Softmax. I stället för en normaliserad sannolikhet accepterar den som indata argumentet till Softmax-åtgärden, som är samma som en icke-normaliserad version av loggen Softmax, även kallad "logit". Det här är det rekommenderade sättet i CNTK att beräkna det kategoriska korsentropykriteriet.

Observera att kategorisk korsentropy inte är en lämplig förlustfunktion för etiketter i flera klasser, där y innehåller mer än en position som innehåller en 1. I det här fallet bör du överväga att använda Sigmoid() i stället för Softmax, med en Logistic() förlust. Se även den här artikeln.

Alternativ definition

CrossEntropyWithSoftmax()är för närvarande en CNTK primitiv som har begränsningar. Ett mer flexibelt och rekommenderat alternativ är att definiera det manuellt som:

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

Glesa etiketter

För att beräkna korsentropin med glesa etiketter (t.ex. läsa med ( Input./Inputs#input)){..., sparse=true} måste det alternativa formuläret ovan användas.

Softmax över tensorer med rang>1

För att beräkna CrossEntropyWithSoftmax() över När det tillämpas på tensorer i rangordning>1, t.ex. där uppgiften är att fastställa en plats i ett 2D-rutnät, måste ytterligare ett alternativt formulär användas:

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

Det här formuläret gör det också möjligt att tillämpa Softmax-åtgärden endast längs en specifik axel. Om indata och etiketter till exempel har formen [10 x 20], och Softmax ska beräknas för var och en av de 20 kolumnerna oberoende av varandra, anger du axis=1.

Exempel

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

Samma sak med glesa etiketter:

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

Logistic{}, WeightedLogistic{}

Beräknar den logistiska förlustfunktionen.

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

Parametrar

  • y: mark-sanningsetikett, 0 eller 1
  • p: bakre sannolikhet att vara av klass 1

Returvärde

Beräknar den (viktade) logistiska förlusten, definierad som:

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

(där för Logistic()är vikten 1).

Description

Den här funktionen är den logistiska förlustfunktionen.

Logistic (y, Softmax (z)) är identisk med CrossEntropyWithSoftmax (y, z) för problem med två klasser, där endast en av de två (kompletterande) grundsanningsetiketterna ges till Logistic().

Se även den här artikeln om träning av klassificerare med flera klasser.

Exempel

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{}

Beräknar felfrekvensen för förutsägelse av kategoriska etiketter. För binära etiketter kan du använda hammingförlust.

ClassificationError (y, z)

Parametrar

  • y: kategoriska etiketter i en het form
  • z: vektor för förutsägelsepoäng, t.ex. loggannolikheter

Returvärde

1 om det maximala värdet z för är vid en position där y har en 1; 0 annars, summerad över en hel minibatch.

Description

Den här funktionen accepterar en vektor med posteriora sannolikheter, logits eller andra matchande poäng, där varje element representerar matchande poäng för en klass eller kategori. Funktionen avgör om klassen med högst poäng är lika med klassen som anges av etikettens indata ygenom att testa om den högst poänggivande positionen innehåller en 1.

När den används som ett utvärderingskriterium aggregerar SGD-processen alla värden över en epok och rapporterar medelvärdet, dvs. felfrekvensen.

ClassificationError() kan inte användas med glesa etiketter.

Obs! I CNTK före version 1.7 anropades ErrorPrediction()den här åtgärden . Namnet kan fortfarande användas, men är inaktuellt.

Exempel

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