Bloco SGD do BrainScript

Artigo
07/13/2017

O bloco de configuração do SGD controla o comportamento do algoritmo SGD (Stochastic Gradient Descent) em CNTK. Se você estiver familiarizado com outros kits de ferramentas, certifique-se de fazer check-out

O bloco de configuração do SGD tem a seguinte estrutura e valores padrão:

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
}

Parâmetros

Controle do processo de treinamento

trainCriterionNodeName: o nome do nó do critério de treinamento. Se não for fornecido o nó de critério de treinamento padrão na rede será usado.
evalCriterionNodeName: o nome do nó do critério de avaliação. Se não for fornecido, o nó de critério de avaliação padrão na rede será usado.
epochSize: clique aqui para saber mais sobre epochSize
keepCheckPointFiles: se você deseja manter o arquivo de ponto de verificação após o início de uma nova época. Os valores válidos são true e false (padrão).
disableWkInBatchNormal: se deseja habilitar o termo de decaimento de peso da normalização em lote enquanto o SGD é atualizado. Os valores válidos são true e false (padrão).
maxEpochs: número máximo de épocas a serem executadas.
minibatchSize: clique aqui para saber mais sobre minibatchSize
dropoutRate: taxa de abandono durante o procedimento de treinamento. O padrão é 0.0. Pode usar sintaxe como 0,5*10:0.2, o que significa usar a taxa de abandono 0,5 para 10 épocas e, em seguida, 0,2 para o restante.
maxTempMemSizeInSamplesForCNN: memória temporária máxima usada (em número de exemplos) ao empacotar e desempacotar recursos de entrada. O padrão é 0, o que significa usar qualquer valor conforme necessário. Útil para controlar a impressão do pé de memória esp. quando executado em GPU.
saveBestModelPerCriterion: opção para salvar o melhor modelo para cada critério, conforme medido em dados de validação cruzada. Quando o treinamento termina, os modelos são nomeados <modelName>_<criterionName>. Os valores válidos são true e false (padrão).

Learning controle de taxa e de impulso

Observe CNTK maneira de especificar taxas de aprendizagem e o impulso difere de outros kits de ferramentas. Veja aqui uma descrição detalhada.

learningRatesPerSample: as taxas de aprendizagem por época com a qual o gradiente de cada exemplo atualiza o modelo. Você pode usar valores diferentes para diferentes épocas, por exemplo, 0,025*10:0.00625 significa usar a taxa de aprendizagem 0,025 para as primeiras 10 épocas e, em seguida, 0,00625 para o restante. Essa é a maneira preferencial de especificar em CNTK, uma vez que especifica as taxas de aprendizagem agnósticas para o tamanho da minibatch, o que é importante quando o dimensionamento automático de minibatch é usado. Outros kits de ferramentas geralmente especificam taxas de aprendizagem de uma forma de minibatch-média. Para converter a partir dessa notação, use a taxa de aprendizagem por exemplo = taxa de aprendizagem por MB / minibatchSize (consulte aqui para obter mais detalhes).
learningRatesPerMB: maneira alternativa de especificar as taxas de aprendizagem a serem aplicadas à média em amostras na minibatch. Essa é a maneira mais comum de especificar taxas de aprendizagem em outros kits de ferramentas, mas é problemática em CNTK onde o treinamento paralelo de dados, que modifica o tamanho da minibatch. Internamente, isso será convertido learningRatesPerSample dividindo os valores pelo "minibatchSize" especificado. Mutuamente exclusivo com learningRatesPerSample.
minLearningRatePerSample: taxa de aprendizagem mínima por exemplo. Quando a taxa de aprendizagem por exemplo for menor que esse valor, o processo de treinamento será encerrado. Isso geralmente é usado para controlar a interrupção antecipada quando o ajuste automático da taxa de aprendizagem está habilitado. O padrão é 1e-9.
momentumAsTimeConstant: da mesma forma que learningratesPerSample, CNTK especifica o impulso de uma maneira agnóstica de tamanho de minibatch como a constante de tempo (em exemplos) de um filtro IIR de 1ª ordem de ganho de unidade. O valor especifica o número de exemplos após os quais um gradiente tem um efeito de 1/e=37%. Outros kits de ferramentas geralmente especificam o impulso como um peso por minibatch (por exemplo, 0,9). Para converter a partir disso, use momentumAsTimeConstant = -minibatchSize / ln (momentumPerMB). Você pode usar sintaxe como 20000*10:2500, o que significa usar a constante de tempo de dinâmica 20000 para 10 épocas e, em seguida, 2500 para o resto.
momentumPerMB: essa maneira alternativa de especificar o momento imita o comportamento de kits de ferramentas comuns. Por exemplo, especificar 0,9 significa que o gradiente anterior será retido com um peso de 0,9. Observe, no entanto, que, ao contrário de alguns outros kits de ferramentas, CNTK ainda usa um filtro de ganho de unidade, ou seja, o novo gradiente será multiplicado com (1-momentumPerMB). Internamente, isso será convertido em momentumAsTimeConstant = -minibatchSize / ln (momentumPerMB).
autoAdjust: contém as informações relacionadas ao controle automático de taxa de aprendizagem. O valor padrão está vazio ("") o que significa que não há controle automático de taxa de aprendizagem. Dentro do bloco, pode haver os seguintes valores:
- autoAdjustLR: o algoritmo de ajuste automático de taxa de aprendizagem a ser usado. Os valores válidos são None (padrão, não ajuste automaticamente a taxa de aprendizagem) AdjustAfterEpoch (verifique o critério de treinamento após cada época usando o conjunto de desenvolvimento do conjunto de treinamento e decida se deseja ajustar a taxa de aprendizado) e SearchBeforeEpoch (pesquise a taxa de aprendizado com base em uma pequena parte do conjunto de treinamento antes de cada época começar).
- Quando usado no AdjustAfterEpoch modo:
  - reduceLearnRateIfImproveLessThan: reduza a taxa de aprendizado se a melhoria for menor que esse valor. O padrão é 0.
  - learnRateDecreaseFactor: o fator de redução da taxa de aprendizagem. O valor padrão é 0.618.
  - increaseLearnRateIfImproveMoreThan: aumente a taxa de aprendizado se a melhoria for maior que esse valor. O valor padrão é 1#INF (infinito), o que significa nunca aumentar.
  - learnRateIncreaseFactor: o fator de aumento da taxa de aprendizagem. O valor padrão é 1.382.
  - loadBestModel: se deve carregar o melhor modelo se o modelo atual diminuir o desempenho. Os valores válidos são true (padrão) e false.
  - learnRateAdjustInterval: determine a frequência de aplicação da verificação de ajuste da taxa de aprendizagem. O padrão é 1 época. Se esse valor for definido como um valor maior que 1, o ajuste da taxa de aprendizagem será baseado no critério médio calculado das últimas learnRateAdjustInterval épocas.
  - useEvalCriterionControlLR: use o critério de avaliação em vez do critério de treinamento para controlar a taxa de aprendizado. Por padrão, é false.
- Quando usado no SearchBeforeEpoch modo.
  - numMiniBatch4LRSearch: o número de minibatches usados para pesquisar a taxa de aprendizado. O valor padrão é 500. Normalmente, ele é definido como 10-20% do total de minibatches em uma época.
  - numPrevLearnRate: número de taxas de aprendizagem anteriores usadas como uma dica para o intervalo de pesquisa. O valor padrão é 5.
  - numBestSearchEpoch: número de épocas em que usamos a melhor taxa de aprendizagem em vez da taxa de aprendizagem suficiente. O valor padrão é 1.
- Quando usado no modo 'AdaptiveMinibatchSizing'.
  - numMiniBatch4LRSearch: o número de minibatches usados para pesquisar o tamanho da minibatch quando estiver no modo de tamanho de minibatch adaptável. O valor padrão é 500. Normalmente, ele é definido como 10-20% do total de minibatches em uma época que é compartilhada com a pesquisa da taxa de aprendizagem no SearchBeforeEpoch modo.
  - autoAdjustMinibatch: habilitar ou desabilitar se o tamanho da minibatch é ajustado adaptávelmente. O valor padrão é false. O dimensionamento de minibatch adaptável começará em épocas a partir de quando os tamanhos de minibatch do usuário especificados explicitamente forem concluídos. Por exemplo, se o usuário especificou minibatchSize=256:1024, 256 e 1024 são usados nas primeiras 2 Épocas e o dimensionamento de minibatch adaptável é usado posteriormente.
  - minibatchSizeTuningFrequency: o número de épocas a serem ignoradas, periodicamente, antes de ajustar dinamicamente o tamanho da minibatch. O valor padrão é 1.
  - minibatchSizeTuningMax: o tamanho máximo permitido para um tamanho de minibatch ajustado adaptável. O valor padrão é 1048576.

Controle Gradiente

gradientClippingWithTruncation: se deve usar o recorte de gradiente baseado em truncamento para controlar a explosão de gradiente. Os valores válidos são true (padrão) e false. Se for falso, o recorte baseado em norma será usado, o que é mais caro.
clippingThresholdPerSample: o limite de recorte para cada exemplo. O valor padrão é 1#INF o que significa infinito (ou seja, o recorte está desativado).
L2RegWeight (padrão 0): o peso de regularização L2 por amostra. A norma Frobenius do parâmetro aprendiz é adicionada ao objetivo com esse peso. Isso é especificado por exemplo, o que significa que a norma Frobenius é multiplicada pelo número de amostras na minibatch.
L1RegWeight (padrão 0): o peso de regularização L1 por amostra.
gradUpdateType: tipo de atualização de gradiente. Os valores válidos são None (padrão, nenhum tratamento especial para o gradiente) AdaGrade RmsProp.
- Quando gradUpdateType igual a AdaGrad ou RmsProp, você pode controlar o comportamento da atualização de gradiente usando os seguintes parâmetros:
  - normWithAveMultiplier: normalize o gradiente com os multiplicadores médios aplicados aos gradientes pelo algoritmo AdaGrad/RmsProp. O padrão é true (padrão).
- Quando gradUpdateType igual a RmsProp, você pode controlar o comportamento da atualização de gradiente usando os seguintes parâmetros:
  - rms_wgt_inc: incremento multiplicativo da escala de taxa de aprendizado. O padrão é 1.2.
  - rms_wgt_dec: decremento multiplicativo da escala de taxa de aprendizagem. O padrão é 0.75.
  - rms_wgt_max: escala máxima de taxa de aprendizagem permitida. Um valor mais próximo de 1 torna o ajuste da taxa de aprendizagem mais estável, mas mais lento. O padrão é 10.
  - rms_wgt_min: escala de taxa de aprendizagem mínima permitida. Um valor mais próximo de 1 torna o ajuste da taxa de aprendizagem mais estável, mas mais lento. O padrão é 0.1.
  - rms_gamma: fator de suavização usado para estimar a média móvel da variação. Quanto menor o valor, mais rápido ele esquece as informações passadas. O padrão é 0.99.
gaussianNoiseInjectStd: o desvio padrão do ruído gaussiano adicionado ao usar a AdaGrad abordagem. O padrão é 0.

Exibição de informações

traceLevel: nível de rastreamento para decidir quais informações imprimir no stderr. Os valores válidos são 0 (padrão) e 1.
numMBsToShowResult: exibir estatísticas de treinamento após quantos minibatches. O padrão é 10.

TensorBoard

tensorBoardNumMBsToLogResult: número de minibates entre os resultados do registro em log no TensorBoard.

Verificação de gradiente

gradientCheck: determina se o verificador de gradiente deve ser usado. O valor padrão é false. Ao usar o verificador de gradiente, você precisa usar um tamanho de minibatch maior que o comprimento da sequência para RNNs devido ao algoritmo de backpropagation truncado por meio do tempo (BPTT) usado para treinar RNNs e uma taxa de aprendizado menor para evitar problemas numéricos causados por divergência. Além disso, a precisão deve ser definida como duplicada.

Descrição

O comportamento do algoritmo SGD (Stochastic Gradient Descent Learner) é controlado pelo bloco SGD das opções. Quando uma opção é omitida, o valor padrão é assumido.

Os parâmetros que não são especificados explicitamente são deixados para os valores padrão.

Especificando tamanhos de dados

Convertendo parâmetros de taxa de Learning e momentum de outros kits de ferramentas

as fórmulas de atualização de modelo do CNTK diferem um pouco de alguns outros kits de ferramentas e da literatura, em que, em CNTK, os parâmetros são especificados de forma agnóstica do tamanho da minibatch. Isso é importante no contexto do treinamento paralelo de dados, em que CNTK em si pode modificar o tamanho da minibatch. Especificar a taxa de aprendizagem e o momento de forma agnóstica evita complexidades de ajustar esses valores após alterações de tamanho de minibatch.

Estas são as fórmulas de atualização de modelo do CNTK para o SGD com impulso:

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)

por

G(t): gradiente suavizado por impulso após t exemplos
g(t'): gradiente bruto de amostra no momento t'
M(t): modelo usado depois de ver t amostras.
t incrementando em etapas de minibatchSize

(Observação: ao usar sequências de comprimento variável, irá flutuar ligeiramente, minibathSize uma vez que os comprimentos de sequência em um minibatch geralmente não somam precisamente ao solicitado minibathSize.)

Você observa:

O filtro G(t) de impulso é ganho de unidade. O gradiente de cada amostra é distribuído ao longo do tempo, de modo que a soma seja 1.
A taxa de aprendizado é especificada por exemplo, em vez de w.r.t. uma média sobre amostras.

A especificação usada em outros kits de ferramentas e na literatura de rede neural é frequentemente esta:

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

por

G': gradiente definido da maneira alternativa como uma média por minibatch e sem (1-mu)
mu: parâmetro momentum, por exemplo, 0,9, de um filtro IIR não-unit-gain , aplicado por minibatch
eta: taxa de aprendizado com gradiente de média de minibatch

Os parâmetros especificados dessa forma podem ser mapeados para parâmetros CNTK usando estas fórmulas:

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

Você se aproximará disso usando learningRatePerMB e, que são mapeados da seguinte maneira (observe a ausência de / (1-mu)learningRatePerSample:momentumPerMB

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

Exemplo

Configuração usada pelo tutorial ImageHandsOn com paralelismo de dados e dimensionamento automático 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
    }
}

Compartilhar via