Le modèle le plus idiot qui existe

Ouvre un livre. Lis la première ligne. Peux-tu deviner le mot suivant ? Probablement, parce que tu l’as déjà vu mille fois ailleurs.

Construisons un modèle qui ne sait faire que ça. À la fin du chapitre, tu auras lancé quatre petites fonctions, vu comment elles se combinent en générateur, et sauvegardé le premier fichier de ton propre projet my-llm/.

Le corpus utilisé ici est un fragment de comptine. Il est volontairement petit et répétitif : assez petit pour vérifier le code à l’œil, assez répétitif pour que le modèle dise quelque chose de presque cohérent.

the cat sat on the mat the dog sat on the rug the cat watched the dog the dog watched the cat

0. Démarre ton projet local

Les cellules dans le navigateur sont le banc d’essai rapide. Le dossier local est ce que tu gardes.

Crée-le maintenant :

mkdir -p my-llm/llm my-llm/scripts my-llm/data && cd my-llm && python3 -m venv .venv && source .venv/bin/activate

mkdir my-llm; mkdir my-llm\\llm,my-llm\\scripts,my-llm\\data; cd my-llm; py -m venv .venv; .\\.venv\\Scripts\\Activate.ps1

mkdir -p my-llm/llm my-llm/scripts my-llm/data && cd my-llm && python3 -m venv .venv && source .venv/bin/activate

Ajoute ensuite le marqueur de package vide :

touch llm/__init__.py

New-Item llm\\__init__.py -ItemType File

touch llm/__init__.py

Tu utiliseras ce dossier pendant tout le livre. Chaque chapitre y ajoute une brique.

1. Découper le texte en tokens

Avant de modéliser quoi que ce soit, il faut couper le texte en unités manipulables. Le choix le plus simple : chaque mot séparé par un espace est un token. On met tout en minuscules pour que The et the comptent comme le même mot.

La cellule contient déjà le texte. Mets-le en minuscules, découpe-le, et retourne le tableau de tokens — la visualisation te montrera exactement ce que le modèle voit.

const text = "The cat sat on the mat the dog sat on the rug the cat watched the dog the dog watched the cat";

// Make it lowercase, split on whitespace, and drop any empty
// strings. Return the array of tokens.
return text;

C’est tout. C’est la préparation des données d’entraînement dans sa forme minimale. Les vrais tokenizers font quelque chose de bien plus malin, ce qu’on verra au chapitre 3, mais pour l’instant espaces + minuscules suffit.

2. Compter les paires

Tout le “modèle” sera une table de comptage : pour chaque paire de tokens adjacents (a, b) dans le corpus, combien de fois b a suivi a ? Cette table est le modèle. L’entraînement consiste simplement à la remplir.

Le vocabulaire est l’ensemble des tokens uniques, dans leur ordre d’apparition. La table de comptage est une matrice carrée de taille vocab.length × vocab.length, où counts[i][j] est le nombre de fois où vocab[i] a été immédiatement suivi par vocab[j].

Écris la boucle qui remplit la table, puis inspecte la matrice qu’elle construit.

// 'tokens' is the array you produced in the previous cell.
// 'vocab' is the unique tokens, in first-seen order.
// Return a vocab.length × vocab.length array where counts[i][j]
// is the number of times vocab[i] is followed by vocab[j].
const counts = vocab.map(() => vocab.map(() => 0));
// ... your loop here
return counts;

La matrice produite est le modèle entier. La plupart des cellules sont à zéro : la plupart des paires de mots ne sont jamais apparues côte à côte. Les cellules non nulles disent ce que le modèle a appris. La ligne de the est probablement la plus remplie ; la ligne de mat est très pauvre, car mat n’est apparu qu’une fois, suivi par the.

En une ligne, les maths sont :

La probabilité que le mot suivant soit $w_t$, sachant que le mot précédent était $w_{t-1}$, est le nombre de fois où tu as vu $(w_{t-1}, w_t)$ divisé par le nombre total de fois où tu as vu $w_{t-1}$. Chaque ligne de la matrice, divisée par sa somme, est exactement une distribution de probabilité.

3. Échantillonner une distribution

Nous avons des probabilités. Il faut les transformer en choix concrets. Si une ligne dit que the est suivi de cat 40 % du temps et de dog 60 % du temps, on veut tirer dog environ six fois sur dix.

L’astuce standard : tirer un nombre aléatoire dans [0, 1), parcourir la somme cumulée des probabilités, puis choisir le premier index dont la somme cumulée dépasse le tirage.

// 'probs' is an array of non-negative numbers that sum to 1.
// Pick one index, with each i picked with probability probs[i].
// Hint: draw r = Math.random() in [0, 1) and walk the cumulative sum.
return 0; // always picks the first one — that's not random

Une fois ta version au point, exécute-la plusieurs fois. Regarde le graphe des comptages empiriques se remplir. Après quelques dizaines de tirages, la droite devrait commencer à ressembler à la gauche. C’est la loi des grands nombres qui s’invite discrètement dans le chapitre.

4. Tout assembler : générer

On chaîne maintenant les pièces. On part d’un token de départ. On trouve sa ligne dans la matrice. On normalise cette ligne en distribution. On échantillonne le token suivant. Celui-ci devient le nouveau départ. Et on répète.

La cellule met maintenant le corpus, le seed, la longueur voulue et les trois fonctions auxiliaires directement dans le script. La boucle s’arrête tôt si elle tombe sur une impasse : un token dont la ligne est entièrement à zéro.

// The script above defines tokenize, buildCounts, and sampleNext.
// It also defines 'text' (the corpus), 'seed', and 'n' (how many tokens).
// 1. Tokenize the corpus.
// 2. Build the vocab and counts table.
// 3. Starting from 'seed', pick one token at a time:
//    a. find the row for the current token,
//    b. normalize it into a distribution,
//    c. sample the next index, append the token.
// Stop early if the row is all zeros (a "dead end").
return [seed];

Une fois ta version au point, exécute-la plusieurs fois. Tu obtiendras des séquences différentes, parce que chaque étape est un échantillonnage, pas un choix déterministe. Certaines seront cohérentes, d’autres absurdes. Elles ne sont pas de simples répétitions du corpus, sauf hasard.

Structurellement, tous les LLM modernes font la même chose : des tokens précédents entrent, une probabilité sur les tokens suivants sort, puis on échantillonne. Le mécanisme qui produit la distribution est infiniment plus expressif que counts[i] / row_sum[i], mais l’interface est identique.

Tu viens de construire un modèle de langage. Il est très mauvais. Le reste du livre consiste à remplacer chaque partie par quelque chose qui l’est moins.

4b. Tourner les boutons

Tu as écrit les quatre fonctions. Manipule maintenant le pipeline entier d’un coup : change le corpus, plafonne le vocabulaire, avance dans la génération token par token et regarde la distribution qui a décidé chaque tirage.

Tape un corpus plus long et plus varié : la matrice devient plus creuse — plus de mots distincts, et la plupart des paires jamais vues. Tape-en un très répétitif et la génération devient vite ennuyeuse. Cet arbitrage est tout le sujet du chapitre 2.

5. Mettre la baseline dans ton repo

Sauvegarde maintenant la même idée localement. Crée llm/bigram.py :

"""A tiny bigram language model."""
from __future__ import annotations
 
import random
from collections import Counter, defaultdict
 
 
# [1]
def tokenize(text: str) -> list[str]:
    return [part for part in text.lower().split() if part]
 
 
# [2]
def train(tokens: list[str]) -> dict[str, Counter[str]]:
    counts: dict[str, Counter[str]] = defaultdict(Counter)
    # [3]
    for left, right in zip(tokens, tokens[1:]):
        counts[left][right] += 1
    return counts
 
 
# [4]
def sample_next(row: Counter[str]) -> str | None:
    total = sum(row.values())
    if total == 0:
        return None
 
    roll = random.random() * total
    acc = 0.0
    for token, count in row.items():
        acc += count
        if roll <= acc:
            return token
    return next(reversed(row))
 
 
# [5]
def generate(model: dict[str, Counter[str]], seed: str, steps: int) -> list[str]:
    out = [seed]
    for _ in range(steps - 1):
        nxt = sample_next(model.get(out[-1], Counter()))
        if nxt is None:
            break
        out.append(nxt)
    return out

Lis ce fichier par petits morceaux :

• [1] tokenize est volontairement ennuyeuse : minuscules, split, suppression des morceaux vides. Sa sortie est la seule chose que le modèle peut voir.
• [2] train construit un dictionnaire de dictionnaires : token précédent à l’extérieur, tokens suivants possibles à l’intérieur.
• [3] zip(tokens, tokens[1:]) est la boucle d’entraînement en miniature : (the, cat), puis (cat, sat), puis (sat, on).
• [4] sample_next ne prend pas le plus grand comptage. Il tire un nombre aléatoire et parcourt la ligne : les tokens fréquents gagnent souvent, pas toujours.
• [5] generate répète ce pas d’un token. Le dernier token devient l’entrée de la prédiction suivante.

Crée scripts/train_bigram.py :

from llm.bigram import generate, tokenize, train
 
TEXT = "the cat sat on the mat the dog sat on the rug the cat watched the dog the dog watched the cat"
 
# [1]
tokens = tokenize(TEXT)
# [2]
model = train(tokens)
 
# [3]
for _ in range(5):
    print(" ".join(generate(model, seed="the", steps=12)))

Ce script est volontairement fin :

• TEXT est la donnée d’entraînement.
• [1] transforme le texte brut en unités du modèle.
• [2] remplit la table de comptage.
• [3] échantillonne cinq continuations pour montrer que la génération est stochastique.

Lance-le :

python -m scripts.train_bigram

python -m scripts.train_bigram

python -m scripts.train_bigram

Tu as maintenant le premier artefact réel du cours : un modèle de langage local avec entraînement et génération. Minuscule, brut, mais à toi.

Pour aller plus loin

• makemore, épisode 1, par Karpathy construit le même modèle en Python, en version caractère.
• Step by Token, chapitre 1 couvre les mêmes idées depuis l’angle compréhension.
• L’implémentation de référence complète vit dans lib/ml/bigram/.

Prochaine étape : compter ne suffit pas — que se passe-t-il quand ton modèle local rencontre une continuation qu’il n’a jamais vue ?