Créer votre propre modèle GPT : Guide complet du débutant à l'expert

Code source du projet associé pour tester ce tutoriel : github.com/Lucas-lux/zeroToGpt

Imaginez que vous lisez un livre et qu'à chaque page, vous devez deviner le mot suivant. Plus vous lisez, plus vous devenez bon à anticiper ce qui vient ensuite. C'est exactement ce que fait un GPT (Generative Pre-trained Transformer) !

Dans ce guide complet, nous allons démystifier ensemble l'architecture qui révolutionne l'intelligence artificielle. De la théorie à la pratique, vous découvrirez comment créer votre propre modèle de langage, étape par étape.

Qu'est-ce qu'un GPT ? La révolution de l'attention

Un GPT est un modèle de langage auto-régressif - cela signifie qu'il génère du texte un mot (ou plus précisément un "token") à la fois, en se basant sur tout ce qu'il a déjà écrit. Contrairement aux humains qui peuvent parfois revenir en arrière pour corriger, un GPT écrit de manière unidirectionnelle : de gauche à droite, sans retour possible.

Pourquoi cette approche est-elle révolutionnaire ?

Avant les Transformers, les modèles de langage utilisaient des architectures récurrentes (RNN, LSTM) qui traitaient le texte séquentiellement - mot après mot. Imaginez devoir lire un livre en ne gardant qu'une petite note sur ce que vous venez de lire. C'est limitant !

Les Transformers ont changé la donne en permettant au modèle de regarder tous les mots précédents simultanément, comme si vous pouviez garder le livre entier ouvert devant vous. Cette capacité s'appelle l'attention.

Les trois piliers d'un GPT

Generative : Il génère du nouveau texte
Pre-trained : Il est d'abord entraîné sur d'énormes quantités de texte pour apprendre les patterns du langage
Transformer : Il utilise l'architecture Transformer basée sur l'attention

Le voyage d'une phrase dans un GPT

Pour comprendre comment un GPT transforme votre prompt en texte cohérent, suivons le parcours de "Bonjour, comment allez-vous ?" à travers le modèle.

Étape 1 : La tokenisation

Votre phrase est d'abord découpée en tokens (unités de traitement) :

"Bonjour" → [Bon, jour]
"comment" → [comment]
"allez-vous" → [allez, -vous]

Étape 2 : L'embedding (transformation en nombres)

Chaque token devient un vecteur de nombres. Par exemple, "Bon" pourrait devenir [0.2, -0.5, 0.8, ...] - un vecteur de 256 dimensions dans notre implémentation.

Pourquoi des nombres ? Les ordinateurs ne comprennent que les mathématiques. Ces vecteurs capturent le sens des mots : les mots similaires auront des vecteurs similaires.

Étape 3 : L'encodage positionnel

Le modèle ajoute des informations sur la position de chaque mot. "Bonjour" en première position recevra des coordonnées différentes de "comment" en deuxième position.

Étape 4 : L'attention (le cœur du système)

C'est ici que la magie opère ! Le modèle calcule combien chaque mot doit "faire attention" à chaque autre mot :

"vous" fera beaucoup attention à "allez" (ils sont liés grammaticalement)
"Bonjour" fera moins attention à "vous" (moins de relation directe)

Les stratégies de tokenisation : transformer le texte en nombres

La tokenisation est cruciale : comment découper le texte en unités que l'ordinateur peut traiter ? Il existe plusieurs stratégies.

Tokenisation par caractères : simplicité et universalité

Exemple simplifié

text = "Hello"
tokens = ["H", "e", "l", "l", "o"]
vocab = ["a", "b", "c", ..., "H", "e", "l", "o", ...]

Avantages :

Vocabulaire minimal (~100 tokens)
Aucun mot "inconnu" possible
Fonctionne dans toutes les langues

Inconvénients :

Séquences très longues (5x plus long qu'avec des mots)
Difficile de capturer le sens des mots

Byte Pair Encoding (BPE) : la solution moderne

BPE est le compromis parfait, utilisé par tous les modèles modernes (GPT-3, GPT-4, etc.).

Comment ça marche :

Commencer avec les caractères : Chaque byte (0-255) est un token initial
Trouver les paires fréquentes : Quelles paires de tokens apparaissent souvent ensemble ?
Fusionner la paire la plus fréquente : Créer un nouveau token
Répéter jusqu'à atteindre la taille de vocabulaire désirée

Exemple concret :

Texte : "unhappy unhappiness happy happiness"

Étape 1 : [u,n,h,a,p,p,y, ,u,n,h,a,p,p,i,n,e,s,s, ...]
Paire la plus fréquente : "p,p" (apparaît 4 fois)
→ Nouveau token "pp"

Résultat final : "unhappy" → [un, happy] "unhappiness" → [un, happiness]

Pourquoi BPE est génial :

Efficacité : Équilibre entre longueur de séquence et taille de vocabulaire
Robustesse : Peut gérer n'importe quel texte, même avec des mots inventés
Adaptabilité : Le vocabulaire s'adapte automatiquement à vos données

L'architecture Transformer démystifiée

Le problème que résout l'attention

Imaginez cette phrase : "La banque où j'ai déposé mon argent se trouve près de la banque de la rivière."

Le mot "banque" a deux sens différents ! Pour comprendre lequel est utilisé, vous devez regarder tout le contexte. C'est exactement ce que fait l'attention.

L'attention en action : Query, Key, Value

L'attention utilise trois concepts clés, comme une bibliothèque intelligente :

Query (Requête) : "Que cherche ce mot ?"
Key (Clé) : "De quoi parle chaque mot ?"
Value (Valeur) : "Quelle information chaque mot apporte-t-il ?"

La formule magique de l'attention

Attention(Q, K, V) = softmax(Q·K^T / √d_k) · V

Astuce: la division par √d_k stabilise les valeurs avant le softmax et évite des gradients trop extrêmes.

Exemple PyTorch minimal (scaled dot-product attention) :

import torch
import torch.nn.functional as F

def scaled_dot_product_attention(Q, K, V):
    d_k = Q.size(-1)
    scores = (Q @ K.transpose(-2, -1)) / (d_k ** 0.5)
    weights = F.softmax(scores, dim=-1)
    return weights @ V

# B x T x d
B, T, d = 2, 4, 8
Q = torch.randn(B, T, d)
K = torch.randn(B, T, d)
V = torch.randn(B, T, d)
out = scaled_dot_product_attention(Q, K, V)

Décortiquons cette formule :

*Q·K^T : Compare chaque query avec chaque key (qui regarde qui ?)
/ √d_k : Normalise pour éviter des scores trop extrêmes
softmax() : Transforme en probabilités (somme = 1)
· V : Pondère les valeurs selon les scores d'attention

Multi-Head Attention : plusieurs perspectives

Pourquoi avoir plusieurs "têtes" d'attention ? Imaginez analyser une peinture :

Tête 1 : Se concentre sur les couleurs
Tête 2 : Analyse les formes
Tête 3 : Étudie la composition
Tête 4 : Observe les détails

Chaque tête d'attention apprend à capturer différents types de relations :

Relations grammaticales (sujet-verbe)
Relations sémantiques (concepts liés)
Relations positionnelles (mots proches)
Relations stylistiques (ton, registre)

Décortiquer un modèle GPT complet

Vue d'ensemble : l'architecture en couches

Un GPT est comme un sandwich de couches, chacune avec un rôle spécifique :

Texte d'entrée: "Le chat mange"
↓
[Token Embeddings] - Transforme les mots en vecteurs
↓
[Position Embeddings] - Ajoute l'info de position
↓
[Transformer Block 1] - Première couche d'analyse
↓
[Transformer Block 2] - Analyse plus profonde
↓
[Transformer Block 3] - Encore plus profonde
↓
[Transformer Block 4] - Analyse finale
↓
[Layer Norm] - Normalisation finale
↓
[Linear Head] - Projection vers le vocabulaire
↓
Probabilités: [0.001 "la", 0.8 "des", 0.15 "une", ...]

Les Token Embeddings : donner un sens aux mots

Schéma simplifié (ASCII)

[Texte d'entrée]
      ↓
[Token Embeddings] → [Position Embeddings]
      ↓
[Bloc Transformer × N]
      ↓
[LayerNorm]
      ↓
[Linear Head]
      ↓
[Softmax → Probabilités vocabulaire]

Étapes détaillées

Token Embeddings: convertit chaque token en vecteur dense dans un espace de dimension d_model.
Position Embeddings: encode la position séquentielle et s’additionne aux Token Embeddings.
Blocs Transformer (×N): chaque bloc applique Self-Attention puis MLP avec résidus + normalisation.
LayerNorm: stabilise et normalise les activations en fin d’empilement.
Linear Head: projette vers la taille du vocabulaire.
Softmax: transforme en distribution de probabilités sur les tokens suivants.

Chaque token devient un vecteur dense de nombres réels. Dans notre configuration, chaque token devient un vecteur de 256 dimensions.

Dans notre code :

self.token_embedding_table = nn.Embedding(vocab_size, config.n_embd)

vocab_size=2000 tokens → n_embd=256 dimensions

Pourquoi 256 dimensions ? C'est un compromis entre :

Expressivité : Assez de dimensions pour capturer les nuances
Efficacité : Pas trop de paramètres pour notre modèle modeste
Mémoire : Matrices de taille raisonnable pour l'entraînement

L'attention causale : respecter la temporalité

Crucial pour les GPT : l'attention causale empêche le modèle de "tricher" en regardant les mots futurs.

Dans notre implémentation :

self.register_buffer('tril', torch.tril(torch.ones(block_size, block_size)))
wei = wei.masked_fill(self.tril[:T, :T] == 0, float('-inf'))

Cette matrice triangulaire garantit que :

Le mot en position 0 ne voit que lui-même
Le mot en position 1 voit les positions 0 et 1
Le mot en position 2 voit les positions 0, 1 et 2
Et ainsi de suite...

Configuration et hyperparamètres : les clés de la performance

Chaque paramètre a un impact direct sur les performances. Comprenons ces choix :

Architecture du modèle

n_embd (256) : La dimension des représentations

C'est la "largeur" de votre modèle - combien de nombres utiliser pour représenter chaque token.

Notre choix (256) : Optimal pour un modèle de ~0.8M paramètres. Assez large pour apprendre des patterns complexes sur Shakespeare, assez petit pour éviter l'overfitting.

n_head (4) : Le nombre de têtes d'attention

Contrainte importante : n_embd doit être divisible par n_head

Notre cas : 256 ÷ 4 = 64 dimensions par tête

block_size (512) : La mémoire du contexte

Combien de tokens précédents le modèle peut-il "voir" ?

Coût : L'attention est en O(n²) - doubler block_size = 4x plus de calculs !

dropout (0.4) : La régularisation

Notre choix (0.4) : Élevé car notre dataset est petit. Force le modèle à généraliser plutôt qu'à mémoriser Shakespeare.

Paramètres d'entraînement

@dataclass
class GPTConfig:
# Architecture
n_embd: int = 256 # Dimension des embeddings
n_head: int = 4 # Têtes d'attention
n_layer: int = 4 # Couches transformer
block_size: int = 512 # Taille du contexte

# Entraînement
batch_size: int = 64     # Taille des batches
learning_rate: float = 3e-4  # Vitesse d'apprentissage
max_iters: int = 2000    # Durée d'entraînement
vocab_size: int = 2000   # Taille du vocabulaire BPE

Mesurer et interpréter votre modèle

Le nombre de paramètres : perspective

Notre modèle contient environ 0.8 million de paramètres :

Notre modèle (0.8M) ← Vous êtes ici GPT-2 small (117M) ← 146x plus grand GPT-3 (175B) ← 218,750x plus grand GPT-4 (~1.7T estimé) ← ~2,125,000x plus grand

Ne vous découragez pas ! Notre petit modèle peut :

Apprendre la grammaire et le style de Shakespeare
Générer du texte cohérent sur plusieurs phrases
Capturer des patterns linguistiques complexes

Interpréter les valeurs de loss

Pour notre tokenisation BPE (vocab_size=2000) :

Loss ~6.9 : Random (log(2000)) - Le modèle devine au hasard Loss ~4.0 : Apprentissage des bigrammes basiques Loss ~3.0 : Structure de phrase émergente Loss ~2.5 : Grammaire correcte, début de sens Loss ~2.0 : Bon style, cohérence locale Loss ~1.5 : Excellence (très difficile à atteindre)

Patterns d'entraînement à reconnaître

🟢 Entraînement sain :

Train et validation descendent ensemble
Écart stable entre les deux
Convergence graduelle

🔴 Overfitting sévère :

Train très bas, validation haute
Grande divergence entre les deux
Génération de texte répétitive

Utilisation pratique du code

Configuration de l'environnement

Installation minimale

pip install torch
pip install regex  # Pour la tokenisation BPE

Structure des fichiers

votre-projet/
├── config.py              # Configuration centralisée
├── data_token_bpe.py      # Module de données BPE
├── model.py               # Architecture GPT
├── gpt.py                 # Script principal d'entraînement
├── infer_bpe.py           # Script d'inférence
└── data/
    └── input_tiny_shakespeare.txt

Lancement de l'entraînement

python gpt.py

Ce qui se passe :

Auto-détection device (CUDA si disponible)
Tokenisation BPE (entraîne ou charge le tokeniseur)
Initialisation du modèle GPT
Boucle d'entraînement avec évaluation périodique
Sauvegarde automatique
Génération test

Tests et inférence

Génération simple

python infer_bpe.py --model-dir model/model_tiny_shakespeare_bpe \
  --prompt "To be or not to" --max-new-tokens 100

Dialogue de Romeo

python infer_bpe.py --model-dir model/model_tiny_shakespeare_bpe \
  --prompt "ROMEO:" --max-new-tokens 50

Monologue d'Hamlet

python infer_bpe.py --model-dir model/model_tiny_shakespeare_bpe \
  --prompt "HAMLET:" --max-new-tokens 100

Aller plus loin : ressources et références

Papiers fondamentaux à lire absolument

🏆 "Attention Is All You Need" (2017) - Vaswani et al.

Le papier qui a tout changé

Comprendre l'origine du mécanisme d'attention qui anime tous les LLM modernes.

Ce que vous y apprendrez :

Formulation mathématique précise de l'attention
Architecture encoder-decoder complète
Positional encoding avec fonctions sinusoïdales
Multi-head attention justifiée théoriquement

🚀 "Language Models are Unsupervised Multitask Learners" (2019) - Radford et al.

L'introduction de GPT-2

Démonstration que l'apprentissage auto-supervisé peut créer des capacités émergentes.

Implémentations de référence

🎯 nanoGPT - Andrej Karpathy

github.com/karpathy/nanoGPT

Pourquoi étudier ce code :

Implémentation minimale mais production-ready
Code très proche du nôtre, mais optimisé
Excellent pour comprendre les détails techniques

🏭 Transformers - Hugging Face

github.com/huggingface/transformers

Bibliothèque de référence avec modèles pré-entraînés (GPT-2, GPT-3.5, Llama, etc.).

Cours recommandés

🎓 "Neural Networks: Zero to Hero" - Andrej Karpathy

karpathy.ai/zero-to-hero.html

Plan du cours :

Micrograd : Comprendre la backpropagation
Makemore : N-gram et MLP language models
GPT from scratch : Exactement ce que vous venez d'apprendre !
Optimizations : Techniques avancées

Conclusion : vous êtes maintenant équipé !

Avec les bases solides que vous avez acquises et ces ressources, vous avez tout pour devenir un expert en modèles de langage. Le domaine évolue rapidement, mais les fondamentaux que vous maîtrisez (attention, transformers, tokenisation, entraînement) restent au cœur de toutes les innovations.

Votre prochain défi : Choisissez un projet concret et implémentez-le ! L'apprentissage en machine learning se fait par la pratique. Commencez petit, itérez rapidement, et n'hésitez pas à partager vos découvertes avec la communauté.

Bienvenue dans le monde fascinant des modèles de langage - vous avez maintenant les clés pour contribuer à l'avenir de l'IA ! 🚀

Et vous, quel sera votre premier projet avec cette architecture GPT ? Partagez vos expérimentations et vos découvertes - la communauté de l'IA se construit par le partage de connaissances !