Programme Leçon 107 sur 250 · L'intuition des réseaux de neurones, les LLM et le projet final IA
L'intuition des réseaux de neurones, les LLM et le projet final IA

L'auto-attention à partir de zéro

Tu as construit un neurone et une passe avant. Maintenant, tu vas construire l'idée qui a transformé les simples réseaux de neurones en transformers et, de là, en LLM derrière chaque assistant de discussion : l'auto-attention (self-attention). C'est une poignée de multiplications de matrices, et tu peux tout faire en numpy.

L'intuition

Imagine que chaque mot d'une phrase veut récupérer des informations des autres mots. L'auto-attention donne trois vecteurs à chaque position :

  • Une requête (query, Q) : ce que cette position cherche.
  • Une clé (key, K) : ce que chaque position offre, utilisé pour la correspondance.
  • Une valeur (value, V) : l'information réelle que porte chaque position.

Une position compare sa requête à chaque clé pour décider à quel point écouter chaque autre position, puis prend un mélange pondéré des valeurs avec ces quantités. Forte correspondance -> gros poids -> cette valeur contribue davantage. C'est tout le mécanisme : les requêtes s'intéressent aux clés, et la réponse est un mélange pondéré des valeurs.

Les maths : l'attention par produit scalaire mis à l'échelle

Le score de correspondance entre une requête et une clé est leur produit scalaire (plus grand quand elles pointent dans le même sens). Empile toutes les requêtes dans une matrice Q et toutes les clés dans K, et tous les scores d'un coup valent Q @ K.T. On divise par sqrt(d_k) (la dimension des clés) pour que les scores n'explosent pas quand les vecteurs s'allongent :

scores = Q @ K.T / np.sqrt(d_k)

Pourquoi diviser ? Un produit scalaire grandit avec la dimension. Si d_k vaut 64 et que les valeurs tournent autour de 1, les scores bruts tombent près de 64, et des nombres aussi grands poussent le softmax sur une seule clé et aplatissent le gradient. Diviser par sqrt(d_k), ici sqrt(64) = 8, ramène les scores dans une plage raisonnable pour que l'attention reste douce et entraînable. Dans le tout petit exemple d_k = 1 que tu lances ci-dessous, le diviseur vaut juste 1, donc tu ne verras pas son effet, mais aux tailles de vrais modèles il est essentiel.

Chaque ligne de scores contient les scores d'une requête face à chaque clé. On transforme chaque ligne en poids positifs qui font 1 au total avec un softmax sur le dernier axe :

weights = softmax(scores, axis=-1)   # each row sums to 1

Le softmax passe à l'exponentielle puis normalise. Fait naïvement, np.exp d'un grand score déborde vers inf et les poids sortent en nan. La solution est l'astuce standard numériquement stable : soustraire le max de chaque ligne avant l'exponentielle. Ça ne change pas le résultat mathématiquement (la même constante s'annule en haut et en bas), mais ça garde chaque exposant <= 0 :

def softmax(x):
    x = x - x.max(axis=-1, keepdims=True)   # stability: largest exponent is now 0
    e = np.exp(x)
    return e / e.sum(axis=-1, keepdims=True)

Enfin, la sortie de chaque requête est ses poids appliqués aux valeurs, une multiplication de matrices de plus :

output = weights @ V

Mis bout à bout, la fameuse formule est juste softmax(Q @ K.T / sqrt(d_k)) @ V. Si Q a la forme (n, d_k), K la forme (m, d_k) et V la forme (m, d_v), alors weights a la forme (n, m) et output la forme (n, d_v) : un vecteur de sortie par requête, chacun un mélange des lignes de valeurs.

C'est toute l'astuce du transformer

Un vrai transformer ne s'arrête pas à un seul calcul d'attention. L'attention multi-têtes en fait tourner plusieurs en parallèle (chaque tête apprend ses propres projections Q, K, V, donc différentes têtes s'intéressent à différentes choses) et concatène les résultats. Un bloc de transformer empile ensuite l'attention avec un petit réseau feed-forward et une connexion résiduelle, et un modèle empile des dizaines de ces blocs. Mais le cœur battant de chacun est exactement la fonction que tu vas écrire : scores, softmax stable, somme pondérée des valeurs. Construis-la et tu comprends l'opération centrale qu'un LLM répète quand il "fait attention" au prompt.

Une précision honnête : ici, Q, K et V te sont donnés comme des tableaux fixes. Dans un vrai modèle, ils ne sont pas donnés, ils sont produits en multipliant l'embedding de chaque token par trois matrices de poids apprises, W_q, W_k et W_v. Ces matrices, et celles de chaque bloc, sont exactement ce que l'entraînement ajuste avec la descente de gradient de la leçon précédente. Ce que tu construis ici est donc le cœur fixe de l'attention, identique dans tout transformer ; l'apprentissage vit dans les projections qui l'alimentent.

Appuie sur Run pour voir l'attention transformer un tout petit Q/K/V en sortie et afficher la matrice des poids, pour lire qui a fait attention à qui.

À ton tour

Code l'attention par produit scalaire mis à l'échelle en numpy. Écris attention(Q, K, V) qui renvoie un tuple (output, weights). Calcule scores = Q @ K.T / np.sqrt(d_k) où d_k est la dernière dimension de Q ; applique un softmax numériquement stable sur le dernier axe (soustrais le max de chaque ligne avant np.exp) pour obtenir weights, dont les lignes font 1 au total ; puis output = weights @ V. Renvoie output d'abord, puis la matrice weights. Puis écris out, w = attention(Q, K, V) pour les tableaux fournis.

Tu as repéré un problème dans cette leçon ? Signale-le · Pose une question sur cette leçon

Cet exercice s'ouvre bientôt

Termine la leçon précédente pour débloquer celle-ci. Tout le cours est gratuit, aucun compte n'est requis, et tu peux lire cette leçon dès maintenant.