AmeliorIA

tekio.org

Exemple de code : Élagage

Pas encore démontré. L'exemple de code de cette méthode s'exécute, mais son résultat ne prouve pas encore le gain de la méthode. 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 16-elagage/ fournit pour cette méthode. Principe et références : Élagage.

Ce que fait l'exemple

Le besoin : réduire le coût d'un modèle en retirant la moitié de ses poids, sans perdre la tâche qu'il sait faire.

Résultats (Qwen2.5-0.5B-Instruct, RTX 5070 Ti Laptop ; 300 problèmes, intervalles à 95 %) :

Exactitude sur la tâche Perplexité générale Tokens/s
Modèle d'origine 0,88 22,3 139
Wanda 50 %, juste après l'élagage 0,34 37,9 142
Wanda 50 %, après cicatrisation 0,66 [0,605 ; 0,711] 25,3 119
2:4, juste après l'élagage 0,01 106,8 142
2:4, après cicatrisation 0,38 30,4 116
Largeur : 30 % des neurones MLP retirés (494 → 400 M paramètres), après cicatrisation 0,14 [0,102 ; 0,180] 27,7 118
Couches : 6 blocs sur 24 retirés (494 → 405 M paramètres), après cicatrisation 0,09 [0,063 ; 0,128] 26,7 148
  • La cicatrisation récupère une partie de la tâche, pas toute : Wanda reste 0,22 sous l'original ([−0,27 ; −0,17]), 2:4 0,50 sous.
  • Aucun gain de vitesse en PyTorch standard pour Wanda et 2:4 : les zéros sont stockés et multipliés comme les autres poids. Le 2:4 n'accélère qu'avec des noyaux dédiés (vLLM, TensorRT).
  • L'élagage structuré rend le modèle réellement plus petit, mais la tâche s'effondre. Retirer 6 couches accélère la génération de 8 % pour 18 % de paramètres en moins ; la tâche ne revient qu'à 0,09. La perplexité générale, elle, revient près de l'original (26,7 contre 22,3) : la cicatrisation restaure la langue, pas la compétence.
  • Conclusion : à cette taille et à ce budget, l'élagage ne paie pas. Un modèle de 0,5B a peu de redondance, et 1 000 pas de distillation (environ 4 millions de tokens) ne suffisent pas. Les gains publiés (Minitron : 8B → 4B) portent sur des modèles bien plus grands, cicatrisés sur des dizaines de milliards de tokens.

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-Instruct<br/>wikitext-2, Alpaca"]
  Cache[("cache disque<br/>~/.cache/huggingface")]
  subgraph Py["Processus Python"]
    Run["run.py<br/>génère les problèmes<br/>charge le modèle"]
    El["elagage.py<br/>Wanda 50 %"]
    Tr["Trainer transformers<br/>distillation"]
  end
  GPU["GPU CUDA, 12 Go"]
  Out[("sorties/16-elagage/")]

  Hub -- "① HTTPS GET, 1re fois<br/>poids (1 Go), textes" --> Cache
  Cache -- "② lecture des poids<br/>et des textes" --> Run
  Run -- "③ ⑥ copie des poids<br/>④⑤ ⑨⑩ ⑬⑭ mesures<br/>conversations" --> GPU
  Run -- "⑦ appel Python<br/>calibration, masques" --> El
  El -- "⑧ noyaux CUDA<br/>forward, mise à zéro" --> GPU
  Run -- "⑪ appel Python<br/>trainer.train()" --> Tr
  Tr -- "⑫ noyaux CUDA<br/>forward, backward" --> GPU
  Run -- "⑮ ⑯ écriture" --> Out

  GPU ~~~ Out
  class Hub externe
  class Run,El,Tr code
  class GPU gpu
  class Cache,Out disque

make run EX=FORM16 vérifie les prérequis (modules, GPU), puis lance run.py dans l'environnement .venv. Le script lit config.yaml (modèle, méthode d'élagage, cicatrisation, données, évaluation) : par défaut, Qwen2.5-0.5B-Instruct est élagué par Wanda à 50 % (methode: wanda, sparsite: 0.5), puis cicatrisé par distillation depuis une copie de l'original (cicatrisation.mode: distillation). Les 300 problèmes de test, de la forme a op b, sont générés en mémoire, sans téléchargement. Les textes viennent de wikitext-2, téléchargé depuis le Hugging Face Hub : 128 paragraphes du split train pour la calibration, 4 000 pour la cicatrisation, 50 du split test pour la perplexité. Les 1 765 demandes générales des conversations viennent du jeu Alpaca (tatsu-lab/alpaca).

  • ① Téléchargement. Au premier lancement, transformers télécharge les poids de Qwen2.5-0.5B-Instruct (environ 1 Go, fichiers safetensors) et datasets télécharge wikitext-2 et Alpaca, 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 float32 dans la mémoire du GPU : c'est le modèle qui sera élagué.
  • ④ Mesure de l'origine. run.py relève les paramètres (494 millions), la part de poids nuls dans les couches linéaires et le débit en génération (32 tokens après un préchauffage), puis appelle commun/evaluation.py pour la perplexité sur les 50 paragraphes et l'exactitude sur les 300 problèmes.
  • ⑤ Génération et forward sur le GPU. La perplexité demande une passe avant par lot de 4 paragraphes. L'exactitude fait répondre le modèle par lots de 16, token par token, jusqu'à 256 tokens, puis compare le nombre final de chaque réponse au résultat attendu.
  • Conversations. Le modèle d'origine répond aux 1 765 demandes générales, par lots de 32, jusqu'à 512 tokens. Les réponses sont gardées dans sorties/cache-remelange/, cache partagé avec le remélange de DATA02 et DATA03 : les lancements suivants les relisent sans rien générer.
  • ⑥ Copie de l'enseignant. run.py duplique le modèle d'origine dans la mémoire du GPU, en bf16 et figé : il servira de référence pendant la distillation.
  • ⑦ Élagage. run.py appelle elagage.py, qui pose des points d'écoute sur les couches linéaires (q_proj, k_proj, v_proj, o_proj, gate_proj, up_proj, down_proj) de chaque bloc.
  • ⑧ Calibration et mise à zéro sur le GPU. Les 128 paragraphes de calibration, tronqués à 256 tokens, traversent le modèle sans rétropropagation ; les points d'écoute cumulent la norme ‖X_j‖₂ de chaque colonne d'entrée. Chaque poids reçoit le score |W_ij| · ‖X_j‖₂, et la moitié de plus faible score de chaque ligne est mise à zéro. Les masques booléens sont gardés pour la suite.
  • ⑨ Mesure du modèle élagué. Mêmes mesures qu'en ④ : le nombre de paramètres ne change pas, la sparsité passe à 0,5.
  • ⑩ Génération et forward sur le GPU, comme en ⑤.
  • ⑪ Cicatrisation. run.py confie l'élève élagué et l'enseignant à un Trainer de transformers dont la perte est la divergence KL entre leurs distributions de sortie, token par token. Les 4 000 paragraphes et les 1 765 conversations sont mélangés, tokenisés, concaténés et découpés en blocs de 256 tokens. Après chaque pas, le rappel GarderMasques d'elagage.py réapplique les masques : les zéros restent des zéros.
  • ⑫ Forward et backward sur le GPU. Chaque pas traite 16 blocs (lots de 2, accumulation sur 8) : passe avant de l'élève, passe avant de l'enseignant sans gradient, perte KL, passe arrière, mise à jour par AdamW 8 bits. 1 000 pas, soit environ 3,5 passages sur les données, taux d'apprentissage 2e-5 après 20 pas de chauffe, gradient checkpointing activé.
  • ⑬ Mesure après cicatrisation. Mêmes mesures qu'en ④ sur le modèle cicatrisé.
  • ⑭ Génération et forward sur le GPU, comme en ⑤.
  • ⑮ Écriture du modèle élagué et cicatrisé et de son tokenizer dans sorties/16-elagage/modele-wanda/.
  • ⑯ Écriture du rapport dans sorties/16-elagage/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. 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. Les poids mis à zéro restent stockés et multipliés comme les autres : sans moteur sparse, l'élagage non structuré n'allège ni la mémoire ni le calcul. Pendant la cicatrisation, trois choses coexistent dans la mémoire du GPU : l'élève en float32 (environ 2 Go), l'enseignant en bf16 (environ 1 Go), l'état de l'optimiseur AdamW 8 bits et les masques booléens (1 octet par poids élagable). Chaque pas fait la passe avant de l'enseignant, la passe avant et la passe arrière de l'élève, puis la mise à jour. Le pic mesuré, sur un calibrage aux mêmes réglages de modèle et d'entraînement, est d'environ 8,9 Go.

Ce qui est écrit.

Fichier Contenu
modele-wanda/model.safetensors Les poids du modèle élagué puis cicatrisé (2,0 Go, en float32). Les zéros sont stockés comme les autres valeurs : le fichier a la taille du modèle d'origine en float32
modele-wanda/config.json, generation_config.json L'architecture, inchangée, et les réglages de génération, pour recharger le modèle avec AutoModelForCausalLM.from_pretrained
modele-wanda/tokenizer.json, tokenizer_config.json, chat_template.jinja Le tokenizer et le format de conversation, copiés pour que le dossier se suffise à lui-même
resultats.json Pour l'origine, le modèle élagué et le modèle cicatrisé : paramètres, sparsité des couches linéaires, tokens par seconde, perplexité générale, exactitude sur les 300 problèmes avec la durée de l'évaluation et trois réponses d'exemple
config_effective.yaml La configuration réellement utilisée, surcharges SET comprises

Avec une autre méthode (SET="methode=..."), le dossier du modèle prend son nom (modele-magnitude/, modele-2-4/, modele-couches/, modele-largeur/).

Essayer dans le dépôt

Exemple Statut Résultat mesuré Durée Commande
exemple principal non prouvé tâche 0,88 → 0,34 → 0,66 (Wanda 50 %) ; 2:4 : 0,38 ; structuré : largeur 0,14, couches 0,09 — à 0,5B et 1 000 pas de cicatrisation, l'élagage ne paie pas : la tâche ne revient pas test : 21 s
complet : 20 min
make test EX=FORM16
non testé version grosse infra jamais exécutée 16-elagage/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=FORM16
make run EX=FORM16

Utilisation

python run.py --quick
python run.py                                                  # Wanda 50 % + distillation, Qwen2.5-0.5B-Instruct, ~20 min
python run.py --set modele.nom=Qwen/Qwen2.5-1.5B-Instruct --set cicatrisation.mode=aucune   # 1,5B : sans cicatrisation
python run.py --set methode=magnitude --set cicatrisation.mode=aucune    # comparer à Wanda sans cicatrisation
python run.py --set methode=2:4
python run.py --set cicatrisation.n_conversations=0             # cicatrisation sur Wikipédia seulement
python run.py --set methode=couches --set n_couches=6
python run.py --set methode=largeur --set ratio_largeur=0.3 --set cicatrisation.mode=lm

Paramètres principaux

Clé Rôle
methode Voir le tableau
sparsite, n_couches, ratio_largeur Intensité selon la méthode
calibration.n Textes de calibration (Wanda, importance des couches et des neurones)
cicatrisation.mode, cicatrisation.entrainement.* Récupération
cicatrisation.n_textes, n_conversations Paragraphes Wikipédia et conversations lus pendant la cicatrisation

Grosse infra

  • L'élagage reste léger : Wanda ou SparseGPT sur un 70B se font couche par couche sur 1 à 2 GPU (llm-compressor, infra/lancer.sh).
  • La cicatrisation par distillation est coûteuse. Minitron distille sur ~100 Md de tokens pour un 8B → 4B : c'est un travail multi-nœuds (infra/config.yaml, Slurm).
  • Outillage industriel : NVIDIA TensorRT Model Optimizer + NeMo (élagage profondeur, largeur, têtes, dimension cachée ; distillation), llm-compressor (SparseGPT 2:4 → vLLM).