Dela via

Tolka epoch_size, minibatch_size_in_samples och MinibatchSource.next_minibatch i CNTK

  • Artikel

I den här artikeln förtydligar vi tolkningen och användningen av följande parametrar och funktioner i Python:

epoch_size

Antalet etikettexempel (tensorer längs en dynamisk axel) i varje epok. i epoch_size CNTK är antalet etikettexempel varefter specifika ytterligare åtgärder vidtas, inklusive

  • spara en kontrollpunktsmodell (träningen kan startas om härifrån)
  • korsvalidering
  • kontroll av inlärningsfrekvens
  • minibatch-scaling

Observera att definitionen av antalet etikettexempel liknar antalet exempel som används för minibatch_size_in_samples. Definitionen av epoch_size skiljer sig från definitionen av minibatch_size_in_samples i den meningen att är epoch_sizeetikettexempel , inte indataexempel.

För sekventiella data är därför ett exempel ett enskilt objekt i en sekvens. Därför refererar CNTK epoch_sizeinte till ett antal sekvenser, utan antalet sekvensobjekt över de sekvensetiketter som utgör minibatchen.

Lika viktigt epoch_size är etikettexempel , inte indataexempel, och antalet etiketter per sekvens är inte nödvändigtvis antalet indataexempel. Det är till exempel möjligt att ha en etikett per sekvens och att varje sekvens har många prover (i vilket fall epoch_size fungerar som antal sekvenser), och det är möjligt att ha en etikett per prov i en sekvens, i vilket fall epoch_size fungerar exakt som minibatch_size_in_samples i att varje prov (inte sekvens) räknas.

För mindre datamängdsstorlekar epoch_size anges ofta lika med datauppsättningens storlek. I Python kan du ange cntk.io.INFINITELY_REPEAT för det. Endast i Python kan du ställa in den på cntk.io.FULL_DATA_SWEEP, där bearbetningen stoppas efter en pass av hela datastorleken.

För stora datamängder kanske du vill vägleda ditt val genom epoch_size kontrollpunkter. Om du till exempel vill förlora högst 30 minuters beräkning vid strömavbrott eller nätverksfel vill du att en kontrollpunkt skapas ungefär var 30:e minut (från vilken träningen kan återupptas). Välj epoch_size att vara det antal exempel som tar cirka 30 minuter att beräkna.

minibatch_size_in_samples

Obs! För BrainScript-användare är minibatchSizeparametern för minibatchstorlek . För Python användare är minibatch_size_in_samplesden .

CNTK har en mycket specifik definition av parameternminibatch_size_in_samples: Den anger antalet exempel mellan modelluppdateringar. Ett exempel här definieras som en vektor eller tensor som flödar genom systemet. I en bildigenkänningsuppgift är till exempel en bild ett exempel.

Minibatchstorleken för varje epok anges i prover (tensorer längs en dynamisk axel). Standardvärdet är 256. Du kan använda olika värden för olika epoker. (i Python) innebär t.ex 128*2 + 1024 . att använda en minibatchstorlek på 128 för de två första epokerna och sedan 1024 för resten. Observera att "minibatch size" i CNTK innebär antalet prover som bearbetas mellan modelluppdateringar. Den här definitionen gäller även vid parallellisering mellan arbetare (t.ex. för K arbetare är minibatch_size_in_samples/Kantalet prover som varje arbetare bearbetar ). När det gäller indata minibatch_size_in_samples med variabel längd refererar till antalet objekt i dessa sekvenser, inte antalet sekvenser. SGD kommer att försöka passa upp till så många sekvenser som möjligt i minibatch som inte överstiger minibatch_size_in_samples det totala antalet prover. Om flera indata anges läggs tensorer till i den aktuella minibatchen tills någon av indata överskrider minibatch_size_in_samples.

För sekventiella data är ett exempel ett enskilt objekt i en sekvens. Därför refererar CNTK minibatch_size_in_samplesinte till antalet sekvenser i minibatchen, utan det aggregerade antalet sekvensobjekt/token i de sekvenser som utgör minibatchen. CNTK har inbyggt stöd för sekvenser med variabel längd, d.v.s. det kan hantera sekvenser med mycket varierande längd inom samma minibatch, utan behov av lösningar som bucketing. Tillsammans med CNTK begreppet att ange inlärningsfrekvensen per prov (i stället för ett minibatch-genomsnitt) bidrar varje objekt i sekvenser med valfri längd på samma sätt till toningen, vilket leder till konsekvent konvergens. (Många andra verktyg definierar minibatchstorleken för sekventiella data som antalet sekvenser i minibatchen. Detta är problematiskt, särskilt om toningar också definieras som minibatch-medelvärden i stället för CNTK minibatchsummor, eftersom bidraget till toningen från varje token eller steg i en sekvens skulle vara omvänt proportionellt mot sekvenslängden. CNTK metod undviker detta.)

När flera indata används är det möjligt att inte alla indata har samma sekvenslängd. I sekvensklassificering är till exempel etiketten för varje sekvens en enda token. I det här fallet styr indata med det största antalet exempel minibatchstorleken. (Du kan ändra det här beteendet genom att defines_mb_size=True ange för vissa indata. Då räknas minibatchstorleken baserat på sekvenserna från just den här indatan. När flera indata har angetts kan endast en enda ha defines_mb_size angetts till True.)

Trots vår tydliga definition av minibatch_size_in_samples att vara antalet exempel mellan modelluppdateringar finns det två tillfällen då vi måste lätta på definitionen:

  • sekventiella data: Sekvenser med variabel längd summeras vanligtvis inte till exakt den begärda minibatchstorleken. I det här fallet packas så många sekvenser som möjligt i en minibatch utan att överskrida den begärda minibatchstorleken (med ett undantag: Om nästa sekvens i den randomiserade korpusen överskrider längden på minibatchstorleken kommer minibatchstorleken att bestå av den här sekvensen).
  • dataparallellitet: Här är minibatchstorleken ungefärlig, eftersom vår segmentbaserade randomiseringsalgoritm inte kan garantera att varje arbetare tar emot exakt samma antal prover.

Alla ovanstående överväganden gäller även för epoch_size, men epoch_size har vissa skillnader, se ovan.

MinibatchSource.next_minibatch

Metoden MinibatchSource.next_minibatch() läser en minibatch som innehåller data för alla indataströmmar. När det anropas under träningen MinibatchSource.next_minibatch(minibatch_size_in_samples, input_map) väljer du en slumpmässig delmängd av k prover från träningsdatauppsättningen, där k=minibatch_size_in_samples.

Implementeringen säkerställer att när anropas tider (där N = number_of_training_samples/minibatch_size_in_samples), täcks hela träningsdatauppsättningen i slutet av anropen av Nnext_minibatch.Nnext_minibatch Det innebär också att hela datauppsättningen täcks två gånger när next_minibatch den anropas 2*N gånger.

Ytterligare information:

  • Varje cykel genom data kommer att ha olika slumpmässig ordning.
  • Om du dubblar din minibatchstorlek kommer en minibatch nu att innehålla exakt de prover som tidigare skulle ha innehållit motsvarande två på varandra följande minibatcher (detta kan vara ungefärligt om du har sekvenser med variabel längd). Två körningar som bara skiljer sig åt i minibatchstorlek bearbetar data i samma ordning.
  • Om du avbryter och startar om från kontrollpunkten får du samma slumpmässiga ordning som om du inte hade avbrutit träningen. Detta implementeras genom att grunda inläsnings-/randomiseringsprocessen på en nominell tidsaxel med den här enkla algoritmen:
    • Träningen fortsätter på en nominell oändlig tidsaxel. Om du hämtar en minibatch med storleken 256 fortsätter den nominella tiden med 256.
    • Tränings corpus replikeras ett oändligt antal gånger på den här tidsaxeln. Om du har M exempel sträcker sig den första repliken över nominell tid 0..M-1, den andra M..2M-1osv.
    • Varje replik blandas slumpmässigt inom, men inte över, replikgränserna. När du har bearbetat exakt M prover har du sett varje prov exakt en gång.
    • Anrop next_minibatch(K) ger dig nästa K exempel på den här omgjorda oändliga tidslinjen. Det är samma sak som att ringa efter next_minibatch(1)K tider.
    • Allt detta görs lazily.
    • Att starta om från kontrollpunkten är lika enkelt som att återställa den nominella tiden till den nominella tid då kontrollpunkten skapades.