Comment la normalisation de couche stabilise les transformateurs
Glissez pour afficher le menu
Les modèles modernes d'apprentissage profond reposent sur des techniques de normalisation pour faciliter un entraînement efficace et précis. En traitement du langage naturel (NLP), où les séquences d'entrée peuvent varier en longueur et en structure, la normalisation est particulièrement importante pour stabiliser le processus d'apprentissage. Deux méthodes courantes de normalisation sont la normalisation par lot et la normalisation par couche, mais elles remplissent des fonctions différentes et sont adaptées à différents types de données.
La normalisation par lot calcule la moyenne et la variance de chaque caractéristique sur l'ensemble du lot d'entrées. Cette approche fonctionne bien pour les tâches de vision par ordinateur, où chaque image d'un lot est généralement de même taille et structure. Cependant, dans les tâches de NLP, en particulier avec des séquences de longueur variable, la normalisation par lot peut introduire des dépendances indésirables entre les échantillons d'un lot et peut ne pas gérer correctement les longueurs de séquence variables.
La normalisation par couche, en revanche, normalise les caractéristiques d'entrée au sein de chaque point de données (comme chaque représentation de jeton dans une phrase) indépendamment des autres points de données du lot. Cela la rend beaucoup plus adaptée au NLP et à la modélisation de séquences. En standardisant les entrées sommées d'un neurone au sein d'une couche, la normalisation par couche garantit que la représentation de chaque jeton est sur une échelle similaire, quel que soit sa position ou la composition du lot. Cela aide les Transformers à s'entraîner de manière stable et à représenter le texte plus efficacement, en particulier lorsqu'ils traitent des phrases longues ou complexes.
123456789101112131415161718192021import numpy as np def layer_norm(x, epsilon=1e-5): """ Applies layer normalization to a 2D numpy array x. Each row is normalized independently. """ mean = np.mean(x, axis=1, keepdims=True) variance = np.var(x, axis=1, keepdims=True) normalized = (x - mean) / np.sqrt(variance + epsilon) # Optional: learnable scale and bias (gamma and beta) gamma = np.ones_like(mean) beta = np.zeros_like(mean) return gamma * normalized + beta # Example: normalize a batch of 3 token embeddings (rows) embeddings = np.array([[2.0, 4.0, 6.0], [1.0, 3.0, 5.0], [0.0, 0.0, 0.0]]) normalized_embeddings = layer_norm(embeddings) print(normalized_embeddings)
Imaginez chaque ligne de votre entrée comme une représentation de jeton unique – à l'image d'un personnage dans une histoire, chacun avec ses propres particularités. La fonction layer_norm donne à chaque jeton une chance équitable en ajustant ses valeurs pour qu'elles soient centrées autour de zéro et partagent la même échelle. Elle calcule la moyenne et la variance pour chaque ligne, puis transforme les valeurs afin qu'aucun jeton ne se distingue excessivement ou ne disparaisse en arrière-plan. Cette normalisation indépendante signifie que, quelle que soit la longueur de la séquence ou la composition du lot, les caractéristiques de chaque jeton sont équilibrées et prêtes à être interprétées par le modèle. Cette approche assure la stabilité et l'efficacité de l'entraînement du modèle, en particulier lors du traitement de longueurs et de structures imprévisibles dans les données NLP réelles.
Merci pour vos commentaires !
Demandez à l'IA
Demandez à l'IA
Posez n'importe quelle question ou essayez l'une des questions suggérées pour commencer notre discussion
