Deep Learningavancé

Transformers & Auto-Attention

“Chaque mot s'adresse directement à chaque autre mot — attention portée à toute la phrase à la fois”

Plongée dans l'attention : dot-product scalé, multi-têtes, encodage positionnel, FFN, sampling (température/top-k/top-p), BERT vs GPT.

90 min

9 diagrammes

7 Concepts Couverts

Prérequis

→RNN / LSTM

→NLP Text Classification

Concepts Couverts

Scaled Dot-ProductMulti-head AttentionPositional EncodingFFNBERTGPTTop-p Sampling

Précédent: NLP : Pipeline de Classification de Texte Suivant: Audio & Reconnaissance Vocale ML

∑Formules Clés

Produit Scalaire Mis à l'Échelle

Attention centrale : dans quelle mesure chaque requête s'attache à chaque clé — mise à l'échelle par √d_k pour la stabilité

Multi-Tête

H fonctions d'attention parallèles jointes et projetées — chaque tête capture un aspect différent des relations

Encodage Positionnel

Injecte les informations de position du token (sans récurrence) — motifs sin/cos à différentes fréquences

Sous-couche FFN

Feed-forward positionnel après chaque bloc d'attention — projette dans une dimension plus grande puis réduit

▶Simulation Interactive

Loading visualization…

⬡Architecture du Modèle

Loading visualization…

🎯

Le Problème des RNN que les Transformers ont Résolu

motivation

Les RNN traitent les séquences jeton par jeton — pour comprendre la relation entre le mot 1 et le mot 500, l'information doit traverser 499 états intermédiaires, chacun pouvant la corrompre (gradient évanescent). Les Transformers résolvent cela en permettant à n'importe quelle position d'assister directement à n'importe quelle autre en une seule étape. Ce chemin direct, combiné au calcul parallèle, explique pourquoi les Transformers ont remplacé les RNN pour presque tout.

💡

L'Attention comme Requête Douce de Base de Données

intuition

Pensez à l'attention comme un magasin clé-valeur différentiable. Vous avez une Requête (ce que vous cherchez), des Clés (descripteurs de chaque mémoire) et des Valeurs (le contenu réel). L'attention calcule la similarité entre la Requête et toutes les Clés, applique softmax pour obtenir une distribution de probabilité, puis renvoie une somme pondérée des Valeurs. Le mot 'banque' dans 'bord de rivière' assistera fortement à 'rivière' et récupérera sa représentation contextuelle.

La mise à l'échelle par √d_k empêche les produits scalaires de devenir grands (ce qui rendrait le softmax extrêmement pointu, tuant le flux de gradient à travers la distribution).

∑

Attention Multi-Têtes : Pourquoi Plusieurs Têtes ?

math

Une seule tête d'attention ne peut assister que selon un critère (ex: accord syntaxique sujet-verbe). Les têtes multiples apprennent différents schémas d'attention simultanément : tête 1 syntaxe, tête 2 sémantique, tête 3 coréférence. Chaque tête projette Q, K, V dans un sous-espace de plus faible dimension, calcule l'attention, puis toutes les têtes sont concaténées et projetées en retour.

Chaque tête utilise ses propres matrices de projection apprises

🔬

BERT vs GPT : Encodeur vs Décodeur

deepdive

BERT utilise une attention bidirectionnelle — chaque jeton assiste à tous les autres. Idéal pour la compréhension (classification, NER, QA) mais ne peut pas générer du texte de gauche à droite. GPT utilise une attention masquée (causale) — chaque jeton n'assiste qu'aux jetons précédents. Cela permet la génération autoregresssive. Le masque est une matrice triangulaire inférieure de valeurs -inf ajoutées avant softmax.

Masque causal (empêche d'assister aux jetons futurs)

⚙️

Bloc Encodeur du Transformer

algorithm

Embeddings d'entrée E = embed_jeton + encodage_positionnel

Auto-Attention Multi-Têtes : Q=EW_Q, K=EW_K, V=EW_V

Attention(Q,K,V) = softmax(QKᵀ/√d_k)V

Ajouter & Normaliser : x₁ = NormCouche(E + Attention(E))

Réseau de propagation avant : FFN(x₁) = ReLU(x₁W₁ + b₁)W₂ + b₂

Ajouter & Normaliser : x₂ = NormCouche(x₁ + FFN(x₁))

Répéter pour L couches

</>

Attention Produit Scalaire Mis à l'Échelle de Zéro

code

python39 lines

import torch
import torch.nn.functional as F
import math

def attention_produit_scalaire(Q, K, V, masque=None):
    class="tok-str">"""
    Q, K, V : (lot, tetes, longueur_seq, d_k)
    """
    d_k = Q.shape[-class="tok-num">1]
    class="tok-comment"># Scores dclass="tok-str">'attention
    scores = torch.matmul(Q, K.transpose(-class="tok-num">2, -class="tok-num">1)) / math.sqrt(d_k)
    class="tok-comment"># Masque causal (style GPT)
    if masque is not None:
        scores = scores.masked_fill(masque == class="tok-num">0, float('-inf'))
    class="tok-comment"># Softmax sur la dimension des clés
    poids_attn = F.softmax(scores, dim=-class="tok-num">1)
    class="tok-comment"># Somme pondérée des valeurs
    return torch.matmul(poids_attn, V), poids_attn

class AttentionMultiTetes(torch.nn.Module):
    def __init__(self, d_modele, n_tetes):
        super().__init__()
        self.d_k = d_modele // n_tetes
        self.n_tetes = n_tetes
        self.W_q = torch.nn.Linear(d_modele, d_modele)
        self.W_k = torch.nn.Linear(d_modele, d_modele)
        self.W_v = torch.nn.Linear(d_modele, d_modele)
        self.W_o = torch.nn.Linear(d_modele, d_modele)

    def forward(self, Q, K, V, masque=None):
        B, T, D = Q.shape
        class="tok-comment"># Projeter + diviser en têtes
        Q = self.W_q(Q).view(B, T, self.n_tetes, self.d_k).transpose(class="tok-num">1, class="tok-num">2)
        K = self.W_k(K).view(B, T, self.n_tetes, self.d_k).transpose(class="tok-num">1, class="tok-num">2)
        V = self.W_v(V).view(B, T, self.n_tetes, self.d_k).transpose(class="tok-num">1, class="tok-num">2)
        x, poids = attention_produit_scalaire(Q, K, V, masque)
        class="tok-comment"># Concaténer les têtes + projeter
        x = x.transpose(class="tok-num">1, class="tok-num">2).contiguous().view(B, T, D)
        return self.W_o(x), poids

?Vérification des Connaissances

La progression est sauvegardée dans votre navigateur — aucun compte requis.

NLP : Pipeline de Classification de Texte

Audio & Reconnaissance Vocale ML

Besoin d'un ingénieur IA ou data scientist ?

Je conçois des modèles ML sur mesure, des agents IA, de la vision par ordinateur et de l'automatisation — de l'idée à la production.

Me contacter Voir les services