Comment construire et entraîner votre propre GPT sur un ordinateur portable ordinaire

La plupart des tutoriels sur les réseaux de neurones aujourd'hui se résument à deux scénarios. On vous demande soit d'appeler l'API OpenAI avec quelques lignes de Python, soit de télécharger un modèle prêt à l'emploi depuis Hugging Face et d'appeler la méthode .generate(). Dans les deux cas, tous les rouages restent en coulisses. Vous obtenez un résultat, mais vous comprenez à peine comment les multiplications matricielles transforment du texte brut en phrases cohérentes.

Récemment, je suis tombé sur le dépôt llm-from-scratch du développeur angelos-p. C'est un atelier interactif où vous écrivez chaque composant d'un modèle de langage from scratch. Pas d'abstractions lourdes : juste du PyTorch pur, des maths claires, et l'entraînement d'un modèle de 10 millions de paramètres sur votre ordinateur portable en moins d'une heure.

Входной текст
    │
    ▼
┌─────────────────┐
│   Tokenizer     │  "hello" → [20, 43, 50, 50, 53]
└────────┬────────┘
         ▼
┌─────────────────┐
│  Token Embed +  │  Векторы токенов + позиция
│  Position Embed │  (размерность n_embd)
└────────┬────────┘
         ▼
┌─────────────────┐
│  Transformer    │  × n_layer слоев
│  Block:         │
│  ┌────────────┐ │
│  │ LayerNorm  │ │
│  │ Self-Attn  │ │  n_head параллельных голов внимания
│  │ + Residual │ │
│  ├────────────┤ │
│  │ LayerNorm  │ │
│  │ MLP (FFN)  │ │  расширение 4x, GELU, проекция назад
│  │ + Residual │ │
│  └────────────┘ │
└────────┬────────┘
         ▼
┌─────────────────┐
│   LayerNorm     │
│   Linear → logits│  вероятности следующего символа
└─────────────────┘

D'où ça vient

Beaucoup ont entendu parler du projet nanoGPT d'Andrej Karpathy. Karpathy a montré qu'une architecture GPT-2 complète avec 124 millions de paramètres peut tenir dans quelques centaines de lignes de code. Cependant, reproduire le GPT-2 original nécessite encore pas mal de calculs et de temps.

L'auteur de llm-from-scratch est allé plus loin. Il a supprimé toutes les optimisations de cluster inutiles et adapté le code pour qu'on puisse l'écrire à la main en une seule soirée. Le modèle final s'entraîne sur Apple Silicon (MPS), les GPU Nvidia via CUDA, ou même un CPU ordinaire. Si vous n'avez pas de matériel local, tout fonctionne dans Google Colab gratuit.

Ce que contient l'atelier

Le matériau est divisé en modules paso à paso dans le dossier docs/. Vous créez séquentiellement trois fichiers fonctionnels : model.py, train.py et generate.py.

1. Tokenisation au niveau des caractères

Lorsqu'on travaille avec d'énormes corpus de texte, la solution standard est l'algorithme BPE (Byte Pair Encoding) avec un vocabulaire de 50 000 jetons. Mais si vous entraînez un petit réseau sur un jeu de données de 1 mégaoctet, le BPE cassera votre entraînement. La plupart des paires de jetons n'apparaîtront que quelques fois dans tout le texte, et les poids ne converger tout simplement pas pour elles.

C'est pourquoi l'auteur utilise un tokenizer au niveau des caractères pour l'entraînement sur les pièces de Shakespeare. L'alphabet ne comprend que 65 caractères uniques. Ce vocabulaire est compact, s'encode rapidement et donne à un petit modèle une chance de capturer la grammaire et la structure des dialogues.

2. Construction du Transformer

Ici, vous assemblez à la main l'architecture du décodeur GPT :

• Tables d'embedding pour les caractères et les positions dans le texte.
• Bloc d'auto-attention multi-têtes, où le vecteur de chaque caractère interagit avec le contexte via les requêtes, les clés et les valeurs (Q, K, V).
• Mécanisme de masque causal qui empêche le modèle de regarder les jetons futurs pendant la génération.
• Couches entièrement connectées (MLP) avec activation GELU et normalisation LayerNorm.

L'architecture est assemblée sans magie ni frameworks tiers. Vous pouvez voir clairement où circule chaque tenseur et à quel stade les connexions résiduelles sont ajoutées.

3. Boucle d'entraînement

Dans la troisième étape, vous écrivez le pipeline d'entraînement. Il comprend :

• Calcul de la perte d'entropie croisée entre les logits prédits et les caractères suivants réels.
• Optimiseur AdamW avec ajustement du weight decay.
• Découpage des gradients pour éviter l'explosion des poids pendant l'entraînement.
• Planificateur de taux d'apprentissage avec warmup et décroissance cosinusoïdale.

4. Génération de texte et échantillonnage

Le modèle fini doit être mis à parler. Vous implémentez une boucle autorégressive : prenez une graine de texte, passez-la dans le transformer, extrayez la distribution de probabilité pour le jeton suivant, et sélectionnez-le en utilisant la température avec une recherche gloutonne ou un échantillonnage top-k.

Configurations pour les expériences

Le dépôt propose trois profils de modèle. Vous pouvez choisir en fonction de votre temps libre.

| Profil | Paramètres | Couches (n_ layer) | Têtes (n_head) | Dimension (n_embd) | Temps d'entraînement (M3 Pro) | |---|---|---|---|---|---|---| | Tiny | ~0,5M | 2 | 2 | 128 | ~5 minutes | | Small | ~4M | 4 | 4 | 256 | ~20 minutes | | Medium | ~10M | 6 | 6 | 384 | ~45 minutes |

Tous les profils fonctionnent avec une longueur de contexte de 256 caractères. Le profil Tiny est idéal pour le débogage rapide lorsque vous devez vérifier que le code s'exécute sans erreurs shape mismatch. Le profil Medium produit déjà une prose shakespearienne assez lisible avec des divisions de dialogues de personnages.

Comment exécuter le projet

Pour la gestion de l'environnement, l'auteur recommande le gestionnaire de paquets rapide uv.

Installation des dépendances et création d'un dossier de travail :

# Установка uv (если еще не установлен)
curl -LsSf https://astral.sh/uv/install.sh | sh

# Клонируем репозиторий и синхронизируем окружение
git clone https://github.com/angelos-p/llm-from-scratch
cd llm-from-scratch
uv sync
mkdir scratchpad && cd scratchpad

Si vous préférez Google Colab, installer un ensemble minimal de bibliothèques suffit :

!pip install torch numpy tqdm tiktoken

Puis vous prenez le fichier data/shakespeare.txt, ouvrez le premier guide docs/01-tokenization.md et commencez à écrire le code paso à paso.

À qui s'adresse cet atelier

Le projet plaira à ceux qui sont fatigués des articles abstraits avec des graphiques d'attention et qui veulent voir du vrai code. Aucune connaissance approfondie de l'apprentissage automatique n'est requise pour le suivre. Être à l'aise avec la lecture de la syntaxe Python et la compréhension des opérations de base sur les tableaux suffit.

Après avoir terminé les six guides, vous vous débarrassez du sentiment de magie autour des LLM. Vous comprendrez en pratique pourquoi les modèles ont besoin d'un warmup du taux d'apprentissage, comment la température affecte l'aléatoire des réponses, et pourquoi les petits modèles sont si sensibles à la taille du vocabulaire. C'est une excellente façon de passer un week-end de manière productive pour vos connaissances en ingénierie.