Exemple de code : Pré-entraînement continu
Démontré en partie. 1 exemple sur 2 démontre le gain de la méthode (exemple principal). L'autre s'exécute, mais son résultat ne le prouve pas encore (variante
mlm-encodeur). La version grosse infra n'a jamais été exécutée. La raison figure dans le tableau « Essayer dans le dépôt » ; les pistes pour y arriver : Travail en cours.
Ce que le dossier 01-pre-entrainement-continu/ fournit pour cette méthode. Principe et références : Pré-entraînement continu.
Ce que fait l'exemple
Le besoin : qu'un modèle réponde à des questions sur des documents internes (fiches produits, procédures, annuaire) sans les avoir dans son contexte, et y compris sur des sujets pour lesquels on n'a écrit aucune question d'exemple.
Résultats (Qwen2.5-0.5B, RTX 5070 Ti Laptop ; 800 questions sur 200 personnages dont le modèle n'a lu que les biographies) :
| Mesure (3 graines) | Avant | Après | Témoin (une biographie) |
|---|---|---|---|
| Questions sur les personnages jamais questionnés | 0,001 | 0,9996 ± 0,0007 | 0,997 ± 0,001 |
| — ville / année / métier / création | 0 / 0 / 0,005 / 0 | 1 / 1 / 1 / 0,998 | 0,995 / 0,995 / 1 / 0,998 |
| Questions déjà vues à l'entraînement | — | 1,0 | 0,9996 |
| Perplexité générale (wikitext-2) | 20,2 | 24,2 ± 0,1 | 24,7 ± 0,5 |
L'écart après − avant est de +0,998 ± 0,001 (p de McNemar < 10⁻⁶ sur chaque graine, 800 questions appariées) : le modèle répond sur des personnages pour lesquels il n'a lu que des biographies. La perplexité générale monte de 20 %, malgré le replay : c'est le prix d'un entraînement complet de 20 époques sur un petit corpus.
Le témoin à une seule biographie fait presque aussi bien (0,997) : sur un modèle déjà pré-entraîné, c'est le mélange de questions-réponses qui rend la connaissance extractable, la diversité des formulations n'apportant ici qu'un gain marginal. Sans questions-réponses à l'entraînement (donnees.source=faits), le modèle apprend les fiches mais n'en extrait presque rien en question-réponse (0,04).
Variantes
Variante encodeur : pré-entraînement continu par masquage
variantes/mlm-encodeur applique la même méthode à un encodeur : BERT, RoBERTa, DeBERTa, CamemBERT, ModernBERT.
À quoi ça sert. Un encodeur ne génère pas de texte. Il transforme un texte en représentation, que l'on fine-tune ensuite pour une tâche : classification, routage de tickets, extraction d'entités, recherche sémantique. En entreprise, ces tâches tournent souvent sur des encodeurs de 100 à 400 millions de paramètres, plus rapides et moins chers qu'un LLM. Un encodeur a été pré-entraîné à deviner des mots masqués (MLM, masked language modeling), pas à prédire le mot suivant. Le pré-entraînement continu reprend donc cet objectif-là sur du texte brut du domaine (contrats, comptes rendus médicaux, tickets internes), avant le fine-tuning de la tâche. C'est l'objet de Don't Stop Pretraining (Gururangan et al., 2020).
Quand l'utiliser. Beaucoup de texte du domaine sans étiquettes, peu d'exemples étiquetés pour la tâche finale, et un vocabulaire éloigné du web. Avec des milliers d'exemples étiquetés, le fine-tuning direct (variante encodeur de DATA02) suffit souvent.
Ce que fait le code. run.py charge RoBERTa-base, génère les fiches de 60 personnages inventés (les mêmes faits que l'exemple principal), en garde trois sur quatre pour l'entraînement et une sur quatre pour la mesure. Le Trainer de transformers masque 15 % des tokens de chaque fiche (DataCollatorForLanguageModeling) et entraîne tous les poids à les retrouver, 20 époques, taux 5e-5. La perte de masquage sur les fiches mises de côté est mesurée avant et après ; le modèle est écrit dans sorties/01-pre-entrainement-continu--variantes--mlm-encodeur/modele/, prêt pour un fine-tuning.
Résultats (RoBERTa-base, 17 s) : perte de masquage sur les fiches mises de côté 2,38 → 1,09.
Non démontré. Cette perte montre seulement que le modèle a appris à compléter des fiches écrites sur le même modèle de phrases. Elle ne dit pas si l'encodeur fait mieux sa tâche finale. La démonstration passe par le protocole du papier sur banking77 : masquage continu sur les messages bancaires sans leurs étiquettes, puis fine-tuning de classification avec 10 exemples par intention, comparé au même fine-tuning sans masquage, sur les 3 080 messages de test et 3 graines.
python variantes/mlm-encodeur/run.py --quick # DistilRoBERTa, 8 personnages
python variantes/mlm-encodeur/run.py # RoBERTa-base, 60 personnages, ~20 s
Composants de l'exemple
flowchart TD
classDef externe fill:#fed7aa,stroke:#ea580c,color:#7c2d12
classDef code fill:#ffffff,stroke:#6b7280,color:#1f2937
classDef gpu fill:#fecaca,stroke:#dc2626,color:#7f1d1d
classDef disque fill:#dcfce7,stroke:#16a34a,color:#14532d
Hub["Hugging Face Hub<br/>Qwen2.5-0.5B<br/>wikitext-2"]
Cache[("cache disque<br/>~/.cache/huggingface")]
subgraph Py["Processus Python"]
Run["run.py<br/>génère les biographies<br/>charge le modèle"]
Ev["evaluation.py<br/>génération, perplexité"]
Tr["transformers Trainer<br/>prochain token"]
end
GPU["GPU CUDA, 12 Go"]
Out[("sorties/01-pre-<br/>entrainement-continu/")]
Hub -- "① HTTPS GET, 1re fois<br/>poids (1 Go), wikitext-2" --> Cache
Cache -- "② lecture des poids<br/>et des textes" --> Run
Run -- "③ copie des poids<br/>en mémoire GPU" --> GPU
Run -- "④ ⑧ appel Python<br/>mesure avant, après" --> Ev
Ev -- "⑤ ⑨ noyaux CUDA<br/>génération, passe avant" --> GPU
Run -- "⑥ appel Python<br/>trainer.train()" --> Tr
Tr -- "⑦ noyaux CUDA<br/>forward, backward" --> GPU
Tr -- "⑩ écriture<br/>modèle" --> Out
Run -- "⑪ écriture<br/>resultats.json" --> Out
GPU ~~~ Out
class Hub externe
class Run,Ev,Tr code
class GPU gpu
class Cache,Out disque
make run EX=DATA01 vérifie les prérequis (modules, GPU), puis lance run.py dans l'environnement .venv. Le script lit config.yaml (modèle de base, données, réglages) et génère en mémoire, sans téléchargement, 400 personnages inventés : ville et année de naissance, métier, création. Le protocole est celui de Physics of Language Models 3.1 (Allen-Zhu et Li) :
-
chaque personnage est décrit par 5 biographies, où la formulation de chaque phrase (4 au choix par attribut) et l'ordre des phrases sont tirés au hasard ;
-
les questions-réponses (« Question: In which city was Kavel Mortor born? Answer: Lisqia ») de 200 personnages sont mêlées aux biographies pendant l'entraînement ;
-
on mesure les réponses aux 800 questions sur les 200 autres personnages, dont le modèle n'a lu que les biographies.
-
① Téléchargement. Au premier lancement, transformers télécharge les poids de Qwen2.5-0.5B, le modèle de base (environ 1 Go, safetensors), et
datasetstélécharge wikitext-2 (7,5 Mo), depuis le Hugging Face Hub, par HTTPS. -
② Lecture. Poids et textes sont rangés dans le cache
~/.cache/huggingface; les lancements suivants les relisent sur le disque, sans réseau. -
③ Copie sur le GPU. Les poids sont copiés en fp32 dans la mémoire du GPU, où ils restent jusqu'à la fin : ce sont les poids maîtres de l'entraînement complet. Le tokenizer est utilisé sans chat template : les questions ont la forme « Question: … Answer: ».
-
④ Mesure avant.
run.pyappellecommun/evaluation.py: les 800 questions sur les personnages jamais questionnés (réponse juste si la bonne valeur est dans la première phrase de la réponse), et la perplexité sur 50 paragraphes du splittestde wikitext-2 (connaissances générales). -
⑤ Calcul sur le GPU. Les questions sont posées en génération gloutonne, jusqu'à 24 tokens par réponse. La perplexité ne demande qu'une passe avant par texte.
-
⑥ Entraînement.
run.pyrépète 20 fois les 2 000 biographies et les 800 questions-réponses, y ajoute 20 % (en caractères) de paragraphes neufs du splittrainde wikitext-2 contre l'oubli, mélange le tout et le découpe en 13 054 blocs de 256 tokens, puis le confie auTrainerde transformers. Tous les poids du modèle sont entraînés, sur la perte « prochain token ». -
⑦ Forward et backward sur le GPU. Chaque pas traite un lot effectif de 8 blocs (2 blocs, 4 accumulations) : 1 632 pas, taux d'apprentissage 5e-5, calcul en bf16, gradient checkpointing actif, environ 11 min.
-
⑧ Mesure après. Les mêmes questions, plus 800 questions déjà vues à l'entraînement (ce que le modèle a appris par cœur), et la même perplexité générale.
-
⑨ Calcul sur le GPU, avec le même décodage qu'en ⑤.
-
⑩ Écriture du modèle complet dans
sorties/01-pre-entrainement-continu/modele/. -
⑪ Écriture du rapport dans
sorties/01-pre-entrainement-continu/resultats.json, avec le même tableau affiché dans le terminal.
Témoin. Avant ⑪, le modèle de base est rechargé et entraîné de la même façon, avec une seule biographie par personnage (formulations et ordre fixes), répétée 5 fois : même nombre de tokens, même nombre de pas. Le papier montre que, sans cette diversité, un modèle entraîné de zéro apprend les biographies par cœur sans savoir en extraire les réponses. temoin: false le désactive.
Ce que fait le GPU. Le processus Python ne calcule presque rien lui-même : PyTorch envoie au GPU des « noyaux CUDA », de petits programmes qui font les multiplications de matrices et l'attention sur les poids et les activations déjà présents dans sa mémoire. En génération (⑤, ⑨), il y a une passe avant par token produit, accélérée par un cache des clés et des valeurs déjà calculées. En entraînement (⑦), chaque pas fait une passe avant, une passe arrière qui calcule les gradients de tous les poids, puis la mise à jour par AdamW, dont l'état existe pour les 494 millions de paramètres.
Ce qui est écrit.
| Fichier | Contenu |
|---|---|
modele/model.safetensors |
Tous les poids du modèle entraîné (2,0 Go, en fp32) |
modele/config.json, generation_config.json |
Architecture et réglages de génération, pour recharger le modèle avec AutoModelForCausalLM.from_pretrained |
modele/tokenizer.json, tokenizer_config.json |
Le tokenizer, copié pour que le dossier se suffise à lui-même |
temoin/ |
Dossier de travail du Trainer pour le témoin, sans point de contrôle |
resultats.json |
Avant, après et témoin : exactitude sur les personnages jamais questionnés (avec intervalle et détail par question), par attribut, sur les questions déjà vues, perplexité générale, trois réponses d'exemple |
config_effective.yaml |
La configuration réellement utilisée, surcharges SET comprises |
Essayer dans le dépôt
| Exemple | Statut | Résultat mesuré | Durée | Commande |
|---|---|---|---|---|
| exemple principal | démontré | questions sur les personnages jamais questionnés 0,001 → 0,9996 ± 0,0007 ; témoin à une biographie 0,997 — perplexité générale 20,2 → 24,2 malgré le replay ; la diversité des formulations n'apporte presque rien sur un modèle pré-entraîné | test : — complet : 25 min |
make test EX=DATA01 |
variante mlm-encodeur |
non prouvé | perte MLM 2,38 → 1,09 — aucune tâche finale mesurée : la perte montre seulement que le modèle complète des fiches au même format | test : 8 s complet : 17 s |
make test EX=DATA01 VAR=mlm-encodeur |
| non testé version grosse infra | jamais exécutée | 01-pre-entrainement-continu/infra/ |
Résultats et durées mesurés sur RTX 5070 Ti Laptop (12 Go, 11,5 Gio utilisables), 30 Go de RAM ; résultats de la configuration complète. make test lance un test rapide sur un petit modèle ; make run lance l'exemple complet ; make verifier contrôle d'abord les prérequis. Installation : Installer et lancer.
make install EXTRAS=1
make test EX=DATA01
make run EX=DATA01
Utilisation
python run.py --quick # SmolLM2-135M, 8 personnages
python run.py # Qwen2.5-0.5B, 400 personnages, ~25 min avec le témoin
python run.py --set temoin=false # sans le témoin, ~12 min
python run.py --set donnees.replay_ratio=0 # sans replay : observer la hausse de perplexite_generale
python run.py --set donnees.source=faits --set donnees.n_entites=40 --set evaluation.n_questions=80 # une fiche par personnage, toutes les questions à la mesure
make graines EX=DATA01 N=3 # trois graines : moyenne et écart type
python variantes/mlm-encodeur/run.py --quick # encodeur RoBERTa
Paramètres principaux
| Clé | Rôle |
|---|---|
modele.nom |
N'importe quel modèle causal HF |
donnees.source |
biographies (protocole Physics of LM 3.1), faits (une fiche par personnage) ou hf (corpus réel : nom, config, colonne) |
donnees.n_entites, n_biographies |
Personnages inventés (la moitié avec questions-réponses à l'entraînement) et biographies par personnage |
temoin |
Même entraînement avec une seule biographie par personnage |
donnees.replay_ratio |
Part de texte général mélangé |
entrainement.longueur_bloc |
Taille des séquences concaténées |
entrainement.lr, epochs |
Voir Principe |
Grosse infra
Pré-entraînement continu impossible en local au-delà de ~1,5B de paramètres en entraînement complet. Adam en bf16 demande ~16 octets par paramètre, sans compter les activations.
-
infra/config.yaml: Llama-3.1-8B, français (FineWeb-2), séquences de 8k, FSDP2. -
infra/lancer.sh: 1 nœud de 8 GPU ; multi-nœuds viacommun/infra/slurm_multinoeud.sbatch. -
Ordres de grandeur : 8B sur 8×H100 ≈ 8 000 tokens/s/GPU, soit ~1,5 jour pour 10 Md de tokens. 70B demande 4 à 8 nœuds.
-
Au-delà de quelques milliards de tokens, charger le corpus en mémoire n'est plus possible. On passe à un pipeline dédié :
- torchtitan ou Nanotron : FSDP2 + parallélisme tensoriel et pipeline, données tokenisées à l'avance, en streaming ;
- NeMo / Megatron-LM sur cluster NVIDIA.
Les réglages (lr, replay, warmup) restent ceux de cet exemple.