Normalisation par lot

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

Paramètres

• input est l’entrée du nœud de normalisation de lot
• scale est un ParameterTensor{} qui contient les facteurs de mise à l’échelle des composants appris (gamma terme dans l’équation ci-dessous).
• bias est un ParameterTensor{} qui contient le biais appris (beta terme). scale et bias doit avoir les mêmes dimensions qui doivent être égales aux dimensions dans le input cas ou le nombre de spatial = false cartes de caractéristiques de convolution de sortie en cas de spatial = true.
• runMean est la moyenne en cours d’exécution qui est utilisée pendant la phase d’évaluation et peut également être utilisée pendant l’entraînement. Vous devez passer un ParameterTensor{} avec les mêmes dimensions que scale et bias, valeur initiale 0, et learningRateMultiplier=0 définir.
• runVariance est la variance en cours d’exécution. Elle est représentée de la même façon que runMean.
• spatial est un indicateur qui spécifie s’il faut calculer la moyenne/var pour chaque fonctionnalité d’un minibatch indépendamment ou, en cas de couches convolutionnelles, par mappage de caractéristiques.
• normalizationTimeConstant (valeur par défaut 0) : constante de temps pour le calcul de la moyenne et de la variance sous la forme d’une version filtrée à faible passe des statistiques par lots. Remarque : La valeur par défaut n’est généralement pas ce que vous voulez.
• blendTimeConstant (valeur par défaut 0) : permet d’effectuer des estimations par lots lisses avec les statistiques en cours d’exécution
• epsilon est une constante de conditionneur ajoutée à la variance lors de l’calcul de l’écart type inverse.
• useCntkEngine (valeur par défaut : true) : définissez-le pour false sélectionner l’implémentation cuDNN gpu uniquement

Valeur retournée

Le lot normalisé input.

Description

BatchNormalization implémente la technique décrite dans la normalisation par lots de papier : accélération de la formation en réseau profond en réduisant le décalage de covarié interne (Sergey Ioffe, Christian Szegedy). En bref, il normalise les sorties de couche pour chaque minibatch pour chaque sortie (fonctionnalité) indépendamment et applique la transformation affine pour conserver la représentation de la couche. Autrement dit, pour la couche input:

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

où gamma et beta sont des paramètres pouvant être entraînés.

mean et variance sont estimés à partir des données d’apprentissage. Dans le cas le plus simple, il s’agit de la moyenne et de la variance du minibatch actuel pendant l’entraînement. En inférence, une estimation à long terme est utilisée à la place.

Les estimations à long terme sont une version à faible pass filtrée des statistiques minibatch, avec la constante de temps (dans les échantillons) donnée par le normalizationTimeConstant paramètre. Une valeur de signifie qu’il 0 n’y aura pas de lissage exponentiel et la moyenne/variance en cours d’exécution sera toujours égale à celles du dernier minibatch vu. C’est souvent indésirable. Au lieu de cela, il est recommandé d’utiliser une valeur de quelques milliers ici. Le BatchNormalizationLayer{} wrapper a une valeur par défaut de 5 000.

Pour plus d’informations sur les constantes temporelles et le lissage exponentiel : https://en.wikipedia.org/wiki/Exponential_smoothing#Time_Constant

Étant donné que les statistiques de minibatch peuvent être bruyantes, CNTK permet également d’utiliser une estimation MAP (maximum-a-modifiable) pendant l’entraînement, où l’estimation à long terme en cours d’exécution est prise comme précédemment. Le poids du précédent est contrôlé par le blendTimeConstant paramètre. Toutefois, cela n’a pas été trouvé utile jusqu’à présent dans nos expériences.

Notez qu’au cours de l’inférence, CNTK définit automatiquement les deux constantes temporelles de sorte que seule l’utilisation de la moyenne en cours d’exécution existante soit utilisée et qu’elle n’est pas mise à jour. Il n’existe aucune action explicite nécessaire par l’utilisateur.

Implémentation cuDNN

Par défaut, cette fonction utilise une implémentation CNTK qui fonctionne avec des GPU et des processeurs. Vous pouvez choisir d’utiliser l’implémentation cuDNN, qui est plus performante. Notez toutefois que l’implémentation de cuDNN ne prend pas en charge toutes les options et que l’entraînement nécessite un GPU (CNTK fournit toutefois une émulation du processeur pour l’inférence même si vous sélectionnez l’implémentation cuDNN).