Accueil › Glossaire › Layer Normalization

Layer Normalization (Normalisation de couche)

La layer normalization (LayerNorm) est une technique qui normalise les activations d’un réseau de neurones en calculant la moyenne et la variance sur toutes les features (dimensions cachées) de chaque échantillon individuellement, puis en recentrant et redimensionnant les valeurs. C’est le mécanisme de normalisation standard des transformers et des LLM.

Sans normalisation, les activations d’un réseau profond dérivent progressivement : certaines couches produisent des valeurs très grandes, d’autres très petites. Ces déséquilibres provoquent des gradients instables, un entraînement lent et des divergences. LayerNorm résout ce problème en forçant chaque couche à produire des activations centrées (moyenne = 0) et normalisées (variance = 1), puis en laissant le réseau réajuster ces valeurs via des paramètres appris (γ et β).

Comment fonctionne la layer normalization

Pour un vecteur d’activation x de dimension d (la taille cachée du modèle), LayerNorm effectue les opérations suivantes :

Étape 1 : Calcul de la moyenne sur toutes les dimensions :

μ = (1/d) × Σᵢ xᵢ

Étape 2 : Calcul de la variance :

σ² = (1/d) × Σᵢ (xᵢ - μ)²

Étape 3 : Normalisation (recentrage + redimensionnement) :

x̂ᵢ = (xᵢ - μ) / √(σ² + ε)

Où ε est une petite constante (typiquement 10⁻⁵) pour éviter la division par zéro.

Étape 4 : Transformation affine avec les paramètres appris γ (gain/scale) et β (bias/shift) :

LayerNorm(xᵢ) = γᵢ × x̂ᵢ + βᵢ

Les paramètres γ et β sont appris pendant l’entraînement. Ils permettent au réseau de « dénormaliser » si nécessaire : si une dimension particulière a besoin d’une valeur élevée pour bien fonctionner, γ peut la redimensionner. Cette flexibilité garantit que la normalisation ne limite pas l’expressivité du modèle.

Pourquoi la normalisation est indispensable

Pour comprendre LayerNorm, il faut d’abord comprendre pourquoi la normalisation est nécessaire. Quand un réseau profond s’entraîne, les poids de chaque couche changent à chaque itération. Cela modifie la distribution des activations que chaque couche reçoit en entrée, un phénomène appelé « internal covariate shift ». La couche suivante doit constamment s’adapter à des entrées dont la distribution bouge, ce qui ralentit l’entraînement et peut provoquer des instabilités (gradients qui explosent ou qui s’évanouissent).

La normalisation résout ce problème en forçant les activations à rester dans une plage prévisible. Les couches suivantes reçoivent des entrées stables, ce qui facilite l’optimisation, permet d’utiliser des learning rates plus élevés, et accélère la convergence. C’est pourquoi quasiment tous les réseaux de neurones modernes (CNN, transformers, LLM) intègrent une forme de normalisation.

Layer Normalization vs Batch Normalization

La Batch Normalization (BatchNorm), introduite par Ioffe et Szegedy en 2015, normalise les activations sur la dimension du batch : elle calcule la moyenne et la variance de chaque feature à travers tous les échantillons du mini-batch. C’est la normalisation standard des CNN en vision par ordinateur.

LayerNorm fait l’inverse : elle normalise sur la dimension des features pour chaque échantillon individuellement. Cette différence a des conséquences profondes.

BatchNorm est problématique pour les transformers et les séquences car chaque position dans la séquence a une signification différente : normaliser le token 1 avec le token 50 à travers le batch n’a pas de sens sémantique. LayerNorm normalise chaque position indépendamment sur ses dimensions cachées, ce qui est sémantiquement cohérent.

Layer Normalization dans les transformers

Chaque bloc transformer contient deux sous-couches : le mécanisme d’attention multi-tête et le réseau feed-forward. LayerNorm est appliquée autour de chaque sous-couche, combinée avec une connexion résiduelle.

Le placement exact de LayerNorm définit deux variantes architecturales majeures.

Post-LN (architecture originale, 2017)

C’est l’architecture du paper « Attention Is All You Need » : la connexion résiduelle est ajoutée d’abord, puis LayerNorm est appliquée au résultat :

output = LayerNorm(x + SubLayer(x))

Post-LN peut souffrir d’instabilité pour les réseaux très profonds car les gradients doivent traverser la normalisation avant d’atteindre la connexion résiduelle.

Pre-LN (GPT-2+, architecture moderne)

LayerNorm est appliquée avant la sous-couche, et la connexion résiduelle contourne la normalisation :

output = x + SubLayer(LayerNorm(x))

Pre-LN préserve un « highway de gradient » propre via la connexion résiduelle. Le gradient peut traverser les couches sans être atténué par la normalisation. C’est le standard depuis GPT-2, et la grande majorité des LLM modernes utilisent Pre-LN. Des chercheurs d’Anthropic (Elhage et al., 2021) ont reformulé le flux résiduel comme le canal de communication central du transformer, confirmant l’importance de Pre-LN pour maintenir ce canal intact.

RMSNorm : l’évolution de LayerNorm dans les LLM

RMSNorm (Root Mean Square Layer Normalization), proposé par Zhang et Sennrich (2019), simplifie LayerNorm en supprimant le recentrage (pas de soustraction de la moyenne) :

RMSNorm(x) = γ ⊙ x / √((1/d) × Σᵢ xᵢ² + ε)

La différence : RMSNorm ne calcule que la norme RMS (root mean square) des activations, sans calculer la moyenne séparément. C’est plus rapide car une opération est supprimée. Les auteurs ont montré que le recentrage de LayerNorm n’est pas indispensable pour obtenir de bonnes performances.

RMSNorm est devenu le standard des LLM modernes : LLaMA (Meta), Mistral, Gemma (Google), Qwen (Alibaba) et de nombreux autres utilisent RMSNorm plutôt que LayerNorm. L’avantage de vitesse est significatif pour les entraînements de très grande échelle (milliards de paramètres, millions de tokens).

Cependant, une étude de 2025 (Costello et al.) a montré que l’absence de recentrage dans RMSNorm peut poser problème pour la quantification (réduction en 8-bit ou 16-bit) : les moyennes des activations dérivent progressivement dans les couches profondes, ce qui est problématique pour les méthodes de quantification qui fonctionnent mieux quand les valeurs sont centrées sur 0. De plus, des implémentations optimisées de LayerNorm (algorithmes en une passe, kernels fusionnés) ont réduit l’écart de vitesse historique avec RMSNorm.

DyT : au-delà de la normalisation statistique (2025)

En 2025, des chercheurs ont proposé DyT (Dynamic Tanh), une approche radicale qui remplace entièrement la normalisation statistique par une simple fonction tanh paramétrique : DyT(x) = γ ⊙ tanh(α × x) + β. Le paramètre α contrôle la « dureté » de la transformation (similaire au rôle de la normalisation statistique).

DyT a montré des résultats comparables à LayerNorm sur 9 architectures différentes dans 4 domaines (vision, NLP, parole, science). C’est une remise en question fondamentale : la normalisation statistique (calcul de moyenne et variance) n’est peut-être pas nécessaire. Une simple transformation non linéaire paramétrique suffirait.

Cependant, aucun LLM de production n’utilise encore DyT. La recette recommandée pour 2026 reste Pre-LN + RMSNorm + QK-Norm + BF16, qui est éprouvée, stable et optimisée dans toutes les bibliothèques d’entraînement majeures (PyTorch, JAX/Flax, Megatron-LM). DyT est un signal fascinant que des hypothèses « évidentes » peuvent être fausses, mais il faut encore des validations à l’échelle des LLM de production avant d’abandonner la normalisation statistique.

Implémentation en Python

import torch
import torch.nn as nn

# LayerNorm intégrée PyTorch
layer_norm = nn.LayerNorm(512)  # dimension cachée = 512

# Exemple dans un bloc transformer
class TransformerBlock(nn.Module):
    def __init__(self, d_model=512, n_heads=8):
        super().__init__()
        self.attention = nn.MultiheadAttention(d_model, n_heads)
        self.ffn = nn.Sequential(
            nn.Linear(d_model, d_model * 4),
            nn.ReLU(),
            nn.Linear(d_model * 4, d_model)
        )
        self.norm1 = nn.LayerNorm(d_model)  # Après attention
        self.norm2 = nn.LayerNorm(d_model)  # Après FFN

    def forward(self, x):
        # Pre-LN : normaliser AVANT la sous-couche
        normed = self.norm1(x)
        attn_out, _ = self.attention(normed, normed, normed)
        x = x + attn_out  # Connexion résiduelle

        normed = self.norm2(x)
        ffn_out = self.ffn(normed)
        x = x + ffn_out  # Connexion résiduelle
        return x

Pour RMSNorm (non inclus nativement dans PyTorch standard mais disponible dans les frameworks LLM comme Hugging Face Transformers, vLLM et Megatron-LM, ainsi que dans les implémentations personnalisées utilisées par la plupart des projets open source de LLM) :

class RMSNorm(nn.Module):
    def __init__(self, d_model, eps=1e-6):
        super().__init__()
        self.weight = nn.Parameter(torch.ones(d_model))
        self.eps = eps

    def forward(self, x):
        rms = torch.sqrt(torch.mean(x ** 2, dim=-1, keepdim=True) + self.eps)
        return self.weight * (x / rms)

Bonnes pratiques en production

Utilisez Pre-LN pour tout nouveau projet de transformer. Post-LN n’a d’intérêt que pour la compatibilité avec des architectures existantes ou si vous avez le budget d’expérimentation pour gérer les instabilités potentielles. Si vous entraînez un LLM, adoptez la recette standard : Pre-LN + RMSNorm + QK-Norm + BF16 (bfloat16 pour la précision mixte). Cette combinaison est utilisée par LLaMA, Gemma, OLMo et de nombreux modèles de référence.

Attention à l’interaction avec d’autres hyperparamètres. Changer de technique de normalisation (par exemple, passer de LayerNorm à RMSNorm) modifie la dynamique d’optimisation. Le learning rate optimal, le weight decay et d’autres hyperparamètres peuvent nécessiter un ajustement. Ne faites pas ce changement sans retester vos hyperparamètres.

Pour l’inférence, LayerNorm est directement compatible : les mêmes opérations sont appliquées pendant l’entraînement et l’inférence, contrairement à BatchNorm qui nécessite un changement de mode (passage aux running averages). C’est un avantage pratique majeur pour le déploiement de modèles, surtout dans les systèmes de streaming ou de génération en temps réel.

La QK-Normalization (normalisation des vecteurs Query et Key avant le produit scalaire d’attention) est une addition récente mais importante. Dehghani et al. (2023) ont montré qu’un modèle ViT de 8 milliards de paramètres divergeait sans QK-Norm, avec des logits d’attention dépassant 50 000. Gemma 2/3, OLMo 2 et Qwen 3 utilisent tous QK-Norm. C’est deux lignes de code qui préviennent des divergences catastrophiques.

L’évolution de la normalisation : une histoire de simplification

L’histoire de la normalisation dans les réseaux de neurones est fascinante car chaque étape a supprimé un élément jugé « indispensable », sans dégrader les résultats.

BatchNorm (2015) : normalise sur le batch, calcule moyenne et variance, utilise des paramètres appris γ et β. Nécessite des running averages pour l’inférence.

LayerNorm (2016) : supprime la dépendance au batch. Normalise par échantillon. Plus de running averages, fonctionne identiquement à l’entraînement et à l’inférence.

RMSNorm (2019) : supprime le recentrage. Ne calcule plus la moyenne, seulement la norme RMS. Plus rapide, résultats comparables.

DyT (2025) : supprime le calcul de statistiques. Remplace la normalisation par une simple fonction tanh paramétrique. Résultats comparables sur 9 architectures.

Chaque étape a simplifié le mécanisme. C’est un rappel que les hypothèses « évidentes » en deep learning méritent d’être questionnées. La normalisation statistique, considérée comme essentielle pendant des années, n’est peut-être qu’une des nombreuses manières de stabiliser l’entraînement.

Autres techniques de normalisation

Group Normalization (GN) : divise les features en groupes et normalise au sein de chaque groupe. C’est un compromis entre BatchNorm (qui normalise sur le batch) et LayerNorm (qui normalise sur toutes les features). GN fonctionne bien avec des petits batchs et est souvent utilisé en vision par ordinateur quand le batch est trop petit pour que BatchNorm soit fiable. Instance Normalization (IN) : normalise chaque canal par échantillon dans les dimensions spatiales. C’est le standard pour le style transfer (transfert de style artistique) car la normalisation par instance supprime les différences stylistiques triviales et permet au modèle de se concentrer sur les transformations structurelles. QK-Normalization : normalise les vecteurs Query et Key avant le produit scalaire dans le mécanisme d’attention. Évite l’explosion des logits d’attention dans les modèles très grands. Utilisé dans Gemma 2/3, OLMo 2, Qwen 3. C’est une addition simple (deux lignes de code) mais critique pour la stabilité des LLM à très grande échelle.