Compartir a través de

Normalización por lotes

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

Parámetros

  • input es la entrada del nodo de normalización por lotes.
  • scale es un ParameterTensor{} que contiene los factores de escalado de componentes aprendidos (gamma término en la ecuación siguiente).
  • bias es un ParameterTensor{} que contiene el sesgo aprendido (beta término). scale y bias deben tener las mismas dimensiones que deben ser iguales a las input dimensiones en caso de o número de spatial = false asignaciones de características de convolución de salida en caso de spatial = true.
  • runMean es la media en ejecución que se usa durante la fase de evaluación y que también se puede usar durante el entrenamiento. Debe pasar un ParameterTensor{} con las mismas dimensiones scale que y bias, el valor inicial 0 y learningRateMultiplier=0 establecer.
  • runVariance es la varianza en ejecución. Se representa de la misma manera que runMean.
  • spatial es una marca que especifica si se debe calcular la media/var de cada característica en un minibatch de forma independiente o, en caso de capas convolucionales, por mapa de características.
  • normalizationTimeConstant (valor predeterminado 0): constante de tiempo para calcular el promedio de ejecución de media y varianza como una versión filtrada de paso bajo de las estadísticas por lotes. Nota: El valor predeterminado no suele ser lo que desea.
  • blendTimeConstant (valor predeterminado 0): permite suavizar las estimaciones por lotes con las estadísticas en ejecución
  • epsilon es una constante de acondicionador agregada a la varianza al calcular la desviación estándar inversa.
  • useCntkEngine (valor predeterminado: true): establézcalo en false para seleccionar la implementación cuDNN solo de GPU.

Valor devuelto

Normalizado inputpor lotes.

Descripción

BatchNormalizationimplementa la técnica descrita en el artículo Normalización por lotes: Aceleración del entrenamiento de redes profundas mediante la reducción del cambio de covariante interno (Sergio Ioffe, Christian Szegedy). En resumen, normaliza las salidas de la capa para cada minibatch para cada salida (característica) de forma independiente y aplica la transformación affine para conservar la representación de la capa. Es decir, para la capa input:

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

donde gamma y beta son parámetros entrenables.

mean y variance se calculan a partir de datos de entrenamiento. En el caso más sencillo, son la media y la varianza del minibatch actual durante el entrenamiento. En su lugar, se usa una estimación a largo plazo.

Las estimaciones a largo plazo son una versión filtrada de paso bajo de las estadísticas de minibatch, con la constante de tiempo (en muestras) dada por el normalizationTimeConstant parámetro . Un valor de 0 significa que no habrá suavizado exponencial y la media/varianza en ejecución siempre será igual a los del último minibatch visto. Esto a menudo no es deseable. En su lugar, se recomienda usar un valor de unos pocos mil aquí. El BatchNormalizationLayer{} contenedor tiene un valor predeterminado de 5000.

Para obtener más información sobre las constantes de tiempo y el suavizado exponencial: https://en.wikipedia.org/wiki/Exponential_smoothing#Time_Constant

Dado que las estadísticas de minibatch pueden ser ruidosas, CNTK también permite usar una estimación MAP (máximo a posteriori) durante el entrenamiento, donde la estimación a largo plazo de ejecución se toma como anterior. El peso del anterior se controla mediante el blendTimeConstant parámetro . Sin embargo, esto no se ha encontrado útil hasta ahora en nuestros experimentos.

Tenga en cuenta que durante la inferencia, CNTK establecerá las constantes de tiempo automáticamente de forma que solo se use la media en ejecución existente y que no se actualice. El usuario no necesita ninguna acción explícita.

Implementación de cuDNN

De forma predeterminada, esta función usa una implementación de CNTK que funciona con GPU y CPU. Puede optar por usar la implementación cuDNN, que es más eficaz. Sin embargo, tenga en cuenta que la implementación cuDNN no admite todas las opciones y el entrenamiento requiere una GPU (CNTK sí proporciona una emulación de CPU para la inferencia incluso si selecciona la implementación de cuDNN).