Dela via

Batchnormalisering

  • Artikel
BatchNormalization(input, scale, bias, runMean, runVariance, spatial,
                   normalizationTimeConstant = 0,
                   blendTimeConstant = 0, epsilon = 0.00001, useCntkEngine = true)

Parametrar

  • input är indata för batchnormaliseringsnoden
  • scale är en ParameterTensor{} som innehåller de inlärda komponentbaserade skalningsfaktorerna (gamma term i ekvationen nedan).
  • bias är en ParameterTensor{} som innehåller den inlärda biasen (beta term). scale och bias måste ha samma dimensioner som måste vara lika med dimensionerna input i händelse av spatial = false eller antalet funktionskartor för utdatabeveckling i händelse av spatial = true.
  • runMean är det löpande medelvärdet som används under utvärderingsfasen och som även kan användas under träningen. Du måste skicka en ParameterTensor{} med samma dimensioner som scale och bias, initialt värde 0 och learningRateMultiplier=0 ange.
  • runVariance är den löpande variansen. Den representeras på samma sätt som runMean.
  • spatial är en flagga som anger om medelvärde/var ska beräknas för varje funktion i en minibatch oberoende av varandra eller, i händelse av decentraliseringslager, per funktionskarta.
  • normalizationTimeConstant (standard 0): tidskonstant för beräkning som kör medelvärdet och variansen som en filtrerad version av batchstatistiken med låg genomströmning. Obs! Standardinställningen är vanligtvis inte vad du vill ha.
  • blendTimeConstant (standard 0): gör det möjligt att jämna ut batchuppskattningar med den statistik som körs
  • epsilon är en conditioner-konstant som läggs till i variansen vid beräkning av den omvända standardavvikelsen.
  • useCntkEngine (standard: true): ange detta till false för att välja GPU-only cuDNN-implementeringen

Returvärde

Batchnormaliserade input.

Description

BatchNormalization implementerar den teknik som beskrivs i papper Batch Normalization: Accelerating Deep Network Training by Reduce Internal Covariate Shift (Sergey Ioffe, Christian Szegedy). I korthet normaliserar den lagerutdata för varje minibatch för varje utdata (funktion) oberoende av varandra och tillämpar affintransformering för att bevara representationen av lagret. Det vill: för lager input:

m = mean (input)
var = variance (input)
inputNorm = (input - mean)/sqrt (epsilon + var)
output = gamma * inputNorm + beta

där gamma och beta är träningsbara parametrar.

mean och variance beräknas utifrån träningsdata. I det enklaste fallet är de medelvärdet och variansen för den aktuella minibatchen under träningen. I slutsatsdragning används en långsiktig uppskattning i stället.

De långsiktiga uppskattningarna är en lågpassfiltrerad version av minibatchstatistiken, med tidskonstanten (i exempel) som anges av parametern normalizationTimeConstant . Ett värde 0 för innebär att det inte blir någon exponentiell utjämning och att köra medelvärde/varians kommer alltid att vara lika med värdet för den senast sedda minibatchen. Detta är ofta oönskat. I stället rekommenderar vi att du använder ett värde på några tusen här. Omslutningen BatchNormalizationLayer{} har standardvärdet 5 000.

Mer information om tidskonstanter och exponentiell utjämning: https://en.wikipedia.org/wiki/Exponential_smoothing#Time_Constant

Eftersom minibatchstatistik kan vara bullrig kan CNTK också använda en MAP-uppskattning (maximum-a-posteriori) under träningen, där den löpande långsiktiga uppskattningen tas som föregående. Vikten för föregående styrs av parametern blendTimeConstant . Detta har dock hittills inte visat sig vara användbart i våra experiment.

Observera att under slutsatsdragningen anger CNTK båda tidskonstanterna automatiskt så att endast det befintliga medelvärdet som körs används och att det inte uppdateras. Det krävs ingen uttrycklig åtgärd av användaren.

cuDNN-implementering

Som standard använder den här funktionen en CNTK implementering som fungerar med både GPU:er och processorer. Du kan välja att använda cuDNN-implementeringen, vilket är mer högpresterande. Observera dock att cuDNN-implementeringen inte stöder alla alternativ, och träning kräver en GPU (CNTK tillhandahåller dock en CPU-emulering för slutsatsdragning även om du väljer cuDNN-implementeringen).