Bloc SGD BrainScript

Le bloc de configuration SGD contrôle le comportement de l’algorithme SGD (descente de dégradé stochastique) dans CNTK. Si vous êtes familiarisé avec d’autres boîtes à outils, veillez à consulter

Le bloc de configuration SGD a la structure et les valeurs par défaut suivantes :

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
}

Paramètres

Contrôle du processus d’entraînement

trainCriterionNodeName: nom du nœud de critère d’entraînement. Si aucun nœud de critère d’apprentissage par défaut n’est fourni dans le réseau, il est utilisé.
evalCriterionNodeName: nom du nœud du critère d’évaluation. Si aucun nœud de critère d’évaluation par défaut n’est fourni dans le réseau, il sera utilisé.
epochSize: cliquez ici pour en savoir plus sur l’époqueSize
keepCheckPointFiles: indique si vous souhaitez conserver le fichier de point de contrôle après le début d’une nouvelle époque. Les valeurs valides sont true et false (valeur par défaut).
disableWkInBatchNormal: indique s’il faut activer le terme de désintégration de poids de la normalisation par lots pendant les mises à jour SGD. Les valeurs valides sont true et false (valeur par défaut).
maxEpochs: nombre maximal d’époques à exécuter.
minibatchSize: cliquez ici pour en savoir plus sur minibatchSize
dropoutRate: taux d’abandon pendant la procédure d’entraînement. La valeur par défaut est 0.0. Peut utiliser une syntaxe telle que 0,5*10:0.2, ce qui signifie utiliser le taux d’abandon 0,5 pour 10 époques, puis 0,2 pour le reste.
maxTempMemSizeInSamplesForCNN: mémoire temporaire maximale utilisée (en nombre d’échantillons) lors de l’empaquetage et de la décompression des fonctionnalités d’entrée. La valeur par défaut est 0, ce qui signifie utiliser n’importe quelle valeur si nécessaire. Utile pour contrôler l’esp d’impression de pied de mémoire. Lors de l’exécution sous GPU.
saveBestModelPerCriterion: option permettant d’enregistrer le meilleur modèle pour chaque critère, tel qu’il est mesuré sur les données de validation croisée. Lorsque l’entraînement met fin aux modèles sont nommés <modelName>_<criterionName>. Les valeurs valides sont true et false (valeur par défaut).

taux de Learning et contrôle de l’élan

Notez CNTK méthode de spécification des taux d’apprentissage et de l’élan diffère des autres boîtes à outils. Consultez cette page pour obtenir une description détaillée.

learningRatesPerSample: taux d’apprentissage par époque avec lequel le dégradé de chaque échantillon met à jour le modèle. Vous pouvez utiliser différentes valeurs pour différentes époques, par exemple 0,025*10:0.00625 signifie utiliser le taux d’apprentissage 0,025 pour les 10 premières époques, puis 0,00625 pour le reste. Il s’agit du moyen préféré de spécifier dans CNTK, car il spécifie les taux d’apprentissage indépendants de la taille minibatch, ce qui est important lorsque le dimensionnement automatique de minibatch est utilisé. D’autres boîtes à outils spécifient souvent des taux d’apprentissage de manière minibatch-moyenne. Pour effectuer une conversion à partir de cette notation, utilisez le taux d’apprentissage par échantillon = taux d’apprentissage par Mo / minibatchSize (voir ici pour plus d’informations).
learningRatesPerMB: autre méthode de spécification des taux d’apprentissage à appliquer à la moyenne sur les échantillons dans le minibatch. Il s’agit du moyen le plus courant de spécifier des taux d’apprentissage dans d’autres boîtes à outils, mais il est problématique dans CNTK’s où l’entraînement en parallèle des données, qui modifie la taille de minibatch. En interne, cela sera converti en learningRatesPerSample divisant les valeurs par le « minibatchSize » spécifié. S’exclue mutuellement avec learningRatesPerSample.
minLearningRatePerSample: taux d’apprentissage minimal par échantillon. Lorsque le taux d’apprentissage par échantillon est inférieur à cette valeur, le processus d’entraînement se termine. Cela est souvent utilisé pour contrôler l’arrêt précoce lorsque l’ajustement automatique du taux d’apprentissage est activé. La valeur par défaut est 1e-9.
momentumAsTimeConstant: de la même façon learningratesPerSampleque , CNTK spécifie l’élan d’une manière indépendante de la taille minibatch comme constante de temps (dans les échantillons) d’un filtre IIR de gain d’unité. La valeur spécifie le nombre d’échantillons après lesquels un dégradé a un effet de 1/e=37 %. D’autres boîtes à outils spécifient souvent l’élan comme poids par minibatch (par exemple, 0,9). Pour convertir à partir de cela, utilisez momentumAsTimeConstant = -minibatchSize / ln (momentumPerMB). Vous pouvez utiliser une syntaxe telle que 20000*10:2500, ce qui signifie utiliser la constante de temps dynamique 20000 pour 10 époques, puis 2500 pour le reste.
momentumPerMB: cette autre façon de spécifier l’élan imite le comportement des boîtes à outils courantes. Par exemple, spécifier 0,9 signifie que le dégradé précédent sera conservé avec un poids de 0,9. Notez toutefois que, contrairement à d’autres boîtes à outils, CNTK utilise toujours un filtre de gain unitaire, c’est-à-dire que le nouveau dégradé sera multiplié par (1-momentumPerMB). En interne, cela sera converti en momentumAsTimeConstant = -minibatchSize / ln (momentumPerMB).
autoAdjust: contient les informations relatives au contrôle automatique du taux d’apprentissage. La valeur par défaut est vide ( » « ) ce qui signifie qu’aucun contrôle automatique du taux d’apprentissage. À l’intérieur du bloc, il peut y avoir les valeurs suivantes :
- autoAdjustLR: algorithme d’ajustement automatique du taux d’apprentissage à utiliser. Les valeurs valides sont None (par défaut, ne pas ajuster automatiquement le taux d’apprentissage) AdjustAfterEpoch (vérifiez le critère d’entraînement après chaque époque à l’aide du jeu de développement du jeu d’entraînement et décidez s’il faut ajuster le taux d’apprentissage) et SearchBeforeEpoch (recherchez le taux d’apprentissage en fonction d’une petite partie du jeu d’entraînement avant chaque époque).
- Lorsqu’il est AdjustAfterEpoch utilisé en mode :
  - reduceLearnRateIfImproveLessThan: réduisez le taux d’apprentissage si l’amélioration est inférieure à cette valeur. La valeur par défaut est 0.
  - learnRateDecreaseFactor: facteur de diminution du taux d’apprentissage. La valeur par défaut est 0.618.
  - increaseLearnRateIfImproveMoreThan: augmentez le taux d’apprentissage si l’amélioration est supérieure à cette valeur. La valeur par défaut est 1#INF (infini), ce qui signifie ne jamais augmenter.
  - learnRateIncreaseFactor: facteur d’augmentation du taux d’apprentissage. La valeur par défaut est 1.382.
  - loadBestModel: indique s’il faut charger le meilleur modèle si le modèle actuel diminue les performances. Les valeurs valides sont true (valeur par défaut) et false.
  - learnRateAdjustInterval: déterminer la fréquence d’application du contrôle d’ajustement du taux d’apprentissage. La valeur par défaut est l’époque 1 . Si cette valeur est définie sur une valeur supérieure à 1, l’ajustement du taux d’apprentissage est basé sur le critère moyen calculé à partir des dernières learnRateAdjustInterval époques.
  - useEvalCriterionControlLR: utilisez le critère d’évaluation au lieu du critère d’apprentissage pour contrôler le taux d’apprentissage. La valeur par défaut est false.
- Lorsqu’il est SearchBeforeEpoch utilisé en mode.
  - numMiniBatch4LRSearch: nombre de minibatches utilisés pour rechercher le taux d’apprentissage. La valeur par défaut est 500. Il est généralement défini sur 10-20% du nombre total de minibatches dans une époque.
  - numPrevLearnRate: nombre de taux d’apprentissage précédents utilisés comme indicateur de la plage de recherche. La valeur par défaut est 5.
  - numBestSearchEpoch: nombre d’époques dans lesquelles nous utilisons le meilleur taux d’apprentissage au lieu du taux d’apprentissage suffisant. La valeur par défaut est 1.
- Lorsqu’il est utilisé en mode « AdaptiveMinibatchSizing ».
  - numMiniBatch4LRSearch: nombre de minibatches utilisés pour rechercher la taille de minibatch en mode de taille de minibatch adaptatif. La valeur par défaut est 500. Il est généralement défini sur 10 à 20 % du nombre total de minibatches dans une époque qui est partagée avec la recherche du taux d’apprentissage en SearchBeforeEpoch mode.
  - autoAdjustMinibatch: activer ou désactiver si la taille de minibatch est ajustée de manière adaptative. La valeur par défaut est false. Le dimensionnement de minibatch adaptatif commence sur les époques commençant après que les tailles de minibatch utilisateur spécifiées explicitement sont terminées. Par exemple, si l’utilisateur a spécifié minibatchSize=256:1024, alors 256 et 1024 sont utilisés dans les 2 premières époques et le dimensionnement adaptatif de minibatch est utilisé par la suite.
  - minibatchSizeTuningFrequency: nombre d’époques à ignorer, périodiquement, avant d’ajuster dynamiquement la taille du minibatch. La valeur par défaut est 1.
  - minibatchSizeTuningMax: taille maximale autorisée pour une taille minibatch ajustée de manière adaptative. La valeur par défaut est 1048576.

Contrôle dégradé

gradientClippingWithTruncation: indique s’il faut utiliser le découpage de dégradé basé sur la troncation pour contrôler l’explosion du dégradé. Les valeurs valides sont true (valeur par défaut) et false. S’il est faux, le découpage basé sur la norme sera utilisé à la place, ce qui est plus coûteux.
clippingThresholdPerSample: seuil de découpage pour chaque exemple. La valeur par défaut signifie 1#INF l’infini (c’est-à-dire la coupure est désactivée).
L2RegWeight (valeur par défaut 0) : poids de la normalisation L2 par échantillon. La norme Frobenius du paramètre apprenant est ajoutée à l’objectif avec ce poids. Cela est spécifié par échantillon, ce qui signifie que la norme Frobenius est multipliée par le nombre d’échantillons dans le minibatch.
L1RegWeight (valeur par défaut 0) : poids de la normalisation L1 par échantillon.
gradUpdateType: type de mise à jour de dégradé. Les valeurs valides sont None (par défaut, aucun traitement spécial au dégradé), AdaGradet RmsProp.
- En cas gradUpdateType d’égalité ou RmsProp, vous pouvez contrôler le comportement de la mise à jour de dégradé à AdaGrad l’aide des paramètres suivants :
  - normWithAveMultiplier: normalisez le dégradé avec les multiplicateurs moyens appliqués aux dégradés par l’algorithme AdaGrad/RmsProp. La valeur par défaut est true (par défaut).
- Quand gradUpdateType elle est égale à , vous pouvez contrôler le comportement de la mise à jour de dégradé à RmsPropl’aide des paramètres suivants :
  - rms_wgt_inc: incrément multiplicative de l’échelle du taux d’apprentissage. La valeur par défaut est 1.2.
  - rms_wgt_dec: décrémentation multipliée de l’échelle du taux d’apprentissage. La valeur par défaut est 0.75.
  - rms_wgt_max: échelle maximale du taux d’apprentissage autorisée. Une valeur plus proche de 1 rend l’ajustement du taux d’apprentissage plus stable mais plus lent. La valeur par défaut est 10.
  - rms_wgt_min: échelle minimale du taux d’apprentissage autorisée. Une valeur plus proche de 1 rend l’ajustement du taux d’apprentissage plus stable mais plus lent. La valeur par défaut est 0.1.
  - rms_gamma: facteur de lissage utilisé pour estimer la moyenne mobile de la variance. Plus la valeur est réduite, plus elle oublie les informations passées. La valeur par défaut est 0.99.
gaussianNoiseInjectStd: écart type du bruit gaussien ajouté lors de l’utilisation de l’approche AdaGrad . La valeur par défaut est 0.

Affichage des informations

traceLevel: niveau de trace pour décider quelles informations imprimer dans le stderr. Les valeurs valides sont 0 (valeur par défaut) et 1.
numMBsToShowResult: affiche les statistiques d’entraînement après le nombre de minibatches. La valeur par défaut est 10.

TensorBoard

tensorBoardNumMBsToLogResult: nombre de minibatches entre les résultats de journalisation dans TensorBoard.

Vérification de dégradé

gradientCheck: détermine s’il faut utiliser le vérificateur de dégradé. La valeur par défaut est false. Lorsque vous utilisez le vérificateur de dégradé, vous devez utiliser une taille minibatch supérieure à la longueur de séquence pour les rnns en raison de l’algorithme backpropagation tronqué par le temps (BPTT) utilisé pour entraîner les RNN, et un taux d’apprentissage plus petit pour empêcher les problèmes numériques causés par la divergence. En outre, la précision doit être définie sur double.

Description

Le comportement de l’algorithme SGD (Apprenant de descente de dégradé stochastique) est contrôlé par le bloc SGD des options. Lorsqu’une option est omise, la valeur par défaut est supposée.

Les paramètres qui ne sont pas spécifiés explicitement sont laissés aux valeurs par défaut.

Spécification des tailles de données

Conversion de paramètres Learning-rate et Momentum à partir d’autres toolkits

CNTK la formule de mise à jour du modèle diffère un peu de certaines autres boîtes à outils et de la littérature, dans cette CNTK, les paramètres sont spécifiés d’une manière qui est agnostique de la taille minibatch. Il est important dans le contexte de l’apprentissage parallèle des données, où CNTK peut modifier la taille du minibatch. La spécification du taux d’apprentissage et de l’élan de manière agnostique évite les complexités de l’ajustement de ces valeurs sur les changements de taille minibatch.

Il s’agit de la formule de mise à jour de modèle de CNTK pour SGD avec un élan :

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)

par

G(t): dégradé lisse à l’élan après t des échantillons
g(t'): dégradé brut d’échantillon au moment t'
M(t): modèle utilisé après avoir vu t des exemples.
t incrémentation dans les étapes de minibatchSize

(Remarque : Lors de l’utilisation de séquences de longueur variable, varie légèrement, minibathSize car les longueurs de séquence dans un minibatch ne se résument généralement pas précisément à la demande minibathSize.)

Vous remarquez :

Le filtre G(t) d’élan est un gain unitaire. Chaque dégradé de chaque échantillon est distribué au fil du temps de sorte que leur somme soit 1.
Le taux d’apprentissage est spécifié par échantillon, plutôt que w.r.t. une moyenne par rapport aux échantillons.

La spécification utilisée dans d’autres boîtes à outils et la littérature de réseau neuronal sont souvent les suivantes :

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

par

G': dégradé défini de la manière alternative comme moyenne par minibatch et sans (1-mu)
mu: paramètre d’élan, par exemple 0,9, d’un filtre IIR non unitaire , appliqué par minibatch
eta: taux d’apprentissage avec dégradé moyen minibatch

Les paramètres spécifiés de cette façon peuvent être mappés aux paramètres CNTK à l’aide de ces formules :

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

Vous serez proche de cela à l’aide learningRatePerMB et momentumPerMB, qui sont mappés comme suit (notez l’absence de / (1-mu) :learningRatePerSample

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

Exemple

Configuration utilisée par le didacticiel ImageHandsOn avec le parallélisme des données et la mise à l’échelle automatique de 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
    }
}

Last updated on 2017-07-13

Partager via