Mécanisme d'attention PyTorch
Le mécanisme d'attention est l'un des concepts les plus importants en apprentissage profond.
Le mécanisme d'attention permet aux modèles d'apprendre à « se concentrer sur » les parties les plus pertinentes de l'entrée, obtenant un grand succès dans des domaines tels que le traitement du langage naturel et la vision par ordinateur.
Cette section détaille les principes fondamentaux du mécanisme d'attention, les implémentations PyTorch et diverses variantes d'attention.
Version applicable :Le code de cet article est écrit sur la base de PyTorch 2.0+.
nn.MultiheadAttentiondebatch_firstLe paramètre a été introduit dans PyTorch 1.9 ; les versions antérieures nécessitent une gestion manuelle des dimensions.
1. Bases du mécanisme d'attention
1.1 Pourquoi l'attention est nécessaire
Les modèles traditionnels de séquence à séquence (Seq2Seq) ont un problème fondamental :L'encodeur doit compresser toutes les informations dans un vecteur de longueur fixe.Pour les longues séquences, ce vecteur devient un goulot d'étranglement informationnel—plus la phrase est longue, plus la perte d'information est importante.
L’idée centrale du mécanisme d’attention est de permettre au Decoder de « voir » tous les états cachés de l’Encoder lors de la génération de chaque sortie, et d’attribuer dynamiquement différents poids d’attention en fonction du contexte actuel. C’est comme un traducteur humain qui revient à la partie correspondante du texte source chaque fois qu’il traduit un mot.
1.2 L’essence du mécanisme d’attention
Le mécanisme d’attention peut être considéré comme une opération desomme pondérée. Étant donné une requête (Query), une clé (Key) et une valeur (Value), les poids sont attribués en calculant la similarité entre la Query et chaque Key, puis une somme pondérée des Values est calculée :
\[\text{Attention}(Q, K, V) = \text{softmax}\left(\frac{QK^T}{\sqrt{d_k}}\right)V\]$$
où :
- Q(Query): vecteur de requête, représentant « quelles informations je recherche »
- K(Key): vecteur de clé, indiquant « quelles informations je possède ici » (utilisé pour la correspondance)
- V(Value): vecteur de valeur, représentant « ce que je peux réellement fournir »
- $$d_k$$: dimension de Key, $$\sqrt{d_k}$$ est utilisé pour la mise à l’échelle afin d’éviter que les valeurs du produit scalaire ne soient trop grandes, ce qui entraînerait des gradients de softmax qui s’évanouissent
Pourquoi diviser par $$\sqrt{d_k}$$ ? Lorsque $$d_k$$ est grand, la variance du produit scalaire de Q et K croît linéairement avec la dimension, ce qui rend les valeurs d’entrée de softmax trop grandes et fait tendre les gradients vers zéro. Après mise à l’échelle, la variance est ramenée à 1, ce qui assure un flux de gradient normal.
Exemple
import torch.nn as nn
import torch.nn.functional as F
import math
def scaled_dot_product_attention(Q, K, V, mask=None):
"""
Attention par produit scalaire mise à l’échelle
Paramètres :
Q : tenseur Query [batch, n_heads, seq_len_q, d_k]
K : tenseur Key [batch, n_heads, seq_len_k, d_k]
V : tenseur des valeurs [batch, n_heads, seq_len_v, d_v]
mask : tenseur de masque ; les positions masquées sont définies à False/0
Retourne :
output : sortie de l’attention [batch, n_heads, seq_len_q, d_v]
attention_weights : poids d’attention [batch, n_heads, seq_len_q, seq_len_k]
"""
d_k = Q.size(-1)
# 1. Calculer QK^T / sqrt(d_k)
scores = torch.matmul(Q, K.transpose(-2, -1)) / math.sqrt(d_k)
# 2. Appliquer le masque (facultatif)
# Définir les positions masquées à une très petite valeur ; après softmax, elles tendent vers 0
if mask is not None:
scores = scores.masked_fill(mask == 0, -1e9)
# 3. Normalisation softmax → poids d’attention
attention_weights = F.softmax(scores, dim=-1)
# 4. Somme pondérée
output = torch.matmul(attention_weights, V)
return output, attention_weights
# Test
batch_size, n_heads = 2, 4
seq_len_q, seq_len_k = 5, 6
d_k, d_v = 8, 16
Q = torch.randn(batch_size, n_heads, seq_len_q, d_k)
K = torch.randn(batch_size, n_heads, seq_len_k, d_k)
V = torch.randn(batch_size, n_heads, seq_len_k, d_v)
output, attn_weights = scaled_dot_product_attention(Q, K, V)
print(f"Forme de sortie : {output.shape}") # [2, 4, 5, 16]
print(f"Forme des poids d'attention : {attn_weights.shape}") # [2, 4, 5, 6]
print(f"Somme de la ligne de poids (devrait être 1.0) : {attn_weights[0, 0, 0].sum().item():.4f}")
L'essence des poids d'attention est une distribution de probabilité—après softmax, chaque ligne vaut 1. Plus le poids est grand, plus le modèle « se concentre » sur cette position.
2. Module d'attention PyTorch
2.1 Attention multi-têtes
Attention multi-têtesElle permet au modèle de porter simultanément son attention sur des informations provenant de différents sous-espaces de représentation à différentes positions. Elle projette Q, K et V via différentes projections linéaires dans plusieurs sous-espaces, calcule l'attention indépendamment dans chaque sous-espace, puis concatène les résultats et applique une autre transformation linéaire.
C'est comme avoir plusieurs personnes qui examinent simultanément le même texte sous différents angles—certaines se concentrent sur la structure grammaticale, d'autres sur les relations sémantiques, et d'autres sur les dépendances à longue distance. Le mécanisme multi-têtes permet au modèle de capturer des motifs plus riches.
$$\text{MultiHead}(Q,K,V) = \text{Concat}(\text{head}_1, \dots, \text{head}_h)W^O$$
$$\text{où head}_i = \text{Attention}(QW_i^Q, KW_i^K, VW_i^V)$$
Exemple
import torch.nn as nn
import torch.nn.functional as F
import math
class MultiHeadAttention(nn.Module):
def __init__(self, d_model, n_heads, dropout=0.1):
super().__init__()
assert d_model % n_heads == 0, "d_model doit être divisible par n_heads"
self.d_model = d_model
self.n_heads = n_heads
self.d_k = d_model // n_heads # Dimension de chaque tête
# Projections linéaires pour Q, K, V (calculer toutes les têtes d'un coup, plus efficace)
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)
# Projection de sortie
self.w_o = nn.Linear(d_model, d_model)
self.dropout = nn.Dropout(dropout)
def forward(self, query, key, value, mask=None):
"""
Paramètres :
requête: [batch, seq_len_q, d_model]
clé: [batch, seq_len_k, d_model]
valeur: [batch, seq_len_k, d_model]
mask: [batch, 1, 1, seq_len_k] ou [batch, 1, seq_len_q, seq_len_k]
"""
batch_size = query.size(0)
# 1. Projection linéaire, puis séparation en têtes
# [batch, seq_len, d_model] → [batch, seq_len, n_heads, d_k]
# → [batch, n_heads, seq_len, d_k]
Q = self.w_q(query).view(batch_size, -1, self.n_heads, self.d_k).transpose(1, 2)
K = self.w_k(key).view(batch_size, -1, self.n_heads, self.d_k).transpose(1, 2)
V = self.w_v(value).view(batch_size, -1, self.n_heads, self.d_k).transpose(1, 2)
# 2. Attention par produit scalaire mise à l'échelle
scores = torch.matmul(Q, K.transpose(-2, -1)) / math.sqrt(self.d_k)
if mask is not None:
scores = scores.masked_fill(mask == 0, -1e9)
attn_weights = F.softmax(scores, dim=-1)
attn_weights = self.dropout(attn_weights)
# 3. Somme pondérée
context = torch.matmul(attn_weights, V)
# 4. Fusion des têtes: [batch, n_heads, seq_len, d_k] → [batch, seq_len, d_model]
context = context.transpose(1, 2).contiguous().view(batch_size, -1, self.d_model)
# 5. Projection de sortie
output = self.w_o(context)
return output, attn_weights
# Test
d_model, n_heads = 128, 8
seq_len, batch = 10, 4
layer = MultiHeadAttention(d_model, n_heads)
query = torch.randn(batch, seq_len, d_model)
key = torch.randn(batch, seq_len, d_model)
value = torch.randn(batch, seq_len, d_model)
output, attn_weights = layer(query, key, value)
print(f"Forme de sortie : {output.shape}") # [4, 10, 128]
print(f"Forme des poids d'attention : {attn_weights.shape}") # [4, 8, 10, 10]
print(f"Dimension de chaque tête d_k = {d_model // n_heads}")
2.2 MultiheadAttention intégré à PyTorch
PyTorch fournit une implémentation hautement optimiséenn.MultiheadAttention, qui utilise des kernels fusionnés au niveau sous-jacent et est plus rapide que les implémentations manuelles dans la plupart des scénarios. Il est recommandé de l'utiliser dans les environnements de production.
Exemple
import torch.nn as nn
class TransformerAttention(nn.Module):
"""Couche d'auto-attention utilisant le MultiheadAttention intégré à PyTorch"""
def __init__(self, d_model, n_heads, dropout=0.1):
super().__init__()
self.attention = nn.MultiheadAttention(
embed_dim=d_model,
num_heads=n_heads,
dropout=dropout,
batch_first=True, # Le format d'entrée est [batch, seq, features]
# PyTorch 2.0+ peut activer le backend Flash Attention :
# attn_implementation="flash_attention_2" # nécessite l'installation de flash-attn
)
self.layernorm = nn.LayerNorm(d_model)
def forward(self, x, key_padding_mask=None):
"""
Auto-attention : Q, K, V sont tous x
Paramètres :
x: [batch, seq_len, d_model]
key_padding_mask: [batch, seq_len], True indique que cette position correspond à du padding
"""
attn_output, attn_weights = self.attention(
x, x, x, # auto-attention
key_padding_mask=key_padding_mask
)
# Connexion résiduelle Pre-Norm (entraînement plus stable que Post-Norm)
output = self.layernorm(x + attn_output)
return output, attn_weights
# Test
d_model, n_heads = 128, 8
seq_len, batch = 10, 4
model = TransformerAttention(d_model, n_heads)
x = torch.randn(batch, seq_len, d_model)
# Créer un masque de padding : True indique que la position doit être ignorée
key_padding_mask = torch.zeros(batch, seq_len, dtype=torch.bool)
key_padding_mask[0, 7:] = True # Les 3 dernières positions du premier échantillon sont du padding
key_padding_mask[1, 5:] = True # Les 5 dernières positions du deuxième échantillon sont du padding
output, attn_weights = model(x, key_padding_mask=key_padding_mask)
print(f"Forme de sortie : {output.shape}") # [4, 10, 128]
print(f"Forme des poids d'attention : {attn_weights.shape}") # [4, 10, 10]
Notez les types de masques :
nn.MultiheadAttentiondekey_padding_maskLa conventionTrue = ignoreest utilisée, à l'opposé de la convention dans certaines implémentations personnalisées où 0 = ignore. Assurez-vous de confirmer lors de l'utilisation.
3. Variantes du mécanisme d'attention
3.1 Auto-attention
L'auto-attentionest une forme particulière du mécanisme d'attention — Q, K, V proviennent tous de la même séquence d'entrée. Elle permet à chaque position de la séquence de prêter directement attention à toutes les autres positions, capturant ainsi les dépendances globales. C'est le composant central du Transformer et la clé de son avantage sur les RNN : les RNN doivent transmettre l'information étape par étape, tandis que l'auto-attention le fait en une seule étape.
Exemple
import torch.nn as nn
import torch.nn.functional as F
import math
class SelfAttention(nn.Module):
"""Couche d'auto-attention multi-têtes, prend en charge le masque causal (pour la génération autorégressive)"""
def __init__(self, d_model, n_heads, dropout=0.1):
super().__init__()
assert d_model % n_heads == 0
self.d_model = d_model
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.out_proj = nn.Linear(d_model, d_model)
self.dropout = nn.Dropout(dropout)
def _split_heads(self, x, batch_size):
"""[batch, seq, d_model] → [batch, n_heads, seq, d_k]"""
return x.view(batch_size, -1, self.n_heads, self.d_k).transpose(1, 2)
def forward(self, x, causal=False):
"""
Auto-attention : Q, K, V proviennent tous de la même entrée x
Paramètres :
x: [batch, seq_len, d_model]
causal : indique s'il faut utiliser un masque causal (empêcher de voir les positions futures)
"""
batch_size, seq_len, _ = x.size()
# Projection + séparation en têtes
Q = self._split_heads(self.w_q(x), batch_size)
K = self._split_heads(self.w_k(x), batch_size)
V = self._split_heads(self.w_v(x), batch_size)
# Calculer les scores d'attention
scores = torch.matmul(Q, K.transpose(-2, -1)) / math.sqrt(self.d_k)
# Masque causal : mettre la matrice triangulaire supérieure à -inf pour empêcher de voir les jetons futurs
if causal:
causal_mask = torch.triu(
torch.ones(seq_len, seq_len, device=x.device, dtype=torch.bool),
diagonal=1
)
scores = scores.masked_fill(causal_mask.unsqueeze(0).unsqueeze(0), float('-inf'))
attn_weights = F.softmax(scores, dim=-1)
attn_weights = self.dropout(attn_weights)
# Somme pondérée + fusion des têtes
context = torch.matmul(attn_weights, V)
context = context.transpose(1, 2).contiguous().view(batch_size, seq_len, self.d_model)
return self.out_proj(context), attn_weights
# Test
d_model, n_heads = 256, 8
seq_len, batch = 20, 2
attn = SelfAttention(d_model, n_heads)
x = torch.randn(batch, seq_len, d_model)
# Sans masque causal (scénario encodeur)
output_enc, weights_enc = attn(x, causal=False)
print(f"[Encodeur] Sortie : {output_enc.shape}, poids : {weights_enc.shape}")
# Avec masque causal (scénario décodeur / génération autorégressive)
output_dec, weights_dec = attn(x, causal=True)
print(f"[Décodeur] Sortie : {output_dec.shape}, poids : {weights_dec.shape}")
# Vérifier la causalité : le premier token ne doit pas prêter attention aux tokens suivants
print(f"causal=True, weights[0,0,0,5:] (devrait être entièrement à 0) : {weights_dec[0, 0, 0, 5:].tolist()[:5]}")
3.2 Attention croisée
Dans l'attention croisée, Q provient d'une séquence (par exemple, le décodeur), tandis que K et V proviennent d'une autre séquence (par exemple, l'encodeur). C'est le pont de l'architecture encodeur-décodeur—il permet au décodeur de « rechercher » dynamiquement toutes les sorties de l'encodeur lors de la génération de chaque jeton.
Exemple
import torch.nn as nn
import torch.nn.functional as F
import math
class CrossAttention(nn.Module):
"""Attention croisée : Q provient de la séquence cible, K/V proviennent de la séquence source"""
def __init__(self, d_model, n_heads, dropout=0.1):
super().__init__()
assert d_model % n_heads == 0
self.d_model = d_model
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.out_proj = nn.Linear(d_model, d_model)
self.dropout = nn.Dropout(dropout)
def forward(self, target, source, mask=Aucune):
"""
Paramètres :
target: séquence cible [batch, target_len, d_model] → fournit Q
source: séquence source [batch, source_len, d_model] → fournit K, V
mask: masque optionnel
"""
batch_size = target.size(0)
target_len = target.size(1)
source_len = source.size(1)
# Projection + séparation en têtes
Q = self.w_q(target).view(batch_size, target_len, self.n_heads, self.d_k).transpose(1, 2)
K = self.w_k(source).view(batch_size, source_len, self.n_heads, self.d_k).transpose(1, 2)
V = self.w_v(source).view(batch_size, source_len, self.n_heads, self.d_k).transpose(1, 2)
# Calcul de l'attention
scores = torch.matmul(Q, K.transpose(-2, -1)) / math.sqrt(self.d_k)
if mask is not None:
scores = scores.masked_fill(mask == 0, float('-inf'))
attn_weights = F.softmax(scores, dim=-1)
attn_weights = self.dropout(attn_weights)
# Somme pondérée + fusion des têtes
context = torch.matmul(attn_weights, V)
context = context.transpose(1, 2).contiguous().view(batch_size, target_len, self.d_model)
return self.out_proj(context), attn_weights
# Test
d_model, n_heads = 256, 8
batch = 2
target_len, source_len = 10, 15
cross_attn = CrossAttention(d_model, n_heads)
target = torch.randn(batch, target_len, d_model) # Sortie du décodeur
source = torch.randn(batch, source_len, d_model) # Sortie de l'encodeur
output, weights = cross_attn(target, source)
print(f"Forme de la séquence cible : {target.shape}")
print(f"Forme de la séquence source : {source.shape}")
print(f"Forme de la sortie : {output.shape}") # [2, 10, 256]
print(f"Forme des poids : {weights.shape}") # [2, 8, 10, 15]
# Signification des poids : combien chaque position cible prête attention à chaque position source
Auto-attention vs. attention croisée :Dans l'auto-attention, Q/K/V ont la même forme (matrice de poids $$seq \times seq$$) ; dans l'attention croisée, la longueur de Q peut différer de celle de K (matrice de poids $$target \times source$$).
3.3 Encodage positionnel
Le mécanisme d'attention lui-même possèdel'invariance par permutation—mélanger l'ordre d'entrée ne change pas la sortie. Mais le langage et les images sont ordonnés, donc l'information positionnelle doit être injectée explicitement via l'encodage positionnel. Le Transformer original utilise des fonctions sinus/cosinus pour générer des encodages positionnels fixes :
$$PE_{(pos, 2i)} = \sin\left(\frac{pos}{10000^{2i/d_{model}}}\right), \quad PE_{(pos, 2i+1)} = \cos\left(\frac{pos}{10000^{2i/d_{model}}}\right)$$
Exemple
import torch.nn as nn
import math
class PositionalEncoding(nn.Module):
"""Encodage positionnel sinusoïdal (schéma original du Transformer)"""
def __init__(self, d_model, max_len=5000, dropout=0.1):
super().__init__()
self.dropout = nn.Dropout(p=dropout)
# Précalculer la matrice d'encodage positionnel [max_len, d_model]
pe = torch.zeros(max_len, d_model)
position = torch.arange(0, max_len, dtype=torch.float).unsqueeze(1)
# div_term : contrôle la vitesse de décroissance des différentes dimensions de fréquence
div_term = torch.exp(
torch.arange(0, d_model, 2).float() * (-math.log(10000.0) / d_model)
)
pe[:, 0::2] = torch.sin(position * div_term) # Dimensions paires
pe[:, 1::2] = torch.cos(position * div_term) # Dimensions impaires
pe = pe.unsqueeze(0) # [1, max_len, d_model]
self.register_buffer('pe', pe) # Non entraînable
def forward(self, x):
"""
x: [batch, seq_len, d_model]
Retour : x + positional_encoding
"""
x = x + self.pe[:, :x.size(1), :]
return self.dropout(x)
# Test
d_model = 128
seq_len = 50
batch = 4
pe = PositionalEncoding(d_model)
x = torch.randn(batch, seq_len, d_model)
output = pe(x)
print(f"Forme de l'entrée : {x.shape}")
print(f"Forme de sortie : {output.shape}")
print(f"Forme de l'encodage positionnel : {pe.pe.shape}") # [1, 5000, 128]
4. Applications visuelles du mécanisme d'attention
Les mécanismes d'attention ne s'appliquent pas uniquement aux données séquentielles, mais brillent aussi en vision par ordinateur. Ce qui suit présente trois modules d'attention visuelle classiques :
4.1 Attention de canal
L'attention de canal(par ex., SENet) permet au réseau d'apprendre « quels canaux sont plus importants ». Elle compresse l'information spatiale par un pooling global sur chaque canal, puis apprend les dépendances entre canaux via deux couches entièrement connectées.
Exemple
import torch.nn as nn
class SEBlock(nn.Module):
"""Bloc Squeeze-and-Excitation (attention de canal)"""
def __init__(self, channels, reduction=16):
super().__init__()
self.squeeze = nn.AdaptiveAvgPool2d(1) # Pooling moyen global
self.excitation = nn.Sequential(
nn.Linear(channels, channels // reduction, bias=False),
nn.ReLU(inplace=True),
nn.Linear(channels // reduction, channels, bias=False),
nn.Sigmoid() # Poids des canaux de sortie de 0 à 1
)
def forward(self, x):
# x : [batch, canaux, H, W]
b, c, _, _ = x.size()
# Squeeze : [B, C, H, W] → [B, C, 1, 1] → [B, C]
y = self.squeeze(x).view(b, c)
# Excitation : apprend les poids des canaux [B, C]
y = self.excitation(y).view(b, c, 1, 1)
# Pondération des canaux : multiplier chaque canal par son poids correspondant
return x * y.expand_as(x)
# Test
se = SEBlock(channels=256, reduction=16)
x = torch.randn(4, 256, 32, 32)
output = se(x)
print(f"Entrée : {x.shape} → Sortie : {output.shape}")
4.2 Attention spatiale
Attention spatialepermet au réseau d'apprendre "quelles positions sont plus importantes". Il compresse le long de la dimension des canaux (en prenant la moyenne et le maximum), puis utilise une convolution pour apprendre une carte de poids spatiale.
Exemple
import torch.nn as nn
class SpatialAttention(nn.Module):
"""Module d'attention spatiale"""
def __init__(self, kernel_size=7):
super().__init__()
padding = kernel_size // 2
# L'entrée a 2 canaux (moyenne + max), la sortie a 1 canal (carte d'attention)
self.conv = nn.Conv2d(2, 1, kernel_size, padding=padding, bias=False)
self.sigmoid = nn.Sigmoid()
def forward(self, x):
# x : [batch, canaux, H, W]
# Compression des canaux : prendre la moyenne et le max → un [B, 1, H, W] chacun
avg_out = torch.mean(x, dim=1, keepdim=True)
max_out, _ = torch.max(x, dim=1, keepdim=True)
# Concaténation → [B, 2, H, W]
scale = torch.cat([avg_out, max_out], dim=1)
# Convolution + Sigmoid → carte de poids spatiale [B, 1, H, W]
scale = self.sigmoid(self.conv(scale))
# Pondération spatiale
return x * scale
# Test
spatial_attn = SpatialAttention(kernel_size=7)
x = torch.randn(4, 256, 32, 32)
output = spatial_attn(x)
print(f"Entrée : {x.shape} → Sortie : {output.shape}")
4.3 CBAM (Module d'attention à blocs convolutifs)
CBAM applique l'attention de canal et l'attention spatiale ensérie: d'abord sélectionner les canaux importants via l'attention de canal, puis sélectionner les positions importantes via l'attention spatiale. Les deux sont complémentaires, et l'effet est meilleur que d'utiliser l'un ou l'autre seul.
Exemple
import torch.nn as nn
class CBAM(nn.Module):
"""CBAM : attention de canal + attention spatiale"""
def __init__(self, channels, reduction=16, kernel_size=7):
super().__init__()
# Attention de canal
self.channel_attn = nn.Sequential(
nn.AdaptiveAvgPool2d(1),
nn.Flatten(),
nn.Linear(channels, channels // reduction, bias=False),
nn.ReLU(inplace=True),
nn.Linear(channels // reduction, channels, bias=False),
nn.Sigmoid()
)
# Attention spatiale
self.spatial_attn = nn.Sequential(
nn.Conv2d(2, 1, kernel_size, padding=kernel_size // 2, bias=False),
nn.Sigmoid()
)
def forward(self, x):
# 1. Attention de canal
b, c, _, _ = x.size()
ca = self.channel_attn(x).view(b, c, 1, 1)
x = x * ca
# 2. Attention spatiale
avg_out = torch.mean(x, dim=1, keepdim=True)
max_out, _ = torch.max(x, dim=1, keepdim=True)
sa = self.spatial_attn(torch.cat([avg_out, max_out], dim=1))
x = x * sa
return x
# Test
cbam = CBAM(channels=256)
x = torch.randn(4, 256, 32, 32)
output = cbam(x)
print(f"Entrée : {x.shape} → Sortie : {output.shape}")
5. Applications du mécanisme d'attention en NLP
5.1 Encodeur Transformer
L'encodeur Transformer est composé de N couches identiques empilées, chacune contenant deux sous-couches :auto-attention multi-têtesetréseau à propagation avant. Chaque sous-couche utilise des connexions résiduelles et une normalisation de couche.
Exemple
import torch.nn as nn
import math
class TransformerEncoderLayer(nn.Module):
"""Couche unique d'encodeur Transformer"""
def __init__(self, d_model, n_heads, d_ff, dropout=0.1):
super().__init__()
# Auto-attention multi-têtes
self.self_attn = nn.MultiheadAttention(
d_model, n_heads, dropout=dropout, batch_first=True
)
# Réseau à propagation avant (deux couches linéaires + activation)
self.ffn = nn.Sequential(
nn.Linear(d_model, d_ff),
nn.GELU(), # GELU est plus couramment utilisé que ReLU
nn.Dropout(dropout),
nn.Linear(d_ff, d_model)
)
# Normalisation de couche (style Pre-Norm, entraînement plus stable)
self.norm1 = nn.LayerNorm(d_model)
self.norm2 = nn.LayerNorm(d_model)
self.dropout = nn.Dropout(dropout)
def forward(self, x, key_padding_mask=None):
# Sous-couche 1 : Auto-attention
residual = x
x = self.norm1(x) # Pré-Norme
attn_out, _ = self.self_attn(x, x, x, key_padding_mask=key_padding_mask)
x = residual + self.dropout(attn_out)
# Sous-couche 2 : Réseau feed-forward
residual = x
x = self.norm2(x) # Pré-Norme
x = residual + self.dropout(self.ffn(x))
return x
class TransformerEncoder(nn.Module):
"""Encodeur Transformer multicouche"""
def __init__(self, d_model, n_heads, d_ff, num_layers, dropout=0.1):
super().__init__()
self.layers = nn.ModuleList([
TransformerEncoderLayer(d_model, n_heads, d_ff, dropout)
for _ in range(num_layers)
])
self.final_norm = nn.LayerNorm(d_model)
def forward(self, x, key_padding_mask=None):
for layer in self.layers:
x = layer(x, key_padding_mask)
return self.final_norm(x)
# Test
d_model, n_heads, d_ff = 128, 4, 512
num_layers, seq_len, batch = 3, 20, 4
encoder = TransformerEncoder(d_model, n_heads, d_ff, num_layers)
x = torch.randn(batch, seq_len, d_model)
# Masque de padding : True = ignorer cette position
key_padding_mask = torch.zeros(batch, seq_len, dtype=torch.bool)
key_padding_mask[0, 15:] = True
output = encoder(x, key_padding_mask=key_padding_mask)
print(f"Entrée : {x.shape} → Sortie : {output.shape}")
5.2 Visualisation de l'attention
La visualisation des poids d'attention est un moyen important de comprendre et de déboguer les modèles Transformer. Grâce aux cartes de chaleur, vous pouvez voir intuitivement à quelles informations le modèle prête attention à chaque position.
Exemple
import matplotlib.pyplot as plt
import numpy as np
def visualize_attention(attention_weights, tokens=None, save_path=Aucune):
"""
Visualisation des poids d'attention multi-têtes
Paramètres :
attention_weights: [n_heads, seq_len, seq_len]
tokens: liste de tokens (facultatif)
save_path: chemin de sauvegarde (facultatif)
"""
n_heads = attention_weights.shape[0]
seq_len = attention_weights.shape[1]
fig, axes = plt.subplots(1, n_heads, figsize=(n_heads * 3, 3.5))
if n_heads == 1:
axes = [axes]
for head in range(n_heads):
ax = axes[head]
attn = attention_weights[head].detach().cpu().numpy()
im = ax.imshow(attn, cmap='Blues', aspect='auto', vmin=0, vmax=attn.max())
ax.set_title(f'Tête {head + 1}', fontsize=10, fontweight='bold')
ax.set_xlabel('Clé')
ax.set_ylabel('Requête')
if tokens is not None:
ax.set_xticks(range(len(tokens)))
ax.set_yticks(range(len(tokens)))
ax.set_xticklabels(tokens, rotation=90, fontsize=8)
ax.set_yticklabels(tokens, fontsize=8)
plt.tight_layout()
if save_path:
plt.savefig(save_path, dpi=150, bbox_inches='tight')
plt.show()
# Poids d'attention simulés après entraînement
n_heads, seq_len = 4, 8
attention_weights = torch.softmax(torch.randn(n_heads, seq_len, seq_len), dim=-1)
tokens = ['The', 'cat', 'sat', 'sur', 'le', 'tapis', '.', '[PAD]']
visualize_attention(attention_weights, tokens)
6. Classificateur d'attention complet
6.1 Classification de texte basée sur l'attention
Ce qui suit est un modèle complet de classification de texte : il utilise un encodeur Transformer pour extraire des caractéristiques, puis compresse des séquences de longueur variable en vecteurs de longueur fixe via un pooling par attention, et les fournit enfin à un classificateur.
Exemple
import torch.nn as nn
import math
class AttentionClassifier(nn.Module):
"""Modèle de classification de texte basé sur Transformer + pooling par attention"""
def __init__(self, vocab_size, embed_dim, hidden_dim, num_classes,
n_heads=4, num_layers=2, dropout=0.1):
super().__init__()
self.embed_dim = embed_dim
# Plongement de mots
self.embedding = nn.Embedding(vocab_size, embed_dim, padding_idx=0)
self.pos_encoding = PositionalEncoding(embed_dim, dropout=dropout)
# Encodeur Transformer
encoder_layer = nn.TransformerEncoderLayer(
d_model=embed_dim,
nhead=n_heads,
dim_feedforward=hidden_dim,
dropout=dropout,
batch_first=True,
activation='gelu'
)
self.transformer = nn.TransformerEncoder(encoder_layer, num_layers)
# Pooling d'attention : apprendre des poids d'importance pour chaque position
self.attn_pool = nn.Sequential(
nn.Linear(embed_dim, 1) # Produire un poids scalaire pour chaque position
)
# Tête de classification
self.classifier = nn.Sequential(
nn.Linear(embed_dim, hidden_dim),
nn.GELU(),
nn.Dropout(dropout),
nn.Linear(hidden_dim, num_classes)
)
def forward(self, x):
"""
x: [batch, seq_len] — identifiants de tokens
Renvoie : logits [batch, num_classes], attn_weights [batch, seq_len]
"""
# Plongement de mots + encodage positionnel
mask = (x == 0) # masque de remplissage
x = self.embedding(x) * math.sqrt(self.embed_dim)
x = self.pos_encoding(x)
# Encodage Transformer
x = self.transformer(x, src_key_padding_mask=mask)
# Agrégation par attention : calculer les poids pour chaque position, somme pondérée
scores = self.attn_pool(x).squeeze(-1) # [batch, seq_len]
scores = scores.masked_fill(mask, float('-inf')) # Ignorer le padding
attn_weights = torch.softmax(scores, dim=1) # [batch, seq_len]
pooled = torch.bmm(attn_weights.unsqueeze(1), x).squeeze(1) # [batch, embed_dim]
# Classification
logits = self.classifier(pooled)
return logits, attn_weights
# Test
model = AttentionClassifier(
vocab_size=10000, embed_dim=128, hidden_dim=256, num_classes=5
)
# Entrée simulée (avec padding)
x = torch.randint(1, 10000, (16, 50))
x[:, -10:] = 0 # Les 10 dernières positions sont du padding
logits, attn_weights = model(x)
print(f"Entrée: {x.shape}")
print(f"Logits: {logits.shape}") # [16, 5]
print(f"Poids d'attention: {attn_weights.shape}") # [16, 50]
6.2 Comparaison des variantes d'attention courantes
| Type | Source de Q | Source de K/V | Utilisation principale | Application typique |
|---|---|---|---|---|
| Auto-attention | Soi-même | Soi-même | Interaction globale au sein d'une séquence | Transformer、BERT、ViT |
| Attention croisée | Séquence cible | Séquence source | Fusion d'informations entre séquences | Traduction automatique, légendage d'images, Stable Diffusion |
| Attention de canal | Caractéristiques globales agrégées | Comme ci-dessus | Apprendre l'importance des canaux | SENet、CBAM |
| Attention spatiale | Caractéristiques compressées par canal | Comme ci-dessus | Apprendre l'importance de la position spatiale | CBAM、Spatial Transformer |
| Attention parcimonieuse | Positions partielles | Positions partielles | Réduire la complexité computationnelle pour les longues séquences | Longformer、BigBird |
7. Bonnes pratiques et problèmes courants
7.1 Conseils d'utilisation
- Cohérence des masques: Assurez-vous que le masque de remplissage et le masque causal ont une direction cohérente (True = ignorer vs 1 = conserver). Les conventions d'API peuvent différer.
- Sélection du nombre de têtes: Généralement défini comme un diviseur de $$d_{model}$$, souvent 8 ou 16. Trop de têtes réduisent la dimension par tête $$d_k$$, ce qui peut nuire aux performances.
- Connexion résiduelle: Assurez-vous d'utiliser des connexions résiduelles + une normalisation de couche avant et après les couches d'attention ; c'est une condition nécessaire pour entraîner des Transformers profonds.
- Échauffement du taux d'apprentissage: Les fluctuations de gradient sont importantes au début de l'entraînement d'un Transformer ; utiliser un planificateur d'échauffement + décroissance cosinus peut considérablement améliorer la stabilité.
- Flash Attention: PyTorch 2.0+ prend en charge via
nn.functional.scaled_dot_product_attentionl'invocation automatique de Flash Attention, optimisant considérablement à la fois l'utilisation de la mémoire et la vitesse.
7.2 Problèmes courants
| Problème | Cause | Solution |
|---|---|---|
| Les poids d'attention sont tous uniformément distribués | Entrée non normalisée ou taux d'apprentissage trop élevé | Vérifier l'échelle d'entrée, utiliser LayerNorm, réduire le taux d'apprentissage |
| La perte d'entraînement ne diminue pas | Encodage positionnel manquant ou masque incorrect | Confirmer que l'encodage positionnel est ajouté, vérifier la direction du masque |
| Mémoire insuffisante (séquences longues) | La matrice d'attention a une complexité $$O(n^2)$$ | Utiliser Flash Attention, le checkpointing de gradient ou l'attention éparse |
| Dégradation de l'attention lors de l'inférence | Masque incohérent entre l'entraînement et l'inférence | Assurez-vous que le masque de remplissage utilise la même logique pendant l'entraînement et l'inférence |
Autres extensionsLe mécanisme d'attention est une technologie fondamentale de l'apprentissage profond moderne. Du traitement du langage naturel à la vision par ordinateur, de la parole à la prédiction de la structure des protéines, presque tous les modèles de pointe sont basés sur l'attention. Comprendre ses principes et sa mise en œuvre est la première étape clé pour maîtriser des modèles tels que Transformer, ViT, Stable Diffusion et GPT.