Exemple de code : Fusion de modèles
Ce que le dossier 08-fusion-modeles/ fournit pour cette méthode. Principe et références : Fusion de modèles.
Ce que fait l'exemple
- Évalue chaque modèle source sur GSM8K (100 questions) et sur la perplexité générale.
- Fusionne avec la méthode choisie (DARE-TIES par défaut) le vecteur de tâche de Qwen2.5-1.5B-Instruct, par rapport à la base commune Qwen2.5-1.5B : seules 30 % de ses coordonnées sont gardées, puis rééchelonnées.
- Évalue le modèle fusionné. L'exemple montre le mécanisme : le modèle garde l'essentiel du gain de l'Instruct malgré 70 % des coordonnées abandonnées. Réunir plusieurs compétences demande d'ajouter d'autres fine-tunes de la même base dans
modeles.
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-1.5B, Instruct<br/>GSM8K, wikitext"]
Cache[("cache disque<br/>~/.cache/huggingface")]
subgraph Py["Processus Python"]
Run["run.py<br/>charge les modèles"]
Ev["evaluation.py<br/>génération, perplexité"]
Fu["fusion.py<br/>DARE-TIES"]
end
GPU["GPU CUDA, 12 Go"]
CPU["CPU et RAM"]
Out[("sorties/<br/>08-fusion-modeles/")]
Hub -- "① HTTPS GET, 1re fois<br/>poids, jeux de données" --> Cache
Cache -- "② ⑥ lecture<br/>des poids" --> Run
Run -- "③ ⑨ copie des poids<br/>en mémoire GPU" --> GPU
Run -- "④ ⑩ appel Python<br/>sources, puis fusion" --> Ev
Ev -- "⑤ ⑪ noyaux CUDA<br/>génération, perplexité" --> GPU
Run -- "⑦ appel Python<br/>fusionner_etats()" --> Fu
Fu -- "⑧ calcul CPU<br/>tenseur par tenseur" --> CPU
Run -- "⑫ écriture<br/>modèle, resultats.json" --> Out
GPU ~~~ Out
class Hub externe
class Run,Ev,Fu code
class GPU,CPU gpu
class Cache,Out disque
make run EX=EDIT08 vérifie les prérequis (modules, GPU), puis lance run.py dans l'environnement .venv. Le script lit config.yaml : méthode dare_ties, base commune Qwen2.5-1.5B, un modèle source Qwen2.5-1.5B-Instruct de poids 1,0, densité 0,3. Il n'y a aucun entraînement : les données ne servent qu'à mesurer, sur 100 problèmes de GSM8K (split test) et sur la perplexité de 50 paragraphes Wikipédia (wikitext-2, split test).
- ① Téléchargement. Au premier lancement, transformers et datasets téléchargent depuis le Hugging Face Hub, par HTTPS, les poids de Qwen2.5-1.5B et de Qwen2.5-1.5B-Instruct (environ 3 Go chacun), le tokenizer de l'Instruct et les jeux GSM8K et wikitext-2.
- ② Lecture. Tout est rangé dans le cache
~/.cache/huggingface; les lancements suivants le relisent sur le disque, sans réseau. Chaque modèle à mesurer est lu à son tour. - ③ Copie sur le GPU. Le modèle mesuré est copié en bf16 dans la mémoire du GPU, puis renvoyé en RAM une fois mesuré : il n'y en a qu'un à la fois sur la carte.
- ④ Mesure des sources.
run.pyappellecommun/evaluation.pypour la base, puis pour l'Instruct. - ⑤ Génération et perplexité sur le GPU. Chaque modèle répond aux 100 problèmes GSM8K, par lots de 16, jusqu'à 384 tokens ; l'évaluation compare le nombre final au résultat attendu. L'évaluation calcule aussi la perplexité sur les 50 paragraphes wikitext, qui détecte une dégradation générale du modèle.
- ⑥ Lecture des poids pour la fusion. Les poids de la base et de l'Instruct sont relus et gardés en RAM, en bf16, sous forme de dictionnaires de tenseurs.
- ⑦ Fusion.
run.pyappellefusion.py, écrit en PyTorch pur, sans bibliothèque de fusion. - ⑧ Calcul sur le CPU.
fusion.pymesure d'abord l'écart relatif de l'Instruct à la base (1,2 % ici : c'est bien un fine-tune de cette base). Puis, pour chaque tenseur, il calcule le vecteur de tâche (Instruct − base), en garde 30 % des coordonnées tirées au hasard, multiplie celles-ci par 1/0,3 (DARE), applique l'élection de signe de TIES et ajoute le résultat à la base. Avec une seule source, l'élection de signe ne retire rien. - ⑨ Copie du modèle fusionné sur le GPU. Les tenseurs fusionnés sont chargés dans un modèle de même architecture, puis copiés en mémoire GPU.
- ⑩ Mesure du modèle fusionné, par le même appel qu'en ④.
- ⑪ Génération et perplexité sur le GPU, avec le même décodage qu'en ⑤.
- ⑫ Écriture du modèle et du rapport. Le modèle fusionné complet est écrit dans
sorties/08-fusion-modeles/modele-dare_ties/, puisresultats.json, avec le même tableau affiché dans le terminal.
Ce que fait le GPU. Le GPU ne sert qu'à mesurer (⑤, ⑪) : PyTorch y envoie des « noyaux CUDA », de petits programmes qui font les multiplications de matrices et l'attention sur les poids 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 ; pour la perplexité, une seule passe avant par lot de 4 paragraphes, sans génération. La fusion elle-même (⑧) n'a ni passe avant ni gradient : c'est de l'arithmétique sur les poids (soustraction, masque aléatoire, addition), faite sur CPU, tenseur par tenseur, en float32 pour chaque tenseur traité. Elle demande surtout de la RAM : la base et l'Instruct y tiennent ensemble en bf16, avec le résultat de la fusion.
Ce qui est écrit.
| Fichier | Contenu |
|---|---|
modele-dare_ties/model.safetensors |
Tous les poids du modèle fusionné (3,09 Go, en bf16), utilisable comme n'importe quel modèle Hugging Face |
modele-dare_ties/config.json, generation_config.json |
Architecture Qwen2 et réglages de génération, repris de l'Instruct |
modele-dare_ties/tokenizer.json, tokenizer_config.json, chat_template.jinja |
Le tokenizer et le format de conversation de l'Instruct |
resultats.json |
Pour la base, l'Instruct et le modèle fusionné : exactitude GSM8K, nombre de réponses, durée, trois réponses d'exemple, perplexité wikitext ; écart relatif de l'Instruct à la base |
config_effective.yaml |
La configuration réellement utilisée, surcharges SET comprises |
Avec SET="methode=...", le modèle fusionné est écrit dans modele-<methode>/.
Essayer dans le dépôt
| Exemple | Statut | Résultat mesuré | Durée | Commande |
|---|---|---|---|---|
| exemple principal | démontré | GSM8K : base 0,07 ; Instruct 0,51 ; fusion DARE-TIES 0,55 — démontre le mécanisme (n = 100) ; scénario multi-compétences à faire | test : 21 s complet : 3 min |
make test EX=EDIT08 |
| non testé version grosse infra | jamais exécutée | 08-fusion-modeles/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=EDIT08
make run EX=EDIT08
Utilisation
python run.py --quick # moyenne SmolLM2 base + instruct
python run.py # DARE-TIES (densité 0,3) : Qwen2.5-1.5B + vecteur de tâche de l'Instruct
python run.py --set methode=ties
python run.py --set methode=slerp --set base=null --set t_slerp=0.3
python run.py --set methode=arithmetique_taches
Paramètres principaux
| Clé | Rôle |
|---|---|
methode |
Voir le tableau |
base |
Modèle d'origine commun (null pour lineaire et slerp) |
modeles[].poids |
λ de chaque source. Une somme > 1 est courante avec TIES et DARE |
densite |
TIES/DARE : part conservée de chaque vecteur de tâche (0,2 à 0,7) |
t_slerp |
Position entre les deux modèles |
Grosse infra
- Pas besoin de cluster pour fusionner : mergekit fusionne un 70B avec ~32 Go de RAM en chargeant les tenseurs un par un (
--lazy-unpickle). infra/ties_70b.yml: TIES entre trois fine-tunes de Llama-3.1-70B.infra/slerp_par_couche.yml: SLERP dont le coefficient varie par couche et par type (attention / MLP).infra/evolve.yml+mergekit-evolve: fusion évolutionnaire. Des centaines de candidats, chacun évalué : c'est là que les GPU sont nécessaires (vLLM, plusieurs nœuds via Ray).infra/config.yaml:run.pysur trois modèles 7B (DARE-TIES).