Mini GPT (from scratch) — Projet TALN

Ce dépôt contient un notebook qui implémente un mini-modèle de langage de type GPT à partir de zéro en PyTorch (architecture Transformer causale), puis l’entraîne pour générer du texte.

Projet réalisé dans le cadre d’un cours de Traitement Automatique du Langage Naturel (TALN). L’objectif pédagogique est de comprendre le fonctionnement interne des modèles de langage : embeddings, self-attention masquée, blocs Transformer, apprentissage auto-régressif, et génération.

Notebook principal : build_a_tiny_language_model.ipynb

Objectifs du projet

• Implémenter un Mini GPT from scratch avec PyTorch.
• Préparer un dataset simple pour l’entraînement : MaxLSB/LeCarnet (Hugging Face).
• Entraîner le modèle à prédire le prochain token et générer du texte.
• Analyser les performances : cohérence qualitative, perte (loss) et (optionnel) perplexité.

Dataset

Le notebook charge le dataset MaxLSB/LeCarnet via la librairie datasets (Hugging Face), puis concatène la colonne texte en un grand corpus.

Remarque : pour accélérer les essais, le notebook permet de limiter le nombre de lignes via max_train_rows.

Prérequis

• Python 3.10+ recommandé
• Accès internet (téléchargement du dataset)
• GPU recommandé (sinon CPU possible mais plus lent)

Dépendances (voir requirements.txt) :

• torch
• datasets
• tqdm

Exécution recommandée : Google Colab (GPU T4)

L’environnement recommandé est Google Colab avec un GPU T4.

1. Ouvrir build_a_tiny_language_model.ipynb dans Colab.
2. Activer le GPU : Runtime → Change runtime type → GPU.
3. Installer les dépendances dans une cellule :

pip install -r requirements.txt

4. Exécuter les cellules dans l’ordre (chargement des données → tokenisation → modèle → entraînement → génération).

Exécution en local

Vous pouvez exécuter le notebook localement (Jupyter/VS Code) en installant les dépendances depuis requirements.txt dans un environnement pip ou uv.

Option A — Environnement venv + pip

Depuis la racine du projet :

python -m venv .venv
source .venv/bin/activate
pip install -U pip
pip install -r requirements.txt

Ensuite, lancez Jupyter (au choix) :

pip install notebook
jupyter notebook

Ou ouvrez le notebook dans VS Code en sélectionnant l’interpréteur .venv.

Option B — Environnement uv

Si uv est installé :

uv venv
source .venv/bin/activate
uv pip install -r requirements.txt

Puis ouvrez/executez le notebook avec Jupyter ou VS Code.

Comment ça marche (résumé)

Le notebook suit les étapes suivantes :

1. Chargement des données (datasets.load_dataset).
2. Tokenisation au choix :
   • char : caractère par caractère
   • word : tokens “mots + ponctuation + espaces” via une regex (mode par défaut)
3. Création du vocabulaire + mappings stoi/itos + encode/decode.
4. Modèle : embeddings (token + position) → empilement de blocs Transformer causaux → projection vocabulaire.
5. Entraînement : AdamW, cross-entropy sur la prédiction du prochain token.
6. Sauvegarde : checkpoint PyTorch (ex. best_model_2.pt).
7. Inférence : génération auto-régressive token par token.

Paramètres importants

Vous pouvez ajuster dans le notebook :

• tokenization_mode : 'word' ou 'char'
• block_size : longueur de contexte
• n_layer, n_head, n_embd : taille/capacité du modèle
• max_iters, learning_rate : entraînement
• max_train_rows : taille du dataset utilisée

Évaluation / analyse des performances

Le notebook affiche périodiquement la perte train_loss et val_loss.

Pour une mesure standard en modélisation de langue, vous pouvez convertir une perte moyenne (cross-entropy) en perplexité :

$$\text{perplexité} = e^{\text{loss}}$$

(Optionnel) vous pouvez aussi analyser qualitativement :

• cohérence locale (accords, ponctuation)
• répétitions
• respect du style du corpus

Résultats attendus

Après entraînement, le modèle doit être capable de générer du texte en français qui suit globalement la distribution du corpus (même si la cohérence globale reste limitée pour un “mini GPT”).

Dépannage

• Téléchargement dataset lent/échoue : vérifier la connexion internet et réessayer.
• CPU trop lent : réduire max_train_rows, max_iters, n_layer/n_embd, ou passer sur Colab GPU.
• CUDA OOM (manque de VRAM) : réduire batch_size, block_size, n_embd, n_layer.

Licence / usage

Notebook fourni à des fins pédagogiques dans le cadre du cours.