Partage de technologie

한어Русский языкEnglishFrançaisIndonesianSanskrit日本語DeutschPortuguêsΕλληνικάespañolItalianoSuomalainenLatina

0. Résumé

Rencontré il y a longtemps BatchNorm etLayerNorm, à cette époque, on savait seulement approximativement qu'ils avaient effectué desstandardisation: $$\mathbf{X}=\frac{\mathbf{X}-\mathbf{\mu }}{\mathbf{\sigma }}$$ C'est bien sûr simple, mais les données réelles sont plus compliquées.Tâches du CVEn termes d’image de données, les données d’un lot ressemblent généralement à ceci : [B, C, H, W]; pour Tâches PNLEn termes de phrase de données, les données d'un lot ressemblent généralement à ceci : [B, T, D]. Que XXNorm Comment est-il calculé ? Tous les nombres du lot entier ne sont certainement pas calculés en même temps.$\mathbf{\mu }$ et$\mathbf{\sigma }$, et ils sont différents.

J'ai donc vérifié beaucoup d'informations, et je suis vraiment d'accord avec les propos de l'instructeur : Ne lisez pas ces blogs désordonnés, ils ne sont pas aussi bons que vous. Les étrangers sont toujours géniaux, ils peuvent expliquer clairement les problèmes simplement en répondant aux questions dans le formulaire ! zone de commentaire : « Pourquoi les transformateurs utilisent-ils la norme de couche au lieu de la norme de lot ? »

1. Comment calculer ?

Cette section explique en détail du point de vue théorique et du code BatchNorm etLayerNorm Méthode de calcul.

1.1 Parlons-en théoriquement d'abord, en nous interrogeant sur la signification générale de Qianwen

>>>>> Tongyi Qianwen >>>>>
demander: Quelle est la différence entre la norme de couche et la norme de lot ? Donnez une explication de la formule.

répondre: Normalisation des couches (LayerNorm) etNormalisation par lots (BatchNorm) sont des techniques utilisées pour accélérer la formation des réseaux neuronaux, via la couche de normalisationSaisir ou activer une valeur, rendant l'apprentissage en réseau plus stable et efficace. Cependant, ils.Mise en œuvreetScène applicablesont différents.

Normalisation par lots (BatchNorm)
BatchNorm Principalement pendant l'entraînementPour un mini-lot de donnéesnormaliser.cible principaleOuiRéduire les changements de covariables internes(décalage covariable interne), c'est-à-dire que pendant le processus de propagation vers l'avant du réseau, la distribution d'entrée de la couche intermédiaire change avec les itérations d'entraînement. BatchNorm par calculLa moyenne et la variance du mini-lot actuelPour normaliser l'entrée, la formule est la suivante :
installation$\mathbf{X}$ est le vecteur d'entrée dans un mini-lot,${\mathbf{\mu }}_B$ et${\mathbf{\sigma }}_B^2$ sont respectivement la moyenne et la variance du mini-lot, alorsBatchNorm Sortir$\mathbf{et}$ On peut l'exprimer ainsi :$$\begin{array}{rl}\hat{\mathbf{X}}& =\frac{\mathbf{X}-{\mathbf{\mu }}_B}{\sqrt{{\mathbf{\mu }}_B^2+ϵ}}\\ \widehat{\mathbf{et}}& =\gamma \hat{\mathbf{X}}+\beta \end{array}$$ dans,$\gamma$ et$\beta$ est un paramètre apprenable,$ϵ$ est une petite constante utilisée pour la stabilité numérique.

Normalisation des couches (LayerNorm)
LayerNorm Le but est deà chaque niveau d'échantillonEffectuez une normalisation sans vous fier aux statistiques de mini-lots. LayerNorm Plus adapté aux modèles séquentiels (tels queLSTM ouTransformer), etc., parmi lesquelsIl peut y avoir des dépendances entre les échantillonsou La taille du mini-lot peut ne pas être fixée. LayerNorm calculerLa moyenne et la variance de chaque caractéristique de l'échantillon, la formule est la suivante :
installation$\mathbf{X}$ est le vecteur caractéristique d'un seul échantillon,${\mathbf{\mu }}_L$ et${\mathbf{\sigma }}_L^2$ sont respectivement la moyenne et la variance des caractéristiques de l'échantillon, alorsLayerNorm Sortir$\mathbf{et}$ On peut l'exprimer ainsi :$$\begin{array}{rl}\hat{\mathbf{X}}& =\frac{\mathbf{X}-{\mathbf{\mu }}_L}{\sqrt{{\mathbf{\mu }}_L^2+ϵ}}\\ \widehat{\mathbf{et}}& =\gamma \hat{\mathbf{X}}+\beta \end{array}$$ Pareil ici,$\gamma$ et$\beta$ est un paramètre apprenable,$ϵ$ est une petite constante.

la différence

• Cela dépend des données: BatchNorm dépend destatistiques de mini-lots, et LayerNorm dépend deStatistiques caractéristiques d'un seul échantillon;
• Scénarios d'application: BatchNorm plus adapté pourtâches de vision par ordinateur, et LayerNorm plus adapté pourtâches de traitement du langage naturel, en particulier lorsqu'il s'agit de données de séquence ;
• Efficacité informatique: BatchNorm Peut être plus efficace en calcul parallèle car il peut tirer parti du parallélisme au sein des mini-batchs, tout enLayerNorm Les calculs sur chaque échantillon sont indépendants et plus adaptés au traitement de données de séquence de différentes longueurs.

Les deux méthodes ont leurs propres avantages et inconvénients, et la méthode à choisir dépend généralement du scénario d'application spécifique et des caractéristiques des données.
<<<<<Tongyi Qianwen<<<<

Êtes-vous clair? Quelle est "la moyenne et la variance du mini-lot actuel"? Quelle est "la moyenne et la variance de chaque caractéristique de l'échantillon"? La réponse de l’étranger est meilleure :

Comprenons d’abord les concepts de base :

• exemple: un échantillon, image pour CV,phrase pour la PNL;
• élément: composants de l'échantillon, pixel pour l'image,mot pour la phrase;
• fonctionnalité: Caractéristiques de l'élément, Valeur RVB pour pexel,intégration pour mot.

Cela se reflète dans les données :

• [B, C, H, W] est un lot,[C, H, W] est un exemple,[C] C'est un pixel, comprenantC fonctionnalité.
• [B, T, L] est un lot,[T, L] est un exemple,[L] C'est un mot, comprenantL fonctionnalité.

Comme indiqué ci-dessous:

En regardant du côté Batch Dimension, chaque petit carré étendu vers l'arrière représente un élément, tel que la longue barre violette dans l'image de gauche, la fonctionnalité RVB d'un pixel ou un vecteur de mot.LayerNorm Donnerchaque élément Calculez la moyenne et la variance, vous pouvez obtenirBxL moyenne et variance (ouBxHxW). AlorsChaque élément est standardisé indépendamment. Le patch violet dans l'image de droite est une fonctionnalité, la première fonctionnalité de tous les mots du lot. Chacun de ces patchs est une fonctionnalité, BatchNorm DonnerChaque fonctionnalité Calculez la moyenne et la variance, vous pouvez obtenirL moyenne et variance (ouC). AlorsChaque fonctionnalité est standardisée indépendamment.

Il convient de noter que Transformer ne suit pas les règles mentionnées ci-dessus.LayerNorm calculé, mais donnéchaque instance Calculez la moyenne et la variance, vous pouvez obtenirB moyenne et variance, alorsChaque instance est standardisée indépendamment. Pour être précis, cela ressemble à l'image ci-dessous :

1.2 Dans PyTorch BatchNorm etLayerNorm

1.2.1 BatchNorm

Dans PyTorch, BatchNorm indiquernn.BatchNorm1d, nn.BatchNorm2d etnn.BatchNorm3d, respectivement pour des données de différentes dimensions :

• nn.BatchNorm1d: (N, C) ou(N, C, L)
• nn.BatchNorm2d: (N, C, H, W)
• nn.BatchNorm3d: (N, C, D, H, W)

Afficher le code source :

class BatchNorm1d(_BatchNorm):
	r"""
	Args:
		num_features: number of features or channels `C` of the input

	Shape:
		- Input: `(N, C)` or `(N, C, L)`, where `N` is the batch size,
		  `C` is the number of features or channels, and `L` is the sequence length
		- Output: `(N, C)` or `(N, C, L)` (same shape as input)
	"""
	def _check_input_dim(self, input):
		if input.dim() != 2 and input.dim() != 3:
			raise ValueError(f"expected 2D or 3D input (got {input.dim()}D input)")
1
2
3
4
5
6
7
8
9
10
11
12
13

Exemples:

>>> m = nn.BatchNorm1d(100)  # C=100	   # With Learnable Parameters
>>> m = nn.BatchNorm1d(100, affine=False)  # Without Learnable Parameters
>>> input = torch.randn(20, 100)  # (N, C)
>>> output = m(input)
>>> # 或者
>>> input = torch.randn(20, 100, 30)  # (N, C, L)
>>> output = m(input)
1
2
3
4
5
6
7

$\mathbf{\gamma },\mathbf{\beta }$ est un paramètre apprenable, etshape=(C,), le nom du paramètre est .weight et.bias:

>>> m = nn.BatchNorm1d(100)
>>> m.weight
Parameter containing:
tensor([1., 1., ..., 1.], requires_grad=True) 
>>> m.weight.shape
torch.Size([100])
>>> m.bias
Parameter containing:
tensor([0., 0., ..., 0.], requires_grad=True)
1
2
3
4
5
6
7
8
9

BatchNorm2d etBatchNorm3d sont les mêmes, la différence est que_check_input_dim(input):

class BatchNorm2d(_BatchNorm):
	r"""
	Args:
		num_features: `C` from an expected input of size `(N, C, H, W)`
	Shape:
		- Input: :math:`(N, C, H, W)`
		- Output: :math:`(N, C, H, W)` (same shape as input)
	"""
	def _check_input_dim(self, input):
		if input.dim() != 4:
			raise ValueError(f"expected 4D input (got {input.dim()}D input)")
1
2
3
4
5
6
7
8
9
10
11

Exemples:

>>> m = nn.BatchNorm2d(100)
>>> input = torch.randn(20, 100, 35, 45)
>>> output = m(input)
1
2
3

class BatchNorm3d(_BatchNorm):
	r"""
	Args:
		num_features: `C` from an expected input of size `(N, C, D, H, W)`
	Shape:
		- Input: :math:`(N, C, D, H, W)`
		- Output: :math:`(N, C, D, H, W)` (same shape as input)
	"""
	def _check_input_dim(self, input):
		if input.dim() != 5:
			raise ValueError(f"expected 5D input (got {input.dim()}D input)")
1
2
3
4
5
6
7
8
9
10
11

Exemples:

>>> m = nn.BatchNorm3d(100)
>>> input = torch.randn(20, 100, 35, 45, 10)
>>> output = m(input)
1
2
3

1.2.2 LayerNorm

différent de BatchNorm(num_features), LayerNorm(normalized_shape) Les paramètres sontinput.shape aprèsx individueldim, comme [B, T, L] Les deux dernières dimensions de[T, L], alors chaque phrase sera standardisée indépendamment si ; L ou[L], alors chaque vecteur de mot est standardisé indépendamment.

Exemple de PNL

>>> batch, sentence_length, embedding_dim = 20, 5, 10
>>> embedding = torch.randn(batch, sentence_length, embedding_dim)
>>> layer_norm = nn.LayerNorm(embedding_dim)
>>> layer_norm(embedding)  # Activate module
1
2
3
4

Exemple d'image

>>> N, C, H, W = 20, 5, 10, 10
>>> input = torch.randn(N, C, H, W)
>>> # Normalize over the last three dimensions (i.e. the channel and spatial dimensions)
>>> layer_norm = nn.LayerNorm([C, H, W])
>>> output = layer_norm(input)
1
2
3
4
5

En d’autres termes, cela inclut non seulement les « divers élément Standardiser indépendamment » et « Chaqueexemple normalisé de manière indépendante" et peut calculer n'importe quelnormaliser sur les x dernières dimensions.

1.3 Enquête sur le processus de calcul

import torch
from torch import nn

# >>> 手动计算 BatchNorm2d >>>
weight = torch.ones([1, 3, 1, 1])
bias = torch.zeros([1, 3, 1, 1])

x = 10 * torch.randn(2, 3, 4, 4) + 100
mean = x.mean(dim=[0, 2, 3], keepdim=True)
std = x.std(dim=[0, 2, 3], keepdim=True, unbiased=False)
print(x)
print(mean)
print(std)

y = (x - mean) / std
y = y * weight + bias
print(y)
# <<< 手动计算 BatchNorm2d <<<

# >>> nn.BatchNorm2d >>>
bnm2 = nn.BatchNorm2d(3)
z = bnm2(x)
print(z)
# <<< nn.BatchNorm2d <<<
print(torch.norm(z - y, p=1))
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25

Vous constaterez que le calcul manuel et nn.BatchNorm Les calculs sont presque exactement les mêmes, il y en a peut-être$ϵ$ L'influence de celui-ci.unbiased=False Il est important de noter, explique la documentation officielle :

"""
At train time in the forward pass, the standard-deviation is calculated via the biased estimator,
equivalent to `torch.var(input, unbiased=False)`.
However, the value stored in the moving average of the standard-deviation is calculated via
the unbiased  estimator, equivalent to `torch.var(input, unbiased=True)`.

Also by default, during training this layer keeps running estimates of its computed mean and
variance, which are then used for normalization during evaluation.
"""
1
2
3
4
5
6
7
8
9

Je veux juste vérifier le processus de calcul ici, pas me concentrer sur unbiased. Juste pour mentionner brièvement :

• L'étape de formation calcule une estimation biaisée de la variance, tandis que la variance de la moyenne mobile avec variance est une estimation non biaisée ;
• Pendant la formation, la moyenne mobile de la moyenne et de la variable sera enregistrée puis utilisée lors de la phase de test.