AmeliorIA

tekio.org

Exemple de code : Extension de contexte

Ce que le dossier 12-extension-contexte/ fournit pour cette méthode. Principe et références : Extension de contexte.

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/>SmolLM-360M<br/>wikitext-2"]
  Cache[("cache disque<br/>~/.cache/huggingface")]
  subgraph Py["Processus Python"]
    Run["run.py<br/>config RoPE YaRN<br/>blocs de 8192 tokens"]
    Ev["mesurer()<br/>clé cachée, perplexité"]
    Tr["Trainer transformers<br/>200 pas"]
  end
  GPU["GPU CUDA, 12 Go"]
  Out[("sorties/<br/>12-extension-contexte/")]

  Hub -- "① HTTPS GET, 1re fois<br/>poids (1,4 Go), textes" --> Cache
  Cache -- "② lecture des poids" --> Run
  Run -- "③ ⑥ copie des poids<br/>en mémoire GPU" --> GPU
  Run -- "④ ⑦ ⑪ appel Python<br/>trois mesures" --> Ev
  Ev -- "⑤ ⑧ ⑫ noyaux CUDA<br/>passes avant longues" --> 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=FORM12 vérifie les prérequis (modules, GPU), puis lance run.py dans l'environnement .venv. Le script lit config.yaml (modèle, méthode yarn, facteur 4, entraînement, longueurs testées). SmolLM-360M a été pré-entraîné avec un contexte de 2 048 tokens ; l'exemple le porte à 8 192. Les textes viennent de wikitext-2 : jusqu'à 6 000 paragraphes du split train pour l'entraînement, et 4 documents longs de 60 paragraphes chacun, tirés du split test, pour la perplexité. Le test de la clé cachée est généré en mémoire : un nombre à 5 chiffres placé au hasard dans un texte de remplissage répété.

  • ① Téléchargement. Au premier lancement, la bibliothèque datasets télécharge wikitext-2 et transformers télécharge le tokenizer et les poids de SmolLM-360M (1,4 Go, safetensors en fp32), 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 du modèle d'origine sur le GPU, en bf16, avec sa configuration RoPE inchangée.
  • ④ Mesure du modèle d'origine. Pour chaque longueur (1 024, 2 048, 4 096 et 7 000 tokens), 10 textes cachent chacun une clé. La clé est juste si elle est la plus probable parmi 10 candidates. La perplexité est calculée sur les 4 documents longs, coupés à 8 192 tokens.
  • ⑤ Passes avant sur le GPU. Chaque candidate demande une passe avant sur tout le texte, sans génération : 100 passes par longueur. Le modèle d'origine est ensuite retiré de la mémoire.
  • ⑥ Rechargement avec YaRN. run.py modifie la configuration (rope_parameters : rope_type: yarn, factor: 4.0, original_max_position_embeddings: 2048, max_position_embeddings: 8192) puis recharge les mêmes poids sur le GPU. Seul le calcul des rotations de RoPE change : les poids sont identiques.
  • ⑦ Mesure après mise à l'échelle seule, sans aucun entraînement.
  • ⑧ Passes avant sur le GPU, comme en ⑤.
  • ⑨ Fine-tuning long. Les paragraphes d'entraînement sont concaténés puis découpés en blocs de 8 192 tokens (123 blocs), confiés au Trainer de transformers : 200 pas, chacun sur 8 blocs (lot de 1, accumulation 8), taux d'apprentissage 2e-5 après 20 pas de montée. Tous les poids sont entraînés.
  • ⑩ Forward et backward sur le GPU, sur des séquences de 8 192 tokens, avec gradient checkpointing.
  • ⑪ Mesure après fine-tuning.
  • ⑫ Passes avant sur le GPU, comme en ⑤.
  • ⑬ Écriture du modèle et de son tokenizer dans sorties/12-extension-contexte/modele-yarn/.
  • ⑭ Écriture du rapport dans sorties/12-extension-contexte/resultats.json, avec le même tableau affiché dans le terminal.

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. Ici, le coût vient de la longueur des séquences : l'attention compare chaque token à tous ceux qui le précèdent, et les activations d'une séquence de 8 192 tokens occupent bien plus de mémoire que les poids d'un modèle de 360 millions de paramètres. Les mesures (⑤, ⑧, ⑫) ne font que des passes avant. En entraînement (⑩), chaque pas fait 8 passes avant et arrière, une par bloc, en cumulant les gradients, puis une mise à jour de tous les poids par AdamW. Le gradient checkpointing ne garde qu'une partie des activations et recalcule les autres pendant la passe arrière, ce qui fait tenir des blocs de 8 192 tokens. Le pic mesuré est d'environ 8 Go de mémoire GPU.

Ce qui est écrit.

Fichier Contenu
modele-yarn/model.safetensors Le modèle complet après fine-tuning (724 Mo, en bf16)
modele-yarn/config.json L'architecture, avec la configuration RoPE YaRN et max_position_embeddings: 8192 : le modèle se recharge directement en contexte 8 192 avec AutoModelForCausalLM.from_pretrained
modele-yarn/generation_config.json Les réglages de génération
modele-yarn/tokenizer.json, tokenizer_config.json Le tokenizer, copié pour que le dossier se suffise à lui-même
modele-yarn/training_args.bin Les réglages d'entraînement utilisés
resultats.json Pour origine, echelle_seule et apres_finetuning : le taux de clés retrouvées à chaque longueur (cle_1024 à cle_7000) et perplexite_8192
config_effective.yaml La configuration réellement utilisée, surcharges SET comprises

Avec SET="entrainement.max_steps=0", il n'y a pas de fine-tuning : le modèle mis à l'échelle est sauvegardé tel quel et resultats.json ne contient que origine et echelle_seule.

Essayer dans le dépôt

Exemple Statut Résultat mesuré Durée Commande
exemple principal démontré perplexité à 8 192 tokens 422 → 19 ; clé retrouvée à 7 000 tokens 0,3 → 1,0 — n = 10 clés test : 15 s
complet : 33 min
make test EX=FORM12
non testé version grosse infra jamais exécutée 12-extension-contexte/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=FORM12
make run EX=FORM12

Utilisation

python run.py --quick
python run.py                                        # SmolLM-360M 2k -> 8k, YaRN + 200 pas
python run.py --set contexte.methode=linear
python run.py --set contexte.methode=dynamic --set entrainement.max_steps=0    # NTK dynamique sans entraînement
python run.py --set contexte.methode=abf --set contexte.facteur_theta=20

Paramètres principaux

Clé Rôle
contexte.methode, facteur Type de mise à l'échelle et multiplicateur de longueur
contexte.facteur_theta Pour abf
entrainement.longueur Longueur des séquences d'entraînement (= contexte visé)
evaluation.longueurs Longueurs du test de la clé cachée, dont certaines au-delà de la longueur d'origine

Grosse infra

  • Local : 8k tokens sur un modèle de 360M. La mémoire des activations croît linéairement avec la longueur (flash/SDPA attention) : 32k sur un 7B demande des GPU 80 Go.
  • infra/config.yaml : recette YaRN sur Mistral-7B, 8k → 32k, FSDP sur 8×H100, 400 pas.
  • infra/axolotl_yarn_128k.yml : 128k avec parallélisme de séquence (ring-flash-attn, une séquence répartie sur 4 GPU). Indispensable au-delà de ~32k. Alternatives : torchtitan / Megatron « context parallel ».
  • Évaluation : RULER, LongBench v2, needle-in-a-haystack, servis par vLLM (--max-model-len).