Multi-Head Attention

Définition

Le Multi-Head Attention (attention multi-têtes) est le composant central de l'architecture Transformer, introduit dans le paper fondateur "Attention Is All You Need" (Vaswani et al., 2017). Ce mécanisme permet au modèle d'apprendre simultanément plusieurs types de relations entre les tokens d'une séquence, en exécutant plusieurs opérations d'attention en parallèle, chacune dans un sous-espace de représentation différent. L'idée fondamentale est que différentes "têtes" d'attention peuvent se spécialiser : l'une peut capturer des relations syntaxiques (sujet-verbe), une autre des coréférences (pronoms → entités), une troisième des dépendances sémantiques longue distance. Cette parallélisation de points de vue enrichit considérablement la représentation contextuelle de chaque token. Dans un Transformer standard, le Multi-Head Attention opère en h têtes parallèles (souvent 8, 12, 16 ou 32 selon la taille du modèle). Chaque tête projette les vecteurs d'entrée dans des espaces de dimension réduite (d_model/h), applique une attention scaled dot-product, puis les sorties sont concaténées et reprojectées dans l'espace d'origine. Pour les LLMs modernes comme GPT-4, Claude ou Llama, le Multi-Head Attention est implémenté avec des optimisations comme Flash Attention (pour l'efficacité mémoire), Grouped Query Attention (pour réduire le coût du KV-Cache), ou Multi-Query Attention. Ces variantes réduisent la complexité quadratique O(n²) inhérente à l'attention standard, permettant de traiter des contextes de plus en plus longs (jusqu'à 1M tokens). La compréhension du Multi-Head Attention est essentielle pour optimiser les LLMs en production : le nombre de têtes influence directement la taille du KV-Cache, le temps d'inférence et la consommation mémoire GPU.

Fonctionnement technique

Chaque tête i applique trois projections linéaires distinctes sur l'entrée X : W_i^Q (queries), W_i^K (keys), W_i^V (values). L'attention scalée est calculée par : head_i = softmax(QK^T / √d_k)V. Les h têtes sont ensuite concaténées et multipliées par W^O pour obtenir la sortie finale.

La complexité spatiale est O(n² × d_model) pour stocker les scores d'attention, ce qui explique le coût exponentiel des très longs contextes. Flash Attention remédie à cela par un calcul en blocs sur GPU (tiling), évitant de matérialiser la matrice complète.

Variantes modernes

Grouped Query Attention (GQA) : plusieurs têtes de queries partagent les mêmes têtes de keys/values → réduit le KV-Cache de 8× (Llama 3, Gemma 2)
Multi-Query Attention (MQA) : une seule tête K/V pour toutes les têtes Q → encore plus rapide mais moins expressif
Sliding Window Attention : chaque token n'attend que ses n voisins → O(n) au lieu de O(n²)

Ressources et outils

# Implémentation PyTorch simplifiée
import torch
import torch.nn as nn

class MultiHeadAttention(nn.Module):
    def __init__(self, d_model=512, n_heads=8):
        super().__init__()
        self.n_heads = n_heads
        self.d_k = d_model // n_heads
        self.W_q = nn.Linear(d_model, d_model)
        self.W_k = nn.Linear(d_model, d_model)
        self.W_v = nn.Linear(d_model, d_model)
        self.W_o = nn.Linear(d_model, d_model)

Papers : "Attention Is All You Need" (2017), "GQA: Training Generalized Multi-Query Transformer Models" (2023), "FlashAttention-2" (2023).

Articles liés

Expert en cybersécurité offensive et intelligence artificielle. Pentest, audit et développement IA sur-mesure.

Services

Ressources

Projets & Outils

Contact

Nous contacter

Mentions légales Confidentialité Politique éditoriale Plan du site ⭐ Source préférée

Un projet cybersécurité ?

Expert dispo · Réponse 24h

Devis