Den första grafen ovan visar att de större batchstorlekarna faktiskt avverkar mindre avstånd per epok. För batch 32-träningsepokens avstånd varierar mellan 0,15 och 0,4, medan det för batch 256-träning ligger runt 0,02-0,04. Som vi kan se i den andra diagrammet ökar förhållandet mellan epokavstånden med tiden!
Men varför går en stor batchträning över mindre avstånd per epok? Är det för att vi har färre batcher och därmed färre uppdateringar per epok? Eller beror det på att varje uppdatering av en batch sträcker sig över mindre avstånd? Eller är svaret en kombination av båda?
För att besvara denna fråga kan vi mäta storleken på varje batchuppdatering.
Median batch update norm for batch size 32: 3.3e-3
Median batch update norm for batch size 256: 1.5e-3
Vi kan se att varje batchuppdatering är mindre när batchstorleken är större. Varför skulle detta vara fallet?
För att förstå detta beteende kan vi skapa ett dummy-scenario där vi har två gradientvektorer a och b, som var och en representerar gradienten för ett träningsexempel. Låt oss fundera på hur den genomsnittliga uppdateringsstorleken för batchstorlek=1 jämför med den för batchstorlek=2.
Om vi använder en batchstorlek på ett, kommer vi att ta ett steg i riktning mot a, sedan b, för att hamna i den punkt som representeras av a+b. (Tekniskt sett skulle gradienten för b beräknas på nytt efter tillämpning av a, men vi struntar i det för tillfället). Detta resulterar i en genomsnittlig satsuppdateringsstorlek på (|a|+|b|)/2 – summan av satsuppdateringsstorlekarna, dividerat med antalet satsuppdateringar.
Och om vi använder en satsstorlek på två, representeras satsuppdateringen i stället av vektorn (a+b)/2 – den röda pilen i figur 12. Således är den genomsnittliga storleken på batchuppdateringen |(a+b)/2| / 1 = |a+b|/2.
Nu ska vi jämföra de två genomsnittliga storlekarna på batchuppdateringen:
I den sista raden använde vi triangelojämlikheten för att visa att den genomsnittliga uppdateringsstorleken för batchstorlek 1 alltid är större än eller lika med den för batchstorlek 2.
Som ett annat sätt att uttrycka det, för att den genomsnittliga batchstorleken för batchstorlek 1 och batchstorlek 2 ska vara lika stor, måste vektorerna a och b peka i samma riktning, eftersom det är då som |a| + |b| = |a+b|. Vi kan utvidga detta argument till n vektorer – endast när alla n vektorer pekar i samma riktning är de genomsnittliga uppdateringsstorlekarna för batchstorlek=1 och batchstorlek=n lika stora. Detta är dock nästan aldrig fallet, eftersom det är osannolikt att gradientvektorerna pekar i exakt samma riktning.
Om vi återvänder till ekvationen för uppdatering av minibatcherna i figur 16, säger vi på sätt och vis att när vi skalar upp batchstorleken |B_k|, så skalar storleken på summan av gradienterna upp relativt sett mindre snabbt. Detta beror på att gradientvektorerna pekar i olika riktningar och att en fördubbling av satsstorleken (dvs. antalet gradientvektorer som ska summeras) inte fördubblar storleken på den resulterande summan av gradientvektorer. Samtidigt dividerar vi med en nämnare |B_k| som är dubbelt så stor, vilket resulterar i ett mindre uppdateringssteg totalt sett.
Detta skulle kunna förklara varför satsuppdateringarna för större satsstorlekar tenderar att vara mindre – summan av gradientvektorer blir större, men kan inte fullt ut kompensera för den större nämnaren|B_k|.
Hypotes 2: Små batchträning hittar plattare minimizers
Låt oss nu mäta skärpan hos båda minimizers och utvärdera påståendet att små batchträning hittar plattare minimizers. (Observera att denna andra hypotes kan samexistera med den första – de utesluter inte varandra). För att göra detta lånar vi två metoder från Keskar et al.
I den första plottar vi tränings- och valideringsförlusten längs en linje mellan en minimizer för små partier (partistorlek 32) och en minimizer för stora partier (partistorlek 256). Denna linje beskrivs av följande ekvation:
där x_l* är minimeringen av stora partier och x_s* är minimeringen av små partier och alfa är en koefficient mellan -1 och 2.
Som vi kan se i diagrammet är den lilla satsminimatorn (alfa=0) mycket plattare än den stora satsminimatorn (alfa=1), som varierar mycket skarpare.
Bemärk att detta är ett ganska förenklat sätt att mäta skärpa, eftersom det bara tar hänsyn till en riktning. Keskar et al. föreslår därför ett mått på skärpa som mäter hur mycket förlustfunktionen varierar i ett grannskap runt en minimizer. Först definierar vi grannskapet på följande sätt:
där epsilon är en parameter som definierar storleken på grannskapet och x är minimeringsvärdet (vikterna).
Därefter definierar vi sharpness metric som den maximala förlusten i detta grannskap runt minimizern:
där f är förlustfunktionen, där ingångarna är vikterna.
Med definitionerna ovan, låt oss beräkna skärpan hos minimizers vid olika satsstorlekar, med ett epsilonvärde på 1e-3:
Detta visar att de stora satsminimeringarna verkligen är skarpare, vilket vi såg i interpolationsdiagrammet.
Sist, låt oss prova att plotta minimizers med en filternormaliserad förlustvisualisering, som formulerats av Li et al . Denna typ av plot väljer två slumpmässiga riktningar med samma dimensioner som modellvikterna och normaliserar sedan varje konvolutionellt filter (eller neuron, när det gäller FC-skikt) så att det har samma norm som motsvarande filter i modellvikterna. Detta säkerställer att skärpan hos en minimering inte påverkas av storleken på dess vikter. Sedan ritas förlusten längs dessa två riktningar, med centrum i ritningen som den minimizer vi vill karakterisera.