À l’intérieur d’un bloc de transformeur

Un bloc de transformeur est l’unité dont un modèle de langage est fait, et un modèle empile ce même bloc de nombreuses fois. Il contient une attention masquée à plusieurs têtes, puis un petit réseau pour chaque jeton. Des raccourcis et une remise à l’échelle entourent les deux.

Qui connaît un bloc connaît la forme du modèle entier.

Un modèle de langage apprend à deviner le jeton suivant. Si un jeton pouvait regarder les jetons d’après, il verrait la réponse.

Un masque causal laisse donc chaque jeton regarder seulement lui-même et les jetons d’avant. Un jeton plus loin reçoit un poids de 0. En pratique, son score passe à moins l’infini avant le softmax, car e puissance moins l’infini vaut 0.

import math

# scores[i][j] : à quel point la requête du jeton i correspond à la clé du jeton j.
scores = [[1, 2, 0], [2, 1, 1], [0, 1, 3]]

for i in range(3):
    puissances = []
    for j in range(3):
        if j <= i:
            puissances.append(math.exp(scores[i][j]))
        else:
            # Un jeton plus loin : masqué, il ne reçoit aucun poids.
            puissances.append(0)
    total = sum(puissances)
    poids = []
    for p in puissances:
        poids.append(round(p / total, 3))
    print("jeton", i, "poids", poids)
# Remplacez j <= i par True, pour ne rien masquer, puis cliquez sur Exécuter.
# Comment change la ligne du premier jeton, et pourquoi est-ce tricher ?

docker exec jupyter python3 -c "import numpy as np; S = np.array([[1, 2, 0], [2, 1, 1], [0, 1, 3]], dtype=float); S[np.triu(np.ones((3, 3), dtype=bool), 1)] = -np.inf; W = np.exp(S) / np.exp(S).sum(axis=1, keepdims=True); print(W.round(3).tolist())"

Une étape d’attention ne mélange que d’une seule façon. Un bloc fait donc tourner plusieurs têtes côte à côte, chacune avec ses propres tables de requête, clé et valeur.

Une tête peut relier un mot au mot d’avant. Une autre peut relier un adjectif au nom qu’il décrit. Leurs sorties sont mises bout à bout, puis une dernière table apprise les ramène à la longueur habituelle.

Après l’attention, chaque jeton passe seul dans une petite étape dense : deux couches avec ReLU entre elles, comme dans le module d’apprentissage profond.

Une connexion résiduelle ajoute l’entrée de chaque étape à sa sortie, si bien que rien de déjà connu ne se perd. La normalisation remet chaque vecteur à l’échelle : ses nombres ont une moyenne de 0 et un écart stable. Les deux gardent une pile profonde entraînable.

docker exec jupyter python3 -c "import numpy as np; x = np.array([2.0, 4.0, 6.0]); print(x.mean(), ((x - x.mean()) / x.std()).round(2).tolist())"