Compartilhar via

Normalização do lote

  • Artigo
BatchNormalization(input, scale, bias, runMean, runVariance, spatial,
                   normalizationTimeConstant = 0,
                   blendTimeConstant = 0, epsilon = 0.00001, useCntkEngine = true)

Parâmetros

  • input é a entrada do nó de normalização do lote
  • scale é um ParameterTensor{} que contém os fatores de dimensionamento de componentes aprendidos (gamma termo na equação abaixo).
  • bias é um ParameterTensor{} que contém o viés aprendido (beta termo). scale e bias deve ter as mesmas dimensões que devem ser iguais às input dimensões no caso ou spatial = false número de mapas de recursos de convolução de saída no caso de spatial = true.
  • runMean é a média de execução que é usada durante a fase de avaliação e pode ser usada durante o treinamento também. Você deve passar um ParameterTensor{} com as mesmas dimensões que scale e bias, valor inicial 0, e learningRateMultiplier=0 definir.
  • runVariance é a variação em execução. Ele é representado da mesma maneira que runMean.
  • spatial é um sinalizador que especifica se a média/var deve ser computada para cada recurso em um minibatch de forma independente ou, no caso de camadas convolucionais, por mapa de recursos.
  • normalizationTimeConstant (padrão 0): constante de tempo para calcular a média de execução de média e variação como uma versão filtrada de passagem baixa das estatísticas do lote. Observação: o padrão normalmente não é o que você deseja.
  • blendTimeConstant (padrão 0): permite suavizar estimativas em lote com as estatísticas em execução
  • epsilon é uma constante de condicionador adicionada à variação ao calcular o desvio padrão inverso.
  • useCntkEngine (padrão: true): defina isso para false selecionar a implementação cuDNN somente de GPU

Valor retornado

O lote normalizado input.

Descrição

BatchNormalization implementa a técnica descrita no papel Normalização do Lote: acelerando o treinamento de rede profunda reduzindo o deslocamento de covariado interno (Sergey Ioffe, Christian Szegedy). Em suma, ele normaliza as saídas de camada para cada minibatch para cada saída (recurso) de forma independente e aplica a transformação affine para preservar a representação da camada. Ou seja, para camada input:

m = mean (input)
var = variance (input)
inputNorm = (input - mean)/sqrt (epsilon + var)
output = gamma * inputNorm + beta

onde gamma e beta são parâmetros treináveis.

mean e variance são estimados a partir de dados de treinamento. No caso mais simples, eles são a média e a variação da minibatch atual durante o treinamento. Em inferência, uma estimativa de longo prazo é usada em vez disso.

As estimativas de longo prazo são uma versão filtrada com baixo passe das estatísticas de minibatch, com a constante de tempo (em exemplos) fornecida pelo normalizationTimeConstant parâmetro. Um valor de meios de 0 que não haverá suavização exponencial e a média/variação de execução sempre será igual à da última minibatch vista. Isso geralmente é indesejável. Em vez disso, é recomendável usar um valor de alguns milhares aqui. O BatchNormalizationLayer{} wrapper tem um padrão de 5000.

Para obter mais informações sobre constantes de tempo e suavização exponencial: https://en.wikipedia.org/wiki/Exponential_smoothing#Time_Constant

Como as estatísticas de minibatch podem ser barulhentas, CNTK também permite usar uma estimativa MAP (máximo a posteriori) durante o treinamento, em que a estimativa de longo prazo em execução é tomada como a anterior. O peso do anterior é controlado pelo blendTimeConstant parâmetro. No entanto, isso não foi encontrado útil até agora em nossos experimentos.

Observe que, durante a inferência, CNTK definirá as duas constantes de tempo automaticamente, de modo que use apenas a média de execução existente e que ela não seja atualizada. Não há nenhuma ação explícita necessária pelo usuário.

Implementação cuDNN

Por padrão, essa função usa uma implementação CNTK que funciona com GPUs e CPUs. Você pode optar por usar a implementação cuDNN, que é mais performante. No entanto, observe que a implementação cuDNN não dá suporte a todas as opções e o treinamento requer uma GPU (CNTK, no entanto, fornece uma emulação de CPU para inferência mesmo se você selecionar a implementação cuDNN).