AmeliorIA

tekio.org

Exemple de code : Croissance d'architecture

Ce que le dossier 14-croissance-architecture/ fournit pour cette méthode. Principe et références : Croissance d'architecture.

Ce que fait l'exemple

Le besoin : apprendre à un modèle une langue ou un domaine qu'il connaît mal, sans lui faire oublier ce qu'il sait. Le pré-entraînement continu classique apprend le domaine mais dégrade le reste. LLaMA Pro ajoute des couches neuves et n'entraîne qu'elles : les poids d'origine ne bougent pas.

Résultats (SmolLM2-360M, RTX 5070 Ti Laptop ; 200 articles bretons et 100 paragraphes anglais jamais vus ; 3 graines, make graines EX=FORM14 N=3, moyenne ± écart type). Plus la perplexité est basse, mieux le modèle connaît la langue :

Paramètres entraînés Perplexité en breton Perplexité en anglais
Modèle d'origine 145,6 19,86
LLaMA Pro, 600 pas 78,7 M 10,9 ± 0,3 22,0 ± 0,2
Témoin entraîné en entier, au pas 150 (même niveau en breton) 361,8 M 10,3 ± 0,2 23,6 ± 0,1
Témoin entraîné en entier, 600 pas 361,8 M 7,8 ± 0,1 26,5 ± 0,5
  • À niveau égal en breton, LLaMA Pro oublie moins. Sa perplexité en anglais monte de 2,1 points, celle du témoin de 3,7. L'écart est de 1,57 ± 0,21 point (1,34 à 1,74 selon la graine), et la plus mauvaise graine de LLaMA Pro (22,1) reste sous la meilleure du témoin (23,5). Au point de comparaison, le témoin est même un peu meilleur en breton : la comparaison le favorise.
  • L'écart se retrouve tout au long de l'entraînement. À 20 de perplexité en breton, par exemple, LLaMA Pro est à 21,1 en anglais et le témoin à environ 21,9 (courbes dans resultats.json).
  • Le prix. LLaMA Pro met 4 fois plus de pas pour atteindre ce niveau en breton, et le modèle garde 22 % de paramètres en plus à l'inférence.
  • Réserves. Modèle de 360 M paramètres et un seul domaine ; la perplexité est mesurée sur des textes fixes. LLaMA Pro limite l'oubli sans le supprimer : la passe avant change dès que les nouvelles couches apprennent.

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/>SmolLM2-360M<br/>Wikipédia en breton, wikitext-2"]
  Cache[("cache disque<br/>~/.cache/huggingface")]
  subgraph Py["Processus Python"]
    Run["run.py<br/>charge le modèle<br/>et les textes"]
    Ev["evaluation.py<br/>deux perplexités"]
    Cr["croissance.py<br/>32 → 40 couches"]
    Tr["Trainer transformers<br/>8 nouvelles couches"]
  end
  GPU["GPU CUDA, 12 Go"]
  Out[("sorties/14-croissance-<br/>architecture/")]

  Hub -- "① HTTPS GET, 1re fois<br/>poids et textes" --> Cache
  Cache -- "② lecture des poids<br/>et des textes" --> Run
  Run -- "③ copie des poids<br/>en mémoire GPU" --> GPU
  Run -- "④ ⑧ ⑫ appel Python<br/>trois mesures" --> Ev
  Ev -- "⑤ ⑨ ⑬ noyaux CUDA<br/>forward" --> GPU
  Run -- "⑥ appel Python<br/>expansion_blocs()" --> Cr
  Cr -- "⑦ copie de couches<br/>en mémoire GPU" --> GPU
  Run -- "⑩ appel Python<br/>trainer.train()" --> Tr
  Tr -- "⑪ noyaux CUDA<br/>forward, backward" --> GPU
  Tr -- "⑭ écriture<br/>modèle agrandi" --> Out
  Run -- "⑮ écriture<br/>resultats.json" --> Out

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

make run EX=FORM14 vérifie les prérequis (modules, GPU), puis lance run.py dans l'environnement .venv. Le script lit config.yaml (modèle, méthode de croissance, domaine, réglages). Par défaut, SmolLM2-360M passe de 32 à 40 couches par block expansion (methode: expansion_blocs, tous_les: 4), puis apprend le breton en 600 pas où seules les 8 couches ajoutées sont entraînées. Deux jeux de textes, téléchargés depuis le Hugging Face Hub :

  • Domaine à apprendre : 5 000 articles tirés au hasard de la Wikipédia en breton (wikimedia/wikipedia, 20231101.br). Un article sur cinq est mis de côté, dont 200 servent au test ; les autres servent à l'entraînement.

  • Ce qu'on ne doit pas perdre : 100 paragraphes d'anglais général du split test de wikitext-2.

  • ① Téléchargement. Au premier lancement, transformers télécharge les poids de SmolLM2-360M (environ 700 Mo, fichiers safetensors), et datasets télécharge la Wikipédia en breton et wikitext-2, 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. run.py y calcule aussitôt les logits du modèle d'origine sur une sonde de 64 tokens, gardés pour la comparaison de ⑧.

  • ④ Mesure de l'origine. run.py compte les paramètres (361,8 millions) et les couches (32), puis appelle commun/evaluation.py pour les deux perplexités : 200 articles bretons et 100 paragraphes anglais, tronqués à 256 tokens.

  • ⑤ Forward sur le GPU. Une passe avant par lot ; la perplexité est l'exponentielle de la perte moyenne de prédiction du token suivant.

  • ⑥ Croissance. run.py appelle croissance.expansion_blocs : après chaque groupe de 4 couches, une copie de la dernière est insérée, avec ses projections de sortie (o_proj, down_proj) mises à zéro. La nouvelle couche renvoie exactement son entrée par la connexion résiduelle. Les indices de couche utilisés par le cache KV sont renumérotés.

  • ⑦ Copie de couches sur le GPU. Les 8 couches ajoutées sont copiées directement dans la mémoire du GPU : le modèle passe à 440,5 millions de paramètres.

  • ⑧ Mesure du modèle transformé. Mêmes mesures qu'en ④, plus l'écart maximal entre ses logits et ceux de l'origine sur la sonde de ③ : 0, le modèle agrandi est identique à l'original.

  • ⑨ Forward sur le GPU, comme en ⑤.

  • ⑩ Entraînement sur le breton. Les 32 couches d'origine, les embeddings et la tête de sortie sont figés : seules les 8 nouvelles couches apprennent, soit 78,7 millions de paramètres. run.py confie le modèle au Trainer de transformers. Les articles d'entraînement sont tokenisés, concaténés et découpés en 3 181 blocs de 512 tokens. Tous les 50 pas, un rappel (Courbe) remesure les deux perplexités.

  • ⑪ Forward et backward sur le GPU. Chaque pas traite 16 blocs (lots de 2, accumulation sur 8) : passe avant, perte du token suivant, passe arrière, mise à jour. 600 pas, soit environ 3 passages sur les données, taux d'apprentissage 1e-4 en cosinus après 50 pas de chauffe, gradient checkpointing activé.

  • ⑫ Mesure après entraînement. Les mêmes textes de test sont repassés dans le modèle à 40 couches.

  • ⑬ Forward sur le GPU, comme en ⑤.

  • ⑭ Écriture du modèle agrandi et de son tokenizer dans sorties/14-croissance-architecture/modele-expansion_blocs/.

  • ⑮ Écriture du rapport dans sorties/14-croissance-architecture/resultats.json, avec le même tableau affiché dans le terminal.

Témoin. Avant ⑮, le modèle agrandi quitte le GPU et SmolLM2-360M d'origine (32 couches) y est rechargé. Il est entraîné en entier, comme dans un pré-entraînement continu classique : mêmes textes, mêmes 600 pas, mêmes réglages, mêmes relevés tous les 50 pas, puis il est mesuré comme en ⑫. Le témoin apprend plus vite. On cherche donc le premier relevé où il atteint le niveau en breton que LLaMA Pro a en fin d'entraînement, puis on compare leurs perplexités en anglais à ce moment-là (section a_domaine_egal). 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. Il n'y a pas de génération : les mesures (⑤, ⑨, ⑬ et les relevés) sont de simples passes avant sur des textes connus. La croissance (⑦) n'est qu'une copie de tenseurs d'une zone de la mémoire du GPU à une autre. Pendant l'entraînement de LLaMA Pro (⑪), la passe arrière traverse tout le modèle, mais seuls les gradients et l'état de l'optimiseur AdamW des 8 nouvelles couches sont gardés. Le témoin, lui, entraîne ses 361,8 millions de paramètres. Un seul modèle occupe la mémoire du GPU à la fois.

Ce qui est écrit.

Fichier Contenu
modele-expansion_blocs/model.safetensors Les poids du modèle à 40 couches après entraînement (1,8 Go, en float32)
modele-expansion_blocs/config.json, generation_config.json L'architecture agrandie (num_hidden_layers: 40) et les réglages de génération, pour recharger le modèle avec AutoModelForCausalLM.from_pretrained
modele-expansion_blocs/tokenizer.json, tokenizer_config.json Le tokenizer, copié pour que le dossier se suffise à lui-même
modele-expansion_blocs/training_args.bin Les réglages d'entraînement utilisés
temoin/ Dossier de travail du Trainer pour le témoin, sans point de contrôle
resultats.json Pour l'origine, le modèle transformé, le modèle entraîné et le témoin : paramètres, paramètres entraînés, couches, perplexités du domaine et générale ; écart de logits du modèle transformé ; courbes des deux entraînements et comparaison à domaine égal
config_effective.yaml La configuration réellement utilisée, surcharges SET comprises

Avec SET="croissance.methode=profondeur" ou "croissance.methode=moe", le dossier du modèle s'appelle modele-profondeur/ ou modele-moe/.

Essayer dans le dépôt

Exemple Statut Résultat mesuré Durée Commande
exemple principal démontré breton 145,6 → 10,9 ; anglais 19,9 → 22,0 ; témoin au même niveau en breton : anglais 23,6 (écart 1,57 ± 0,21, 3 graines) — LLaMA Pro met 4 fois plus de pas pour atteindre ce niveau en breton et garde 22 % de paramètres en plus test : 13 s
complet : 55 min
make test EX=FORM14
non testé version grosse infra jamais exécutée 14-croissance-architecture/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=FORM14
make run EX=FORM14

Utilisation

python run.py --quick
python run.py                                                   # SmolLM2-360M 32 -> 40 couches (LLaMA Pro), breton, ~55 min avec le témoin
python run.py --set domaine.config=20231101.oc                  # une autre langue : occitan
python run.py --set croissance.methode=profondeur               # 32 -> 48 couches (SOLAR), tout est entraîné
make graines EX=FORM14 N=3                                      # trois graines : moyenne et écart type (~3 h)
python run.py --set croissance.methode=moe --set croissance.n_experts=4 --set modele.dtype=auto --set entrainement.optim=adamw_bnb_8bit   # ~1B paramètres : bf16 + AdamW 8 bits
python run.py --set domaine=null                                # sans domaine : cicatrisation sur l'anglais général (wikitext)

Paramètres principaux

Clé Rôle
croissance.methode profondeur, expansion_blocs ou moe
croissance.m Chevauchement SOLAR : couches totales = 2(n-m)
croissance.tous_les Fréquence des blocs identité
croissance.n_experts, top_k, bruit_experts Configuration MoE
domaine.* Le domaine à apprendre (jeu Hugging Face, colonne, nombre d'articles et de tests) ; sans cette section, l'entraînement porte sur wikitext
entrainement.* Pré-entraînement continu
suivi_tous_les Intervalle des relevés de perplexité pendant l'entraînement
temoin Entraîner aussi le modèle d'origine en entier, pour comparaison

Grosse infra

  • La transformation est instantanée et se fait sur CPU, même pour un 70B :
  • La cicatrisation est un pré-entraînement continu multi-nœuds (infra/config.yaml, infra/lancer.sh, ou 01 infra).
  • Pour l'entraînement de MoE à grande échelle, le parallélisme d'experts devient nécessaire : Megatron-LM / NeMo (upcycling intégré), torchtitan, DeepSpeed-MoE.