Transformers sans normalisation

• Remplacer Layer Norm/RMSNorm, utilisées comme des composants indispensables dans les Transformers, par Dynamic Tanh (DyT) peut offrir des performances comparables, voire supérieures, à celles des modèles classiques avec normalisation
• DyT est une opération élément par élément de la forme DyT(x) = tanh(αx), née de l’observation que la Layer Normalization, dans les Transformers, produit souvent un mappage entrée-sortie en S similaire à tanh
• L’implémentation tient en quelques lignes de PyTorch, avec des paramètres apprenables alpha, weight et bias qui appliquent une mise à l’échelle et un biais à la sortie de tanh(alpha * x)
• L’évaluation couvre un large éventail de modèles de vision, langage, parole et modélisation de séquences ADN : ViT, ConvNeXt, MAE, DINO, DiT, LLaMA, wav2vec 2.0, HyenaDNA, Caduceus
• Sans réglage d’hyperparamètres supplémentaire, les résultats sont comparables ou meilleurs que ceux des variantes fondées sur la normalisation dans plusieurs configurations, ce qui remet en question l’idée qu’une couche de normalisation soit indispensable

---

Ce que Dynamic Tanh change

• DyT est une couche simple qui remplace Layer Norm ou RMSNorm dans les blocs Transformer
• L’opération centrale est DyT(x) = tanh(αx), appliquée élément par élément
• Cela montre qu’un Transformer sans couche de normalisation peut atteindre des performances comparables, voire supérieures, à celles d’un Transformer classique avec normalisation
• L’idée part de l’observation que la Layer Normalization dans les Transformers produit souvent une relation entrée-sortie proche d’une fonction tanh mise à l’échelle

Méthode d’implémentation

• Le module DyT peut être implémenté brièvement en PyTorch

class DyT(nn.Module):
    def __init__(self, num_features, alpha_init_value=0.5):
        super().__init__()
        self.alpha = nn.Parameter(torch.ones(1) * alpha_init_value)
        self.weight = nn.Parameter(torch.ones(num_features))
        self.bias = nn.Parameter(torch.zeros(num_features))

    def forward(self, x):
        x = torch.tanh(self.alpha * x)
        return x * self.weight + self.bias

• alpha est un paramètre apprenable, avec une valeur initiale fixée à 0.5
• weight et bias sont eux aussi des paramètres apprenables, appliqués à la sortie de tanh(alpha * x)

Observation issue de la Layer Normalization

• La Layer Normalization (LN) d’un Transformer génère un mappage entrée-sortie proche d’une fonction tanh mise à l’échelle
• Dans les premières couches, ce mappage reste globalement proche d’un comportement linéaire
• Plus on va en profondeur, plus la courbe en S caractéristique de tanh devient marquée
• Les observations incluent des couches LN sélectionnées de Vision Transformer (ViT), du modèle Transformer vocal wav2vec 2.0, et de Diffusion Transformer (DiT)

Portée de l’évaluation et résultats

• DyT a été évalué sur plusieurs architectures et tâches
  • Vision supervisée : ViT, ConvNeXt
  • Vision auto-supervisée : MAE, DINO
  • Modèles de diffusion : DiT
  • Grands modèles de langage : LLaMA
  • Parole auto-supervisée : wav2vec 2.0
  • Modélisation de séquences ADN : HyenaDNA, Caduceus
• Dans tous les cas, les Transformers utilisant DyT affichent des performances comparables ou supérieures à leurs équivalents fondés sur la normalisation
• Le champ d’évaluation est large : de la reconnaissance à la génération, du supervisé à l’auto-supervisé, de la vision par ordinateur aux modèles de langage

Références

• Download Paper: article contenant tous les détails de la recherche
• View on GitHub: dépôt pour consulter les détails de l’implémentation
• View Summary: bref résumé des résultats de la recherche
• Transformers without Normalization est accepté comme article de CVPR 2025

[GN⁺]

Avis sur Hacker News

• Si c’est vrai, c’est une assez bonne amélioration incrémentale. Cela ne semble pas augmenter significativement les performances des modèles, mais le coût de calcul est inférieur à celui de RMSNorm, utilisé par la plupart des LLM à l’état de l’art aujourd’hui, ce qui pourrait rendre l’entraînement plus rapide et moins coûteux.
  • Cela dit, RMSNorm ne représente qu’une assez faible part du calcul total dans un Transformer. En général, les opérations de réduction peuvent être fusionnées avec les opérations qui les précèdent ou les suivent.
  • Je viens de l’appliquer à mon benchmark personnel d’entraînement de Transformers, et les résultats sont très décevants. La convergence est bien plus lente qu’avec RMSNorm.
    Ajuster alpha n’a pas eu beaucoup d’effet, donc il faudra peut-être un réglage conséquent des hyperparamètres ou une initialisation plus sophistiquée. J’ai essayé à la fois l’initialisation par défaut de PyTorch et une initialisation orthogonale, sans différence.
    Ou bien l’optimiseur scalaire que j’utilise n’est peut-être pas adapté. J’utilise un optimiseur scalaire custom qui converge plus vite qu’Adam, mais sur les couches DyT il semblait seulement au niveau d’Adam.
    Ou alors c’est peut-être une approche qui ne rattrape son retard qu’après des dizaines de milliards de tokens, mais je n’ai pas le budget pour tester aussi longtemps.
• Avec des formats à faible précision comme float8, il faut généralement remonter les activations en BF16 avant la normalisation. Donc plus on descend en précision, plus la part de calcul occupée par les couches de normalisation augmente.
  Pouvoir remplacer ce type de couche aiderait à réduire assez fortement le coût de calcul.
• Il faudra que je lise les détails, mais la suppression de la normalisation peut être importante. Quand on essaie de nouvelles architectures, il est toujours pénible de faire en sorte que le réseau soit correctement normalisé.
  tanh aura sûrement aussi d’autres effets. La normalisation résout parfois des problèmes de conditionnement. Malgré tout, avoir davantage d’alternatives est une bonne chose.
• Alors, la disparition du gradient n’est plus un problème ?
  • Si les couches sont correctement initialisées, on peut maintenir la magnitude des gradients dans les réseaux profonds de façon qu’ils ne disparaissent ni n’explosent. Par exemple, si l’on règle la moyenne de la sortie de chaque couche à 0 et son écart-type à 1, les gradients restent eux aussi dans une plage raisonnable.
    Je recommande l’article original sur ResNet de Kaiming He et al., ainsi que les articles qui ont suivi.
    Pour une approche moderne des RNN, l’article de DeepMind https://arxiv.org/abs/2303.06349 vaut la peine d’être lu.
    L’essentiel est que la plus grande valeur propre, c’est-à-dire le rayon spectral, soit proche de 1. Cela signifie que l’application répétée d’une transformation linéaire ne fait ni croître ni décroître les activations.
  • ResNet a pratiquement résolu la disparition du gradient, à mon avis. L’explosion du gradient se traite généralement avec une bonne initialisation des paramètres et de la normalisation. Cet article propose en quelque sorte une alternative à la normalisation.
  • Bonne question. C’était un problème de l’époque où l’on utilisait tanh comme fonction d’activation, et avant les connexions résiduelles et les couches de normalisation. Utiliser tanh comme une normalisation avec d’autres fonctions d’activation et des connexions résiduelles en place me semble acceptable.
  • Comme on le voit sur le schéma, un Transformer apprend le résidu. C’est de la forme y = x + f(x).
• Je ne sais pas si je suis le seul à voir cela ainsi, mais les graphiques de l’article semblent comparer LNinput et LNoutput tout en ajoutant des poids et biais après tanh(a*x).
  Pour voir la similarité, il me semble qu’il faudrait comparer avec la sortie de LayerNorm une fois les poids et biais retirés.
  Si le résultat final est bon, peu importe, mais en isolant uniquement la partie effectivement remplacée, on comprendrait mieux ce qui se passe.
  • D’après l’implémentation, il semble appliquer les poids et biais après avoir calculé tanh.
• Concrètement, qu’est-ce que cela implique ?
  • D’après le résumé, avec DyT, des Transformers sans normalisation peuvent égaler ou dépasser les performances de leurs homologues normalisés, la plupart du temps sans réglage des hyperparamètres.