BrainScript SGD-blok

Artikel
07/13/2017

Het SGD-configuratieblok bepaalt het gedrag van het SGD-algoritme (Stochastic Gradient Descent) in CNTK. Als u bekend bent met andere toolkits, moet u het uitchecken

Het SGD-configuratieblok heeft de volgende structuur en standaardwaarden:

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
}

Parameters

Besturingselement voor trainingsproces

trainCriterionNodeName: de naam van het knooppunt van het trainingscriterium. Als het standaardtrainingscriteriumknooppunt in het netwerk niet is opgegeven, wordt dit gebruikt.
evalCriterionNodeName: de naam van het evaluatiecriteriumknooppunt. Als het standaardevaluatiecriteriumknooppunt in het netwerk niet is opgegeven, wordt het netwerk gebruikt.
epochSize: klik hier voor meer informatie over epochSize
keepCheckPointFiles: of u het controlepuntbestand wilt behouden nadat een nieuw tijdvak is gestart. Geldige waarden zijn true en false (standaard).
disableWkInBatchNormal: of de termijn voor gewichtsverval van batchnormalisatie tijdens SGD-updates moet worden ingeschakeld. Geldige waarden zijn true en false (standaard).
maxEpochs: maximum aantal tijdvakken dat moet worden uitgevoerd.
minibatchSize: klik hier voor meer informatie over minibatchSize
dropoutRate: dropoutpercentage tijdens de trainingsprocedure. De standaardinstelling is 0.0. Kan syntaxis gebruiken, zoals 0,5*10:0.2, wat betekent dat u vervolgkeuzelijst 0,5 gebruikt voor 10 epochs en vervolgens 0,2 voor de rest.
maxTempMemSizeInSamplesForCNN: maximaal tijdelijk geheugen dat wordt gebruikt (in aantal steekproeven) bij het verpakken en uitpakken van invoerfuncties. De standaardwaarde is 0, wat betekent dat u elke waarde indien nodig gebruikt. Handig om het afdrukken van de geheugenvoetafdruk te beheren. Wanneer u onder GPU wordt uitgevoerd.
saveBestModelPerCriterion: optie voor het opslaan van het beste model voor elk criterium, zoals gemeten op kruisvalidatiegegevens. Wanneer de training eindigt, worden modellen benoemd <modelName>_<criterionName>. Geldige waarden zijn true en false (standaard).

Learning snelheids- en momentumcontrole

Let op CNTK manier om leerpercentages en momentum op te geven, verschilt van andere toolkits. Zie hier voor een gedetailleerde beschrijving.

learningRatesPerSample: de leersnelheden per tijdvak waarmee de kleurovergang van elk voorbeeld het model bijwerkt. U kunt verschillende waarden gebruiken voor verschillende periodes, bijvoorbeeld 0,025*10:0,00625 betekent dat u de leersnelheid 0,025 gebruikt voor de eerste 10 epochs en vervolgens 0,00625 voor de rest. Dit is de voorkeursmethode voor het opgeven in CNTK, omdat hiermee de leersnelheden agnostisch worden opgegeven voor de minibatchgrootte, wat belangrijk is wanneer automatische minibatch-grootte wordt gebruikt. Andere toolkits geven vaak leerfrequenties op een minibatch-gemiddelde manier op. Als u wilt converteren van die notatie, gebruikt u de leersnelheid per steekproef = leersnelheid per MB / minibatchSize (zie hier voor meer informatie).
learningRatesPerMB: alternatieve manier om leerfrequenties op te geven die moeten worden toegepast op het gemiddelde van steekproeven in de minibatch. Dit is de meest voorkomende manier om leerfrequenties op te geven in andere toolkits, maar is problematisch in CNTK waar gegevensparallel trainen, waarmee de minibatchgrootte wordt gewijzigd. Intern wordt dit geconverteerd learningRatesPerSample door de waarden te delen door de opgegeven 'minibatchSize'. Wederzijds exclusief met learningRatesPerSample.
minLearningRatePerSample: minimale leersnelheid per steekproef. Wanneer de leersnelheid per steekproef kleiner is dan deze waarde, wordt het trainingsproces beëindigd. Dit wordt vaak gebruikt om vroeg stoppen te beheren wanneer automatische aanpassing van leersnelheid is ingeschakeld. De standaardwaarde is 1e-9.
momentumAsTimeConstant: vergelijkbaar met learningratesPerSample, CNTK geeft momentum op een minibatch-grootte agnostische manier als de tijdconstante (in steekproeven) van een eenheidswinst 1e-order IIR-filter. De waarde geeft het aantal steekproeven op waarna een kleurovergang een effect heeft van 1/e=37%. Andere toolkits geven vaak momentum aan als gewicht per minibatch (bijvoorbeeld 0,9). Als u wilt converteren, gebruikt u momentumAsTimeConstant = -minibatchSize / ln (momentumPerMB). U kunt syntaxis zoals 20000*10:2500 gebruiken, wat betekent dat u de tijdsconstante van de momentumtijd 20000 gebruikt voor 10 epochs en vervolgens 2500 voor de rest.
momentumPerMB: deze alternatieve manier om het momentum op te geven, bootst het gedrag van algemene toolkits na. Als u bijvoorbeeld 0,9 opgeeft, wordt de vorige kleurovergang behouden met een gewicht van 0,9. Houd er echter rekening mee dat, in tegenstelling tot sommige andere toolkits, CNTK nog steeds een eenheidswinstfilter gebruikt, dat wil gezegd hebben dat de nieuwe kleurovergang wordt vermenigvuldigd met (1-momentumPerMB). Intern wordt dit omgezet in momentumAsTimeConstant = -minibatchSize / ln (momentumPerMB).
autoAdjust: bevat de informatie met betrekking tot de automatische leersnelheidscontrole. De standaardwaarde is leeg ("") wat betekent dat er geen automatische controle over leersnelheid is. Binnen het blok kunnen de volgende waarden zijn:
- autoAdjustLR: het algoritme voor automatische aanpassing van leersnelheid dat moet worden gebruikt. Geldige waarden zijn None (standaard, niet automatisch het leerpercentage aanpassen), AdjustAfterEpoch (controleer het trainingscriterium na elke periode met behulp van de ontwikkelset van de trainingsset en bepaal of de leersnelheid moet worden aangepast) en SearchBeforeEpoch (zoek het leerpercentage op basis van een klein deel van de trainingsset voordat elk tijdvak begint).
- Wanneer deze wordt gebruikt in de AdjustAfterEpoch modus:
  - reduceLearnRateIfImproveLessThan: verminder het leerpercentage als de verbetering kleiner is dan deze waarde. De standaardinstelling is 0.
  - learnRateDecreaseFactor: de afnamefactor van het leerpercentage. De standaardwaarde is 0.618.
  - increaseLearnRateIfImproveMoreThan: verhoog het leerpercentage als de verbetering groter is dan deze waarde. De standaardwaarde is 1#INF (oneindig) wat betekent dat de waarde nooit toeneemt.
  - learnRateIncreaseFactor: de toename van het leerpercentage. De standaardwaarde is 1.382.
  - loadBestModel: of u het beste model wilt laden als het huidige model de prestaties verlaagt. Geldige waarden zijn true (standaard) en false.
  - learnRateAdjustInterval: bepaal de frequentie van het toepassen van de controle van de leersnelheidsaanpassing. De standaardwaarde is 1 epoch. Als deze waarde is ingesteld op een waarde die groter is dan 1, wordt de aanpassing van de leersnelheid gebaseerd op het gemiddelde criterium dat is berekend uit de laatste learnRateAdjustInterval periodes.
  - useEvalCriterionControlLR: gebruik het evaluatiecriterium in plaats van het trainingscriterium om het leerpercentage te bepalen. Standaard is het onwaar.
- Wanneer deze wordt gebruikt in de SearchBeforeEpoch modus.
  - numMiniBatch4LRSearch: het aantal minibatches dat wordt gebruikt om het leerpercentage te doorzoeken. De standaardwaarde is 500. Het is meestal ingesteld op 10-20% van de totale minibatches in een tijdvak.
  - numPrevLearnRate: het aantal eerdere leerpercentages dat wordt gebruikt als hint voor het zoekbereik. De standaardwaarde is 5.
  - numBestSearchEpoch: aantal tijdvakken waarin we het beste leerpercentage gebruiken in plaats van het voldoende leerpercentage. De standaardwaarde is 1.
- Wanneer deze wordt gebruikt in de modus AdaptiveMinibatchSizing.
  - numMiniBatch4LRSearch: het aantal minibatches dat wordt gebruikt om de minibatchgrootte te doorzoeken in de modus adaptieve minibatchgrootte. De standaardwaarde is 500. Het is meestal ingesteld op 10-20% van de totale minibatches in een tijdvak dat wordt gedeeld met de zoekfrequentie in SearchBeforeEpoch de modus.
  - autoAdjustMinibatch: in- of uitschakelen of minibatchgrootte adaptief is aangepast. De standaardwaarde is false. Adaptieve minibatchgrootten beginnen op tijdvakken die beginnen nadat de minibatchgrootten van de gebruiker expliciet zijn opgegeven, zijn voltooid. Als de gebruiker bijvoorbeeld minibatchSize=256:1024 heeft opgegeven, worden er daarna 256 en 1024 gebruikt in de eerste twee epochs en adaptieve minibatchgrootte.
  - minibatchSizeTuningFrequency: Het aantal tijdvakken dat periodiek moet worden overgeslagen voordat de minibatchgrootte dynamisch wordt aangepast. De standaardwaarde is 1.
  - minibatchSizeTuningMax: De maximale grootte die is toegestaan voor een adaptief aangepaste minibatchgrootte. De standaardwaarde is 1048576.

Besturingselement Kleurovergang

gradientClippingWithTruncation: of u de afkapping op basis van kleurovergangen wilt gebruiken om de kleurovergangsexplosie te beheren. Geldige waarden zijn true (standaard) en false. Als het onwaar is, wordt de normgebaseerde knipsel gebruikt in plaats daarvan die duurder is.
clippingThresholdPerSample: de drempel voor het knippen voor elk voorbeeld. De standaardwaarde betekent 1#INF oneindigheid (dat wil zeggen dat knipsel is uitgeschakeld).
L2RegWeight (standaard 0): het L2-regularisatiegewicht per steekproef. De Frobenius-norm van de leerbare parameter wordt met dit gewicht toegevoegd aan het doel. Dit wordt opgegeven per steekproef, wat betekent dat de Frobenius-norm wordt vermenigvuldigd met het aantal monsters in de minibatch.
L1RegWeight (standaard 0): het L1-regularisatiegewicht per steekproef.
gradUpdateType: type kleurovergangsupdate. Geldige waarden zijn None (standaard, geen speciale behandeling voor de kleurovergang), AdaGraden RmsProp.
- Wanneer gradUpdateType de kleurovergang gelijk is aan AdaGrad of RmsProp, kunt u het gedrag van de kleurovergangsupdate beheren met behulp van de volgende parameters:
  - normWithAveMultiplier: normaliseer de kleurovergang met de gemiddelde vermenigvuldigers die worden toegepast op de kleurovergangen door het algoritme AdaGrad/RmsProp. De standaardwaarde is true (standaard).
- Wanneer gradUpdateType de kleurovergang gelijk is aan RmsProp, kunt u het gedrag van de kleurovergangsupdate beheren met behulp van de volgende parameters:
  - rms_wgt_inc: vermenigvuldigingsverhoging van de leersnelheidsschaal. De standaardinstelling is 1.2.
  - rms_wgt_dec: vermenigvuldiging van de schaal van de leersnelheid. De standaardinstelling is 0.75.
  - rms_wgt_max: maximale leersnelheidsschaal toegestaan. Een waarde dichter bij 1 maakt de aanpassing van de leersnelheid stabieler maar langzamer. De standaardinstelling is 10.
  - rms_wgt_min: minimale leersnelheidsschaal toegestaan. Een waarde dichter bij 1 maakt de aanpassing van de leersnelheid stabieler maar langzamer. De standaardinstelling is 0.1.
  - rms_gamma: vereffeningsfactor die wordt gebruikt om het zwevende gemiddelde van de variantie te schatten. Hoe kleiner de waarde, hoe sneller de informatie uit het verleden wordt vergeten. De standaardinstelling is 0.99.
gaussianNoiseInjectStd: de standaarddeviatie van de Gaussiaanse ruis die is toegevoegd bij het gebruik van de AdaGrad benadering. De standaardinstelling is 0.

Informatieweergave

traceLevel: traceerniveau om te bepalen welke informatie moet worden afgedrukt in de stderr. Geldige waarden zijn 0 (standaard) en 1.
numMBsToShowResult: trainingsstatistieken weergeven na hoeveel minibatches. De standaardinstelling is 10.

TensorBoard

tensorBoardNumMBsToLogResult: aantal minibatches tussen logboekregistratieresultaten naar TensorBoard.

Kleurovergangscontrole

gradientCheck: bepaalt of de kleurovergangscontrole moet worden gebruikt. De standaardwaarde is false. Wanneer u de kleurovergangscontrole gebruikt, moet u een minibatchgrootte gebruiken die groter is dan de reekslengte voor RNN's vanwege het afgekapte backpropagatie-algoritme gedurende de tijd (BPTT) dat wordt gebruikt om RNN's te trainen en een kleiner leerpercentage om numerieke problemen te voorkomen die worden veroorzaakt door verschillen. Bovendien moet de precisie worden ingesteld op dubbel.

Description

Het gedrag van het SGD-algoritme (Stochastic Gradient Descent Learner) wordt bepaald door het SGD-blok van de opties. Wanneer een optie wordt weggelaten, wordt uitgegaan van de standaardwaarde.

Parameters die niet expliciet zijn opgegeven, worden overgelaten aan de standaardwaarden.

Gegevensgrootten opgeven

Learning- en momentumparameters converteren van andere toolkits

CNTK modelupdateformules verschillen enigszins van sommige andere toolkits en van literatuur, in dat in CNTK worden de parameters opgegeven op een manier die agnostisch is van de minibatchgrootte. Dit is belangrijk in de context van gegevensparallel trainen, waarbij CNTK zelf de minibatchgrootte kan wijzigen. Het opgeven van leersnelheid en momentum op een agnostische manier vermijdt complexiteit van het aanpassen van deze waarden bij wijzigingen van minibatchgrootte.

Dit zijn CNTK modelupdateformules voor SGD met 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)

wordt uitgevoerd met

G(t): momentum-vloeiende kleurovergang na t steekproeven
g(t'): onbewerkte kleurovergang van monster op tijd t'
M(t): model gebruikt na het zien van t voorbeelden.
t incrementeren in stappen van minibatchSize

(Opmerking: wanneer u reeksen met variabele lengte gebruikt, fluctueert iets omdat minibathSize reekslengten in een minibatch over het algemeen niet precies worden opgeteld bij de aangevraagde minibathSize.)

U ziet het volgende:

Het momentumfilter G(t) is eenheidswinst. De kleurovergang van elke steekproef wordt na verloop van tijd verdeeld, zodat de som 1 is.
De leersnelheid wordt opgegeven per steekproef, in plaats van w.r.t. een gemiddelde voor steekproeven.

De specificatie die wordt gebruikt in andere toolkits en literatuur voor neurale netwerken is vaak dit:

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

wordt uitgevoerd met

G': kleurovergang die op de alternatieve manier is gedefinieerd als een per-minibatchgemiddelde en zonder (1-mu)
mu: momentumparameter, bijvoorbeeld 0,9, van een IIR-filter zonder eenheidswinst , toegepast per minibatch
eta: leersnelheid met minibatch-gemiddelde kleurovergang

Parameters die op deze manier zijn opgegeven, kunnen worden toegewezen aan CNTK parameters met behulp van deze formules:

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

U komt hier dichtbij door gebruik te maken learningRatePerMB van en momentumPerMB, die als volgt zijn toegewezen (let op het ontbreken van/ (1-mu):learningRatePerSample

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

Voorbeeld

Configuratie die wordt gebruikt door de zelfstudie ImageHandsOn met gegevensparallellisme en automatisch schalen van minibatch:

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

Delen via