Construire un LLM.

Un token est une unité de texte. Ici, un caractère Unicode normalisé = un token. Les modèles du livre utilisent ensuite une tokenisation BPE, où un token peut contenir plusieurs caractères. Le vocabulaire est construit sur le corpus entier ; seuls les 80 % initiaux servent aux mises à jour.

chars = sorted(set(text))
stoi = {c: i for i, c in enumerate(chars)}
ids = [stoi[c] for c in text]
assert ''.join(chars[i] for i in ids) == text

Le contexte est le nombre maximal de tokens lus à la fois. Les cibles sont la même séquence décalée d’un token. On sépare entraînement et validation avant de créer les fenêtres : aucune ne traverse cette frontière. La validation mesure la prédiction sur du texte réservé, pas la compréhension.

train, validation = ids[:split], ids[split:]
x = train[start:start + context]
y = train[start + 1:start + context + 1]
assert x[1:] == y[:-1]

Les requêtes Q et les clés K produisent des scores de proximité. On masque les scores futurs avant le softmax, qui transforme les scores en poids dont la somme vaut 1. Les valeurs V sont ensuite combinées avec ces poids. Cet exemple utilise des Q/K fixes pour isoler le masque ; les Q/K/V du modèle seront appris.

scores = q @ k.transpose(-2, -1) / sqrt(head_dim)
scores = scores.masked_fill(future, float('-inf'))
weights = scores.softmax(dim=-1)
context = weights @ v

Un embedding associe un vecteur à chaque token et à sa position. Deux têtes d’attention lisent des relations différentes. Un MLP transforme le résultat ; les connexions résiduelles et LayerNorm stabilisent le calcul. Les logits sont des scores, un par token possible. Un seul bloc et aucun dropout ici pour garder le modèle petit et les calculs reproductibles.

x = token_embedding(ids) + position_embedding(positions)
x = x + attention(norm1(x))
x = x + mlp(norm2(x))
logits = output(final_norm(x))

La loss est l’erreur moyenne de prédiction (entropie croisée, en nats). Plus elle est basse, mieux le modèle prédit ces cibles. Le gradient indique comment modifier les poids ; Adam fait les mises à jour à un taux de 0,003, avec norme du gradient limitée à 1. Les mesures utilisent toujours les mêmes 8 fenêtres par ensemble. Si train baisse et validation remonte, le modèle surapprend. Le meilleur checkpoint est celui dont la loss de validation mesurée est la plus basse.

loss = cross_entropy(logits.flatten(0, 1), targets.flatten())
optimizer.zero_grad()
loss.backward()
clip_grad_norm_(model.parameters(), 1.0)
optimizer.step()

La température divise les logits avant le softmax. Une valeur basse concentre la distribution ; une valeur haute la répartit davantage. On tire ici dans tout le vocabulaire, sans top-k. Les probabilités affichées décrivent la dernière décision de génération. Même graine et mêmes poids donnent la même séquence. Un corpus de quelques lignes produit un modèle de démonstration, pas un assistant ni une capacité de raisonnement.

logits = model(ids[:, -context:])[:, -1, :]
probabilities = (logits / temperature).softmax(-1)
next_id = multinomial(probabilities, 1)
ids = cat((ids, next_id), dim=1)