BrainScript SGD-block

SGD-konfigurationsblocket styr beteendet för SGD-algoritmen (Stochastic Gradient Descent) i CNTK. Om du är bekant med andra verktyg måste du ta en titt på

• Hur definieras minibatchstorleken i CNTK
• Hur definieras epokstorleken i CNTK
• Hur konverterar jag parametrar för inlärningstakt och momentum från andra verktyg?

SGD-konfigurationsblocket har följande struktur och standardvärden:

SGD = {
    # Training process control
    modelPath = ...
    trainCriterionNodeName = ...
    evalCriterionNodeName = ...

    maxEpochs = ...
    epochSize = 0
    minibatchSize = 256

    truncated = false

    dropoutRate = 0
    maxTempMemSizeInSamplesForCNN = 0
    keepCheckPointFiles = false

    disableWkInBatchNormal = false

    # Learning rate and momentum control
    learningRatesPerSample = ...
    learningRatesPerMB = ...
    minLearningRatePerSample = ...

    momentumAsTimeConstant = ...
    momentumPerMB = ...

    useNAG = false

    autoAdjust = {
        autoAdjustLR = "none"  # | "searchBeforeEpoch" | "adjustAfterEpoch"
        autoAdjustMinibatch = false

        # for autoAdjustLR = "adjustAfterEpoch":
        reduceLearnRateIfImproveLessThan = 0
        learnRateDecreaseFactor = 0.618
        increaseLearnRateIfImproveMoreThan = infinity
        learnRateIncreaseFactor = 1.382
        loadBestModel = true
        learnRateAdjustInterval = 1
        useCVSetControlLRIfCVExists = true
        useEvalCriterionControlLR = false

        # for autoAdjustLR = "searchBeforeEpoch":
        numMiniBatch4LRSearch = 500
        numPrevLearnRates = 5
        numBestSearchEpoch = 1

        # for autoAdjustMinibatch = true:
        numMiniBatch4LRSearch = 500
        minibatchSizeTuningFrequency = 1
        minibatchSizeTuningMax = 1048576
        minibatchSearchCriterionErrorMargin = 1
    }

    parallelTrain = {
        parallelizationMethod =  "none"  # | "dataParallelSGD" | "blockMomentumSGD" | "modelAveragingSGD"
        parallelizationStartEpoch = 1
        distributedMBReading = false
        syncPerfStats = 0
        # for parallelizationMethod = "dataParallelSGD"
        dataParallelSGD =
        {
            gradientBits = (8*sizeof(precision))  # | 1 | 2
            useBufferedAsyncGradientAggregation= false
        }
        # for parallelizationMethod = "blockMomentumSGD"
        blockMomentumSGD = {
            blockSize = (120000 * #workers)
            blockMomentumAsTimeConstant = (-blockSize / log(1 - 1/#workers))
            resetSGDMomentum = true;
            useNesterovMomentum = true;
            blockLearningRate = 1.0
        }
        # for parallelizationMethod = "modelAveragingSGD"
        modelAveragingSGD = {
            blockSize = (40000 * #workers)
        }
    }

    # Gradient control
    gradientClippingWithTruncation = true
    clippingThresholdPerSample = (infinity)
    L2RegWeight = 0
    L1RegWeight = 0
    gaussianNoiseInjectStd = 0
    gradUpdateType = ""  # "" | "adagrad" | "rmsProp" | "fsAdaGrad"
    # for gradUpdateType = "adaGrad" or "rmsProp":
    normWithAveMultiplier = true
    # for gradUpdateType = "rmsProp":
    rms_wgt_inc = 1.2
    rms_wgt_dec = 0.75
    rms_wgt_max = 10.0
    rms_wgt_min = 0.1
    rms_gamma = 0.99

    # Information display
    traceLevel = 0
    firstMBsToShowResult = 10
    numMBsToShowResult = 10
    numMBsToCUDAProfile = 0

    # Precompute
    useAllDataForPreComputedNode = true

    # Gradient check
    gradientCheck = false
    sigFigs = 6
}

Parametrar

Träningsprocesskontroll

• trainCriterionNodeName: namnet på träningsvillkorsnoden. Om det inte anges används standardnoden för träningsvillkor i nätverket.

• evalCriterionNodeName: namnet på utvärderingskriteriumnoden. Om det inte anges används standardutvärderingskriteriumnoden i nätverket.

• epochSize: Klicka här om du vill veta mer om epochSize

• keepCheckPointFiles: om du vill behålla check point-filen när en ny epok startar. Giltiga värden är true och false (standard).

• disableWkInBatchNormal: om du vill aktivera termen för viktförfall för batchnormalisering medan SGD uppdateras. Giltiga värden är true och false (standard).

• maxEpochs: maximalt antal epoker som ska köras.

• minibatchSize: Klicka här om du vill veta mer om minibatchSize

• dropoutRate: avhopp under träningsproceduren. Standardvärdet är 0.0. Kan använda syntax som 0,5*10:0.2, vilket innebär att du använder avhoppsfrekvensen 0,5 för 10 epoker och sedan 0,2 för resten.

• maxTempMemSizeInSamplesForCNN: maximalt tillfälligt minne som används (i antal exempel) när du paketerar och packar upp indatafunktioner. Standardvärdet är 0, vilket innebär att du använder valfritt värde efter behov. Användbart för att styra fotutskriften för minnet. när den körs under GPU.

• saveBestModelPerCriterion: alternativ för att spara den bästa modellen för varje kriterium mätt på korsvalideringsdata. När träningen avslutas får modellerna namnet <modelName>_<criterionName>. Giltiga värden är true och false (standard).

Learning hastighets- och momentumkontroll

Observera CNTK sätt att ange inlärningsfrekvens och momentum skiljer sig från andra verktyg. En detaljerad beskrivning finns här.

• learningRatesPerSample: inlärningsfrekvensen per epok som varje exempels gradient uppdaterar modellen med. Du kan använda olika värden för olika epoker, t.ex. 0,025*10:0.00625 innebär att du använder inlärningshastigheten 0,025 för de första 10 epokerna och sedan 0,00625 för resten. Det här är det bästa sättet att ange i CNTK, eftersom det anger de inlärningsfrekvenser som är oberoende av minibatchstorleken, vilket är viktigt när automatisk minibatchstorlek används. Andra verktyg anger ofta inlärningshastigheter på ett minibatch-genomsnittsmode. Om du vill konvertera från den notationen använder du inlärningstakt per exempel = inlärningstakt per MB/ minibatchSize (se här för mer information).

• learningRatesPerMB: alternativt sätt att ange inlärningsfrekvenser som ska tillämpas på medelvärdet över proverna i minibatchen. Det här är det vanligaste sättet att ange inlärningsfrekvenser i andra verktyg, men det är problematiskt i CNTK är där dataparallell träning, som ändrar minibatchstorleken. Internt konverteras detta till learningRatesPerSample genom att värdena divideras med den angivna "minibatchSize". Ömsesidigt uteslutande med learningRatesPerSample.

• minLearningRatePerSample: lägsta inlärningstakt per prov. När inlärningsfrekvensen per prov är mindre än det här värdet avslutas träningsprocessen. Detta används ofta för att styra tidigt stopp när automatisk inlärningshastighetsjustering är aktiverad. Standardvärdet är 1e–9.

• momentumAsTimeConstant: på samma sätt learningratesPerSamplesom , anger CNTK momentum på ett agnostiskt sätt i minibatchstorlek som tidskonstanten (i urval) för ett IIR-filter med enhetsvinst i första ordningen. Värdet anger antalet exempel varefter en toning har en effekt på 1/e=37 %. Andra verktyg anger ofta momentum som en vikt per minibatch (t.ex. 0,9). Om du vill konvertera från det använder du momentumAsTimeConstant = -minibatchSize / ln (momentumPerMB). Du kan använda syntax som 20000*10:2500, vilket innebär att du använder momentumtidskonstanten 20000 för 10 epoker och sedan 2 500 för resten.

• momentumPerMB: Det här alternativa sättet att ange momentum efterliknar beteendet hos vanliga verktyg. Om du t.ex. anger 0,9 innebär det att den tidigare toningen behålls med en vikt på 0,9. Observera dock att till skillnad från vissa andra verktyg använder CNTK fortfarande ett enhetsvinstfilter, d.v.s. den nya toningen multipliceras med (1-momentumPerMB). Internt konverteras detta till momentumAsTimeConstant = -minibatchSize / ln (momentumPerMB).

• autoAdjust: innehåller den information som rör den automatiska inlärningshastighetskontrollen. Standardvärdet är tomt ("") vilket innebär att det inte finns någon kontroll för automatisk inlärningshastighet. I blocket kan det finnas följande värden:

  • autoAdjustLR: algoritmen för automatisk inlärningstaktsjustering som ska användas. Giltiga värden är None (standard, justera inte inlärningsfrekvensen automatiskt) AdjustAfterEpoch (kontrollera träningskriteriet efter varje epok med hjälp av utvecklingsuppsättningen för träningsuppsättningen och bestäm om inlärningshastigheten ska justeras) och SearchBeforeEpoch (sök i inlärningsfrekvensen baserat på en liten del av träningsuppsättningen innan varje epok startar).

  • När det AdjustAfterEpoch används i läget:

    • reduceLearnRateIfImproveLessThan: minska inlärningstakten om förbättringen är mindre än det här värdet. Standardvärdet är 0.
    • learnRateDecreaseFactor: inlärningshastighetens minskningsfaktor. Standardvärdet är 0.618.
    • increaseLearnRateIfImproveMoreThan: öka inlärningstakten om förbättringen är större än det här värdet. Standardvärdet är 1#INF (oändlighet) vilket innebär att aldrig öka.
    • learnRateIncreaseFactor: inlärningshastighetsökningsfaktorn. Standardvärdet är 1.382.
    • loadBestModel: om den bästa modellen ska läsas in om den aktuella modellen minskar prestandan. Giltiga värden är true (standard) och false.
    • learnRateAdjustInterval: fastställa frekvensen för att tillämpa inlärningstaktens justeringskontroll. Standardvärdet är 1 epok. Om det här värdet anges till ett värde som är större än 1 baseras inlärningshastighetsjusteringen på det genomsnittliga kriteriet som beräknats från de senaste learnRateAdjustInterval epokerna.
    • useEvalCriterionControlLR: använd utvärderingskriteriet i stället för träningskriteriet för att kontrollera inlärningstakten. Som standard är det falskt.

  • När den SearchBeforeEpoch används i läget.

    • numMiniBatch4LRSearch: antalet minibatcher som används för att söka i inlärningstakten. Standardvärdet är 500. Det är vanligtvis inställt på 10-20% av de totala minibatches i en epok.
    • numPrevLearnRate: antal tidigare inlärningsfrekvenser som används som tips för sökintervallet. Standardvärdet är 5.
    • numBestSearchEpoch: antal epoker där vi använder den bästa inlärningsfrekvensen i stället för den tillräckliga inlärningstakten . Standardvärdet är 1.

  • När det används i läget "AdaptiveMinibatchSizing".

    • numMiniBatch4LRSearch: antalet minibatcher som används för att söka i minibatchstorleken i anpassningsbar minibatchstorleksläge. Standardvärdet är 500. Det är vanligtvis inställt på 10–20 % av de totala minibatchesna i en epok som delas med sökningen efter inlärningshastighet i SearchBeforeEpoch läge.
    • autoAdjustMinibatch: aktivera eller inaktivera om minibatchstorleken justeras anpassningsbart. Standardvärdet är false. Anpassningsbar minibatch-storleksändring börjar på epoker som börjar när användarens minibatchstorlek uttryckligen har angetts är klar. Om användaren till exempel har angett minibatchSize=256:1024 används 256 och 1024 i de första 2 epokerna och anpassningsbar minibatchstorlek används efteråt.
    • minibatchSizeTuningFrequency: Antalet epoker som regelbundet ska hoppa över innan minibatchstorleken justeras dynamiskt. Standardvärdet är 1.
    • minibatchSizeTuningMax: Den största tillåtna storleken för en anpassningsbart justerad minibatchstorlek. Standardvärdet är 1048576.

Toningskontroll

• gradientClippingWithTruncation: om du vill använda det trunkeringsbaserade toningsklippet för att styra gradient explosion. Giltiga värden är true (standard) och false. Om det är falskt används det normbaserade urklippet i stället, vilket är dyrare.

• clippingThresholdPerSample: tröskelvärdet för urklipp för varje exempel. Standardvärdet är 1#INF vilket innebär oändlighet (t.ex. urklipp är inaktiverat).

• L2RegWeight (standard 0): L2-regulariseringsvikten per exempel. Frobenius-normen för den lärbara parametern läggs till i målet med den här vikten. Detta anges per prov, vilket innebär att Frobenius-normen multipliceras med antalet prover i minibatchen.

• L1RegWeight (standard 0): L1-regulariseringsvikten per exempel.

• gradUpdateType: typ av toningsuppdatering. Giltiga värden är None (standard, ingen särskild behandling av toningen), AdaGrad, och RmsProp.

  • När gradUpdateType är lika med AdaGrad eller RmsPropkan du styra beteendet för toningsuppdateringen med hjälp av följande parametrar:
    • normWithAveMultiplier: normalisera toningen med de genomsnittliga multiplikatorer som tillämpas på toningarna av AdaGrad/RmsProp-algoritmen. Standard är true (standard).
  • När gradUpdateType är lika med RmsPropkan du styra beteendet för toningsuppdateringen med hjälp av följande parametrar:
    • rms_wgt_inc: flerplikativ ökning av inlärningshastighetsskalan. Standardvärdet är 1.2.
    • rms_wgt_dec: multiplicativ minskning av inlärningshastighetsskalan. Standardvärdet är 0.75.
    • rms_wgt_max: högsta tillåtna inlärningshastighetsskala. Ett värde närmare 1 gör inlärningshastighetsjusteringen stabilare men långsammare. Standardvärdet är 10.
    • rms_wgt_min: Minsta tillåtna inlärningshastighetsskala. Ett värde närmare 1 gör inlärningshastighetsjusteringen stabilare men långsammare. Standardvärdet är 0.1.
    • rms_gamma: utjämningsfaktor som används för att beräkna variansens glidande medelvärde. Ju mindre värde, desto snabbare glömmer den tidigare informationen. Standardvärdet är 0.99.

• gaussianNoiseInjectStd: Standardavvikelsen för det gaussiska brus som läggs till när metoden används AdaGrad . Standardvärdet är 0.

Informationsvisning

• traceLevel: spårningsnivå för att bestämma vilken information som ska skrivas ut i stderr. Giltiga värden är 0 (standard) och 1.

• numMBsToShowResult: visa träningsstatistik efter hur många minibatcher. Standardvärdet är 10.

TensorBoard

• tensorBoardNumMBsToLogResult: antal minibatcher mellan loggningsresultaten till TensorBoard.

Toningskontroll

• gradientCheck: avgör om toningskontrollen ska användas. Standardvärdet är false. När du använder gradient checker måste du använda en minibatchstorlek som är större än sekvenslängden för RNN på grund av den trunkerade algoritmen för backpropagation genom tid (BPTT) som används för att träna RNN och en mindre inlärningsfrekvens för att förhindra numeriska problem som orsakas av skillnader. Dessutom ska precisionen vara inställd på dubbelt.

Description

Beteendet för SGD-algoritmen (Stochastic Gradient Descent Learner) styrs av SGD-blocket för alternativen. När ett alternativ utelämnas antas standardvärdet.

Parametrar som inte uttryckligen anges lämnas till standardvärdena.

Ange datastorlekar

• Vad är minibatchstorleken i CNTK?
• Vad är epokstorleken i CNTK?

Konvertera Learning- och momentumparametrar från andra verktyg

CNTK modelluppdateringsformler skiljer sig något från vissa andra verktyg och litteratur, eftersom parametrarna i CNTK anges på ett sätt som är agnostiskt för minibatchstorleken. Detta är viktigt i samband med dataparallell träning, där CNTK själv kan ändra minibatchstorleken. Genom att ange inlärningshastighet och momentum på ett oberoende sätt undviker du komplexiteten i att justera dessa värden vid ändringar av minibatchstorleken.

Dessa är CNTK modelluppdateringsformler för SGD med momentum:

G(t) = (1-mu) sum { g(t-minibatchSize+1) ... g(t) } + mu * G(t-minibatchSize)
mu   = exp (-minibatchSize/momentumAsTimeConstant)
M(t) = M(t-minibatchSize) + learningRatePerSample G(t)

med

• G(t): momentum-utjämnad toning efter t prover
• g(t'): rå toning av provet vid tidpunkten t'
• M(t): modell som används efter att ha sett t exempel.
• t öka i steg i minibatchSize

(Obs! När du använder sekvenser minibathSize med variabel längd varierar något eftersom sekvenslängderna i en minibatch vanligtvis inte summerar exakt till den begärda minibathSize.)

Du märker:

• Momentumfiltret G(t) är enhetsvinst. Varje exempels toning fördelas över tid så att summan är 1.
• Inlärningsfrekvensen anges per exempel i stället för w.r.t. ett genomsnitt jämfört med exempel.

Specifikationen som används i andra verktyg och litteratur om neurala nätverk är ofta följande:

G'(t) = average { g(t-minibatchSize+1) ... g(t) } + mu * G'(t-minibatchSize)
M(t) = M(t-minibatchSize) + eta G'(t)

med

• G': toning definieras på ett alternativt sätt som ett genomsnitt per minibatch och utan (1-mu)
• mu: momentumparameter, t.ex. 0,9, av ett IIR-filter som inte får en enhet , tillämpat per minibatch
• eta: inlärningshastighet med minibatch-average gradient

Parametrar som anges på det här sättet kan mappas till CNTK parametrar med hjälp av följande formler:

learningRatePerSample = eta / minibatchSize / (1-mu)
momentumAsTimeConstant = -minibatchSize / ln (mu)

Du kommer nära detta med hjälp learningRatePerMB av och momentumPerMB, som mappas enligt följande (observera frånvaron av / (1-mu) för learningRatePerSample:

learningRatePerSample = learningRatePerMB / minibatchSize
momentumAsTimeConstant = -minibatchSize / ln (momentumPerMB)

Exempel

Konfiguration som används av självstudien ImageHandsOn med dataparallellitet och automatisk minibatchskalning:

SGD = {
    epochSize = 50000

    maxEpochs = 160 ; minibatchSize = 128
    learningRatesPerSample = 0.0078125*80:0.00078125*40:0.000078125
    momentumAsTimeConstant = 1200
    L2RegWeight = 0.0001

    firstMBsToShowResult = 10 ; numMBsToShowResult = 500

    parallelTrain = {
        parallelizationMethod = "dataParallelSGD"
        parallelizationStartEpoch = 1
        distributedMBReading = true
        dataParallelSGD = { gradientBits = 2 }
    }
    autoAdjust = {
        autoAdjustMinibatch = true        # enable automatic growing of minibatch size
        minibatchSizeTuningFrequency = 10 # try to enlarge after this many epochs
        numMiniBatch4LRSearch = 200
        minibatchSizeTuningMax = 15000    # out of memory above this
    }
}