Créez votre propre IA en fusionnant des modèles existants : le tutoriel complet Mergekit (SLERP, TIES, DARE) sans GPU ni entraînement

Kamleu Noumi Emeric 11 septembre 2026 Tutoriels, Décryptage IA Laissez un commentaire

Créer un modèle d’IA sur mesure, sans GPU et sans entraînement

Voici une phrase qui, il y a encore trois ans, aurait semblé absurde : vous pouvez créer votre propre modèle de langage, personnalisé selon vos besoins précis, sans disposer d’un cluster de GPU, sans jeu de données d’entraînement, et sans écrire une seule ligne de code de deep learning. Le tout en quelques minutes, sur un ordinateur portable ordinaire, voire directement dans un notebook.

Ça s’appelle le model merging, la fusion de modèles, et l’outil de référence pour le faire s’appelle Mergekit. Depuis son apparition, cette technique est devenue un véritable sport communautaire dans l’écosystème open source de l’IA. Sur le célèbre Open LLM Leaderboard, des modèles fusionnés grâce à Mergekit trustent régulièrement les premières places, battant parfois des modèles ayant nécessité des milliers d’heures de calcul GPU pour être entraînés depuis zéro.

Dans ce tutoriel, nous allons décortiquer comment ça fonctionne, comprendre les différentes méthodes de fusion disponibles, et vous guider pas à pas pour créer votre propre modèle fusionné.

Le concept : comprendre le model merging avant de foncer dans le code

L’analogie du mélange de cafés

Pour comprendre intuitivement ce qu’est le model merging, imaginez que vous mélangez des grains de café. Chaque café fine-tuné (spécialisé) apporte une saveur particulière : l’un excelle en code, l’autre en écriture créative, un troisième dans le suivi précis d’instructions. Le model merging consiste à combiner ces différentes saveurs en un seul mélange, dans l’espoir d’obtenir le meilleur de chaque monde à la fois.

Techniquement, voici ce qui se passe : vous prenez deux modèles (ou plus) qui partagent la même architecture de base, et vous combinez directement leurs poids (les paramètres numériques qui constituent le « cerveau » du modèle) pour créer un nouveau modèle unique. Pas de nouvelles données d’entraînement, pas de descente de gradient, juste de l’arithmétique sur des tenseurs et le résultat est étonnamment souvent excellent.

Pourquoi cette technique a explosé en popularité

Entraîner un LLM depuis zéro, ou même simplement le fine-tuner (l’affiner sur une tâche spécifique) demande des ressources considérables : des GPU puissants loués à prix d’or, des heures voire des jours de calcul, et une expertise technique poussée pour éviter les écueils classiques de l’entraînement (surapprentissage, instabilité, catastrophic forgetting…).

Le model merging contourne entièrement ce problème. Puisqu’il s’agit de combinaisons mathématiques de poids déjà entraînés, l’opération est quasiment instantanée et ne nécessite, dans la plupart des cas, aucun GPU, un simple processeur avec suffisamment de RAM suffit pour fusionner des modèles de taille raisonnable (7 à 13 milliards de paramètres).

La condition indispensable : la compatibilité architecturale

Il y a cependant une contrainte technique fondamentale à connaître avant de vous lancer : les modèles que vous voulez fusionner doivent partager la même architecture de base : même nombre de couches, mêmes dimensions cachées, même nombre de têtes d’attention. Vous ne pouvez pas fusionner n’importe quel modèle avec n’importe quel autre : un modèle basé sur Mistral-7B ne peut se fusionner qu’avec d’autres modèles également dérivés de cette même architecture Mistral-7B (généralement des versions fine-tunées de ce modèle de base par différentes équipes ou communautés).

Qu’est-ce que Mergekit exactement ?

Mergekit est une bibliothèque open source complète, développée à l’origine par Charles Goddard et l’équipe d’Arcee AI, conçue spécifiquement pour faciliter l’application de stratégies de fusion de modèles. Elle fournit un cadre extensible permettant de fusionner des modèles efficacement sur n’importe quel matériel, tout en prenant en charge une grande variété d’algorithmes de fusion.

Le projet est disponible gratuitement sur GitHub, et son adoption dans la communauté open source est aujourd’hui massive : c’est devenu l’outil de référence incontournable dès qu’il s’agit de fusionner des LLM, que ce soit pour des projets de recherche, des expérimentations personnelles, ou même des modèles commercialisés.

Les principales méthodes de fusion disponibles dans Mergekit

C’est le cœur technique de ce tutoriel. Mergekit propose plusieurs algorithmes de fusion, chacun avec sa propre logique mathématique et ses propres cas d’usage privilégiés. Comprendre leurs différences est indispensable pour choisir la bonne approche selon votre objectif.

1. Linear Merging (ou « Model Soups ») : la méthode la plus simple

C’est l’approche la plus basique, introduite sous le nom de « Model Soups » par une équipe de recherche en 2022. Le principe : calculer une simple moyenne pondérée des paramètres de plusieurs modèles.

Avantage : extrêmement simple à comprendre et à mettre en œuvre.

Limite : dans des espaces à très haute dimension (ce qui est le cas des poids d’un LLM, qui comptent des milliards de paramètres), l’interpolation linéaire classique peut entraîner une réduction de l’amplitude des vecteurs interpolés, autrement dit, une perte de « force » du signal, qui peut dégrader la qualité du modèle final.

2. SLERP (Spherical Linear Interpolation) : la référence pour fusionner deux modèles

SLERP, pour Spherical Linear Interpolation (interpolation linéaire sphérique), est probablement la méthode la plus populaire et la plus fiable pour fusionner deux modèles. Introduite à l’origine par Ken Shoemake en 1985 dans le contexte de l’animation 3D, cette technique a été reprise pour le merging de modèles d’IA.

Le principe : au lieu de faire une simple moyenne linéaire entre deux points, SLERP traite les paramètres des modèles comme des points sur une hypersphère (une sphère à très haute dimension) et calcule le chemin le plus naturel entre ces deux points le long de la surface de cette sphère, plutôt qu’en ligne droite. Cette approche préserve mieux les propriétés géométriques et rotationnelles de l’espace vectoriel des modèles, garantissant un mélange qui incarne plus fidèlement les caractéristiques des deux modèles parents.

La limite principale de SLERP : elle ne peut fusionner que deux modèles à la fois, contrairement à d’autres méthodes plus flexibles.

3. TIES-Merging : pour combiner plusieurs modèles sans qu’ils se marchent sur les pieds

TIES signifie Trim, Elect Sign & Merge (« Élaguer, Élire le Signe, et Fusionner »). Introduite par Yadav et ses collègues, cette méthode a été spécifiquement conçue pour résoudre deux problèmes majeurs qui surgissent quand on essaie de fusionner plusieurs modèles spécialisés dans une seule tâche multi-usage :

La redondance des paramètres : TIES identifie et élimine les paramètres redondants au sein des modèles spécifiques à chaque tâche, en se concentrant uniquement sur les changements les plus significatifs effectués lors du fine-tuning (typiquement, elle ne conserve que le top-k % des changements les plus importants, et écarte le reste).
Les désaccords entre signes de paramètres : des conflits surviennent lorsque différents modèles suggèrent des ajustements opposés (positifs vs négatifs) sur le même paramètre. TIES résout ces conflits par un système d’élection de signe, une sorte de vote majoritaire pour déterminer la direction finale de chaque paramètre

Avantage majeur : contrairement à SLERP, TIES peut fusionner plusieurs modèles simultanément, ce qui en fait un choix privilégié quand vous voulez combiner trois, quatre, ou davantage de modèles spécialisés.

4. DARE : ajouter du hasard pour améliorer la robustesse

DARE, pour Drop And REscale, introduit une dimension supplémentaire particulièrement astucieuse : le hasard contrôlé.

Son fonctionnement repose sur deux étapes :

L’élagage (pruning) : DARE réinitialise aléatoirement certains poids fine-tunés à leur valeur d’origine (celle du modèle de base), agissant comme une forme de régularisation.
Le rééchelonnement (rescaling) : pour compenser cette suppression aléatoire, DARE redimensionne les poids restants afin de maintenir globalement inchangée l’espérance des sorties du modèle, un facteur d’échelle est appliqué pour préserver l’équilibre global

L’implémentation de DARE dans Mergekit propose deux variantes : dare_ties (qui intègre l’étape d’élection de signe de TIES) et dare_linear (sans cette étape). L’avantage concret de DARE est qu’elle fait de la place pour davantage de modèles dans le mélange final, sans que leurs interférences mutuelles ne dégradent trop la qualité globale.

5. Passthrough (« Frankenmerging ») : créer des architectures inédites

C’est probablement la technique la plus spectaculaire, et la plus surprenante dans ses résultats. Contrairement à toutes les méthodes précédentes qui combinent mathématiquement les poids de différents modèles au même endroit dans l’architecture, le passthrough, surnommé par la communauté « Frankenmerging », empile littéralement des couches provenant de différents modèles, créant ainsi une architecture d’une taille inhabituelle, différente de n’importe lequel des modèles d’origine.

C’est cette technique qui se cache derrière le modèle Goliath-120B, un modèle géant créé en combinant les couches de deux modèles Llama 2 de 70 milliards de paramètres chacun. C’est également la première étape de la technique de Depth Up-Scaling, utilisée pour créer des modèles comme SOLAR-10.7B et Yi-9B.

L’approche est très expérimentale, on ne sait jamais vraiment à l’avance si le résultat sera cohérent, mais elle a produit des modèles étonnamment performants, malgré son caractère presque artisanal.

6. Task Arithmetic : la logique des « vecteurs de tâche »

Task Arithmetic généralise le concept d’interpolation en travaillant dans un espace appelé espace des vecteurs de tâche. La méthode calcule la différence entre chaque modèle fine-tuné et le modèle de base d’origine (ce qu’on appelle le « delta » ou vecteur de tâche), moyenne ces différences entre plusieurs modèles, puis rajoute ce résultat au modèle de base. C’est la fondation conceptuelle sur laquelle TIES et DARE ont ensuite construit leurs raffinements respectifs.

Tableau récapitulatif : quelle méthode choisir ?

Méthode	Nombre de modèles	Complexité	Cas d’usage idéal
Linear (Model Soup)	2 ou plus	Très simple	Modèles très similaires, résultat rapide
SLERP	2 seulement	Modérée	Fusion fine et fidèle de deux modèles complémentaires
TIES	2 ou plus	Modérée	Combiner plusieurs modèles spécialisés dans des tâches différentes
DARE (dare_ties / dare_linear)	2 ou plus	Modérée	Fusionner un grand nombre de modèles sans trop d’interférences
Passthrough (Frankenmerge)	2 ou plus	Expérimentale	Créer un modèle plus grand que ses composants, structure inédite
Task Arithmetic	2 ou plus	Modérée	Base conceptuelle, utile pour des cas de recherche personnalisés

Le tutoriel pratique : fusionner votre premier modèle avec Mergekit

Passons maintenant à la partie concrète. Voici comment procéder, étape par étape.

Étape 1 : Installer Mergekit

Ouvrez un terminal et installez la bibliothèque directement depuis son dépôt GitHub officiel :

git clone https://github.com/arcee-ai/mergekit.git
cd mergekit
pip install -e .

Cette installation vous donne accès à la commande en ligne de commande mergekit-yaml, qui est le point d’entrée principal pour lancer vos fusions.

Étape 2 : Choisir vos modèles sources

Rendez-vous sur Hugging Face Hub, la plateforme communautaire de référence pour héberger et partager des modèles d’IA open source et identifiez les modèles que vous souhaitez fusionner. Rappel important : ils doivent tous partager la même architecture de base.

Exemple concret : si vous travaillez avec des modèles dérivés de Mistral-7B, vous pourriez choisir de combiner un modèle spécialisé dans le raisonnement mathématique, un autre orienté conversation naturelle, et un troisième excellant en génération de code, tous construits sur cette même base architecturale.

Étape 3 : Rédiger votre fichier de configuration YAML

C’est l’étape centrale de tout le processus. Mergekit fonctionne grâce à un fichier de configuration au format YAML, dans lequel vous décrivez précisément quels modèles fusionner, avec quelle méthode, et selon quels paramètres.

Voici un exemple concret de configuration utilisant la méthode SLERP, pour fusionner deux modèles basés sur Mistral-7B :

slices:
  - sources:
      - model: OpenPipe/mistral-ft-optimized-1218
        layer_range: [0, 32]
      - model: mlabonne/NeuralHermes-2.5-Mistral-7B
        layer_range: [0, 32]
merge_method: slerp
base_model: OpenPipe/mistral-ft-optimized-1218
parameters:
  t:
    - filter: self_attn
      value: [0, 0.5, 0.3, 0.7, 1]
    - filter: mlp
      value: [1, 0.5, 0.7, 0.3, 0]
    - value: 0.5
dtype: bfloat16

Ce que ce fichier signifie concrètement :

La section slices définit quelles couches de quels modèles inclure dans la fusion (ici, l’intégralité des 32 couches des deux modèles).
Le paramètre t (pour interpolation factor) contrôle la proportion de chaque modèle à chaque étape de l’interpolation. Vous pouvez faire varier ce facteur différemment selon les composants internes du modèle (les couches d’attention self_attn versus les couches de réseau de neurones mlp), ce qui permet un contrôle très fin.
dtype: bfloat16 précise le format numérique utilisé pour stocker les poids du modèle final, un compromis courant entre précision et taille de fichier.

Étape 4 : Un exemple avec TIES-DARE pour combiner plus de deux modèles

Si vous souhaitez fusionner plus de deux modèles simultanément, voici un exemple de configuration utilisant la méthode dare_ties :

models:
  - model: mistralai/Mistral-7B-v0.1
    # Aucun paramètre nécessaire pour le modèle de base
  - model: samir-fama/SamirGPT-v1
    parameters:
      density: 0.53
      weight: 0.4
  - model: abacusai/Slerp-CM-mist-dpo
    parameters:
      density: 0.53
      weight: 0.3
  - model: EmbeddedLLM/Mistral-7B-Merge-14-v0.2
    parameters:
      density: 0.53
      weight: 0.3
merge_method: dare_ties
base_model: mistralai/Mistral-7B-v0.1
parameters:
  int8_mask: true
dtype: bfloat16

Décortiquons les paramètres clés :

density : ce paramètre contrôle la fraction des poids conservés de chaque modèle après l’étape de suppression aléatoire propre à DARE. La documentation recommande généralement une densité inférieure à 0,5 pour des résultats optimaux. Ici, une valeur de 0,53 est légèrement supérieure à cette recommandation, mais reste dans une plage acceptable selon les retours d’expérience de la communauté.
weight : détermine l’importance relative de chaque modèle dans le mélange final. Une règle pratique communément admise : la somme des poids devrait se situer entre 0,9 et 1,1 pour obtenir un résultat équilibré.
int8_mask : une option d’optimisation qui réduit l’empreinte mémoire du processus de fusion en utilisant un masque en 8 bits plutôt qu’en pleine précision.

Étape 5 — Lancer la fusion

Une fois votre fichier de configuration prêt (sauvegardez-le, par exemple, sous le nom config.yaml), lancez la fusion avec la commande suivante :

mergekit-yaml config.yaml ./mon-modele-fusionne --cuda --low-cpu-memory

L’option --cuda active l’accélération GPU si vous en disposez d’une (facultatif mais recommandé pour accélérer le processus).
--low-cpu-memory limite la consommation de mémoire vive pendant l’opération, utile sur des machines aux ressources limitées

Le processus dure généralement de quelques minutes à une demi-heure, selon la taille des modèles et la puissance de votre machine, une durée dérisoire comparée aux jours ou semaines qu’exigerait un entraînement complet depuis zéro.

Étape 6 : Tester et publier votre modèle

Une fois la fusion terminée, votre nouveau modèle se trouve dans le dossier de sortie que vous avez spécifié (./mon-modele-fusionne dans notre exemple). Vous pouvez immédiatement le charger avec la bibliothèque Transformers de Hugging Face pour le tester :

from transformers import AutoModelForCausalLM, AutoTokenizer

model = AutoModelForCausalLM.from_pretrained("./mon-modele-fusionne")
tokenizer = AutoTokenizer.from_pretrained("./mon-modele-fusionne")

Si les résultats vous satisfont, vous pouvez publier votre création sur le Hugging Face Hub, en la rendant accessible à toute la communauté. C’est exactement ainsi que sont nés des modèles devenus célèbres comme NeuralPipe-7B-slerp ou Marcoro14-7B-slerp, ce dernier ayant notamment obtenu d’excellentes performances sur le Open LLM Leaderboard, se classant comme l’un des meilleurs modèles de 7 milliards de paramètres de son époque.

L’astuce pour aller plus vite : LazyMergekit

Pour les utilisateurs souhaitant s’épargner la configuration manuelle d’un environnement local, il existe un notebook automatisé baptisé LazyMergekit, qui simplifie considérablement le processus en fournissant une interface prête à l’emploi, exécutable directement dans Google Colab, sans installation locale.

Les bonnes pratiques et pièges à éviter

Vérifier la compatibilité de licence

Chaque modèle source possède sa propre licence d’utilisation (Apache 2.0, MIT, licences propriétaires plus restrictives…). Avant de fusionner et de publier un modèle, assurez-vous que les licences des modèles sources sont compatibles entre elles et autorisent ce type de dérivation, un point souvent négligé par les débutants, mais qui peut avoir des conséquences juridiques réelles si vous comptez utiliser votre modèle fusionné commercialement.

Ne pas négliger l’évaluation post-fusion

Un modèle fusionné n’est pas automatiquement meilleur que ses composants individuels. Il est indispensable de tester rigoureusement votre création sur des benchmarks pertinents (comme ceux du Open LLM Leaderboard, ou des tests personnalisés adaptés à votre cas d’usage précis) avant de considérer la fusion comme réussie.

Expérimenter avec les poids d’interpolation

Les résultats d’une fusion peuvent varier considérablement selon les valeurs choisies pour les paramètres t, density, ou weight. N’hésitez pas à itérer plusieurs configurations différentes, c’est souvent par tâtonnement méthodique que les meilleures fusions sont découvertes par la communauté.

Pourquoi cette technique séduit autant la communauté open source

Le model merging répond à un besoin très concret dans l’écosystème actuel de l’IA : la démocratisation de la création de modèles personnalisés, sans les barrières financières et techniques qu’imposait autrefois l’entraînement classique.

Pour une petite entreprise, un chercheur indépendant, ou simplement un passionné curieux, la possibilité de combiner les forces de plusieurs modèles open source déjà entraînés sans avoir besoin de louer des GPU coûteux ni de collecter des jeux de données propriétaires, représente une avancée considérable en termes d’accessibilité. C’est probablement l’une des raisons pour lesquelles le nombre de modèles fusionnés soumis chaque semaine sur le Hugging Face Hub continue de croître de façon soutenue.

Le model merging annonce-t-il la fin de l’entraînement traditionnel pour les petits projets ?

Pendant longtemps, créer un modèle d’IA performant a été perçu comme réservé à ceux qui disposaient de moyens considérables : des budgets de calcul à six chiffres, des équipes de data scientists expérimentés, un accès privilégié à des jeux de données massifs. Le model merging bouscule cette hiérarchie établie. Il permet à quiconque possède une connaissance de base de Python et un ordinateur raisonnablement équipé de recombiner l’intelligence collective déjà produite par la communauté open source, pour créer quelque chose de nouveau et potentiellement performant.

Ce qui me semble particulièrement fascinant, c’est que cette approche remet en question une intuition assez répandue selon laquelle « plus de calcul égale toujours de meilleurs résultats ». Des modèles fusionnés, produits en quelques minutes sur un simple ordinateur portable, arrivent régulièrement à rivaliser, voire à surpasser, des modèles ayant nécessité des investissements colossaux en entraînement. Cela suggère que l’intelligence artificielle contemporaine recèle encore beaucoup de « gains gratuits » que la communauté n’a pas fini d’explorer, simplement en recombinant intelligemment ce qui existe déjà, plutôt qu’en cherchant systématiquement à tout reconstruire depuis zéro.

Cela dit, il faut garder les pieds sur terre : le model merging ne remplace pas l’entraînement traditionnel pour tous les cas de figure. Il fonctionne remarquablement bien pour combiner des spécialisations complémentaires issues d’une même famille de modèles, mais il ne peut pas faire émerger des capacités totalement nouvelles qu’aucun des modèles sources ne possédait déjà, d’une manière ou d’une autre, dans ses poids.

La vraie question que je trouve intéressante pour l’avenir : à mesure que de plus en plus de modèles open source de haute qualité sont publiés chaque semaine, allons-nous voir émerger une véritable « économie de la fusion », où la valeur ajoutée réside moins dans l’entraînement initial que dans la capacité à combiner intelligemment l’existant ? Cette perspective mérite d’être suivie de près.

💬 Votre avis nous intéresse !

Avez-vous déjà expérimenté avec Mergekit ou une autre technique de fusion de modèles ? Quelle méthode avez-vous trouvée la plus efficace pour vos propres projets ? Et pensez-vous que le model merging va continuer à gagner en popularité, ou qu’il restera une technique de niche réservée aux passionnés de l’open source ?

Partagez votre expérience et vos configurations dans les commentaires.