Fusion de modèles Mergekit

Mergekit est la boîte à outils de référence pour fusionner des grands modèles de langage préentraînés. Avec plus de 5 000 étoiles sur GitHub, il implémente tous les principaux algorithmes de fusion de modèles — SLERP, TIES, DARE, DARE-TIES, fusion MoE, et plus encore — vous permettant de créer de nouveaux modèles puissants sans aucune donnée d’entraînement ni temps d’entraînement GPU.

Tous les exemples peuvent être exécutés sur des serveurs GPU loués via la place de marché CLORE.AI.

---

Qu'est-ce que Mergekit ?

La fusion de modèles est une technique puissante qui combine les forces de plusieurs LLM en un seul modèle :

• Aucun entraînement requis — la fusion se fait dans l'espace des poids, pas par rétropropagation

• Combiner les capacités — mélanger un modèle de code avec un modèle suivant des instructions

• Réduire les faiblesses — faire la moyenne des échecs individuels des modèles au sein d'un ensemble

• Créer un mélange d'experts — combiner des modèles en une architecture MoE clairsemée

• Adaptation de domaine — fusionner un modèle de base avec des modèles spécialisés dans un domaine

Mergekit implémente tous les algorithmes de pointe :

Algorithme	Description	Idéal pour
SLERP	Interpolation linéaire sphérique entre deux modèles	Fusion en douceur de deux modèles similaires
TIES	Élaguer les paramètres redondants, élire les signes, fusionner	Combinaison de plusieurs modèles avec un minimum d'interférences
DARE	Supprimer et re-échelonner des paramètres aléatoires	Réduction des interférences entre paramètres lors de fusions de grande taille
DARE-TIES	DARE + TIES combinés	Le meilleur choix global pour les fusions multi-modèles
Linéaire	Moyenne pondérée simple	Fusions de base rapides
Arithmétique des tâches	Ajouter/soustraire des vecteurs de tâches	Ajout/suppression de capacités spécifiques
Passage direct	Copier les couches directement	Construction d'un MoE

La fusion de modèles est étonnamment efficace. Les modèles fusionnés surpassent souvent leurs modèles parents sur les benchmarks en combinant des connaissances complémentaires. La communauté MergeKit sur HuggingFace héberge des milliers de modèles fusionnés.

---

Exigences du serveur

Composant	Minimum	Recommandé
GPU	Non requis (fusion possible sur CPU)	A100 40 Go pour les grands modèles
VRAM	—	80 Go pour les fusions de modèles 70B
RAM	32 Go	64 Go+ (les modèles se chargent en RAM)
CPU	8 cœurs	16+ cœurs
Stockage	100 Go	500 Go+
Système d'exploitation	Ubuntu 20.04+	Ubuntu 22.04
Python	3.10+	3.11

Pour la fusion uniquement sur CPU (le mode le plus courant), la RAM est votre goulot d'étranglement. Fusionner deux modèles 7B en bf16 nécessite au minimum ~28 Go de RAM. Utilisez --lazy-unpickle pour une consommation de mémoire plus faible.

---

Ports

Port	Service	Remarques
22	SSH	Accès terminal et transfert de fichiers

Mergekit s'exécute comme un outil en ligne de commande — aucun serveur web n'est nécessaire.

---

Installation sur Clore.ai

Étape 1 — Louer un serveur

1. Accédez à Marketplace Clore.ai

2. Filtrer pour RAM ≥ 64 Go (critique pour les grandes fusions de modèles)

3. Choisissez Stockage ≥ 500 Go (les modèles fusionnés nécessitent de l'espace pour 2 à 4 modèles d'entrée + la sortie)

4. Le GPU est facultatif mais utile si vous souhaitez tester le modèle fusionné ensuite

5. Ouvrir le port 22 uniquement

Étape 2 — Connexion via SSH

ssh root@<server-ip> -p <ssh-port>

Étape 3 — Installer l'environnement Python

# Installer Python 3.11
apt-get update
apt-get install -y python3.11 python3.11-venv python3.11-pip git

# Créer un environnement virtuel
python3.11 -m venv /opt/mergekit
source /opt/mergekit/bin/activate

Étape 4 — Installer Mergekit

# Installer depuis PyPI
pip install mergekit

# Ou installer depuis les sources (recommandé pour les dernières fonctionnalités)
git clone https://github.com/arcee-ai/mergekit.git
cd mergekit
pip install -e '.[everything]'

Étape 5 — Installer la CLI HuggingFace

pip install huggingface_hub
huggingface-cli login  # Entrez votre jeton HF

Étape 6 — Vérifier l'installation

mergekit --help
mergekit-yaml --help

---

Téléchargement des modèles à fusionner

# Télécharger les modèles que vous souhaitez fusionner
# Avec huggingface_hub

python3 << 'EOF'
from huggingface_hub import snapshot_download

# Télécharger le modèle 1
snapshot_download(
    repo_id="mistralai/Mistral-7B-Instruct-v0.3",
    local_dir="models/Mistral-7B-Instruct-v0.3"
)

# Télécharger le modèle 2
snapshot_download(
    repo_id="meta-llama/Llama-3.2-8B-Instruct",
    local_dir="models/Llama-3.2-8B-Instruct",
    token="hf_your-token"  # Requis pour les modèles à accès restreint
)
EOF

# Ou utiliser la CLI huggingface_hub
huggingface-cli download mistralai/Mistral-7B-Instruct-v0.3 \
  --local-dir models/Mistral-7B-Instruct-v0.3

---

Configurations de fusion

Mergekit utilise des fichiers de configuration YAML pour définir les fusions.

Exemple 1 : Fusion SLERP (deux modèles)

SLERP mélange deux modèles le long d'un arc sphérique — idéal pour des modèles de la même architecture :

# slerp_merge.yaml
models:
  - model: models/Mistral-7B-Instruct-v0.3
  - model: models/OpenHermes-2.5-Mistral-7B

merge_method: slerp
base_model: models/Mistral-7B-Instruct-v0.3

slices:
  - sources:
    - model: models/Mistral-7B-Instruct-v0.3
      layer_range: [0, 32]
    - model: models/OpenHermes-2.5-Mistral-7B
      layer_range: [0, 32]

parameters:
  t:
    - filter: self_attn
      value: 0.5  # Mélange 50/50 pour les couches d'attention
    - filter: mlp
      value: 0.3  # 30 % du modèle 2 pour les couches MLP
    - value: 0.5  # valeur par défaut pour le reste

dtype: bfloat16

mergekit-yaml slerp_merge.yaml merged-model/ --lazy-unpickle

Exemple 2 : Fusion TIES (plusieurs modèles)

TIES gère les interférences entre plusieurs modèles fusionnés :

# ties_merge.yaml
models:
  - model: models/Mistral-7B-v0.3
    parameters:
      weight: 1.0    # Modèle de base, poids total
      density: 1.0

  - model: models/Mistral-7B-coding
    parameters:
      weight: 0.7    # Capacité de codage
      density: 0.5   # Conserver 50 % des paramètres modifiés

  - model: models/Mistral-7B-math
    parameters:
      weight: 0.5    # Capacité mathématique
      density: 0.3   # Conserver 30 % des paramètres modifiés

merge_method: ties
base_model: models/Mistral-7B-v0.3

parameters:
  normalize: true
  int8_mask: true

dtype: bfloat16

mergekit-yaml ties_merge.yaml merged-ties/ --lazy-unpickle

Exemple 3 : Fusion DARE-TIES (le meilleur choix global)

# dare_ties_merge.yaml
models:
  - model: models/Llama-3.2-8B-Instruct
    parameters:
      weight: 1.0
      density: 0.7
      dare_linear: true

  - model: models/Llama-3.2-8B-code
    parameters:
      weight: 0.8
      density: 0.5
      dare_linear: true

  - model: models/Llama-3.2-8B-math
    parameters:
      weight: 0.6
      density: 0.4
      dare_linear: true

merge_method: dare_ties
base_model: models/Llama-3.2-8B-Instruct

parameters:
  normalize: true
  dare_density: 0.5
  dare_epsilon: 0.08

dtype: bfloat16

mergekit-yaml dare_ties_merge.yaml merged-dare-ties/ --lazy-unpickle

Exemple 4 : Arithmétique des tâches (ajouter des capacités)

Ajoutez un « delta de compétence » à un modèle de base :

# task_arithmetic.yaml
# Ajoute la compétence en mathématiques d'un modèle ajusté aux mathématiques à un modèle de base général
models:
  - model: models/Llama-3.2-8B-Instruct
    parameters:
      weight: 1.0
  
  - model: models/Llama-3.2-8B-math
    parameters:
      weight: 0.7   # Positif = ajouter cette capacité
  
  # Pour SUPPRIMER une capacité, utilisez un poids négatif :
  # - model: models/Llama-3.2-8B-harmful
  #   parameters:
  #     weight: -0.5

merge_method: task_arithmetic
base_model: models/Llama-3.2-8B-Instruct

dtype: bfloat16

Exemple 5 : MoE (mélange d'experts)

Combinez les modèles dans une architecture MoE clairsemée :

# moe_merge.yaml
base_model: models/Llama-3.2-8B-Instruct

gate_mode: hidden  # Utiliser les états cachés pour router vers les experts
dtype: bfloat16
experts:
  - source_model: models/Llama-3.2-8B-coding
    positive_prompts:
      - "Écrire du code"
      - "Déboguer cette fonction"
      - "Implémentez un algorithme"
    negative_prompts:
      - "Racontez-moi une histoire"
      - "Expliquez l'histoire"
  
  - source_model: models/Llama-3.2-8B-creative
    positive_prompts:
      - "Écrire une histoire"
      - "Être créatif"
      - "Imaginez"
    negative_prompts:
      - "Écrire du code"
      - "Calculer"

mergekit-moe moe_merge.yaml merged-moe/ --lazy-unpickle

---

Exécution de la fusion

Commande de base

# Activer l'environnement
source /opt/mergekit/bin/activate

# Exécuter la fusion avec désérialisation paresseuse (économise la RAM)
mergekit-yaml your_config.yaml output_model/ --lazy-unpickle

# Avec l'accélération CUDA (si le GPU est disponible)
mergekit-yaml your_config.yaml output_model/ \
  --lazy-unpickle \
  --cuda \
  --copy-tokenizer

# Mode faible mémoire (plus lent mais fonctionne sur des serveurs plus modestes)
mergekit-yaml your_config.yaml output_model/ \
  --lazy-unpickle \
  --low-cpu-memory

Suivre la progression

# Mergekit affiche la progression pour chaque couche
# Sortie typique :
# Chargement du modèle 1...
# Chargement du modèle 2...
# Fusion de la couche 0/32 : embed_tokens
# Fusion de la couche 1/32 : layers.0.self_attn
# ...
# Sauvegarde du modèle fusionné...
# Terminé ! Enregistré dans output_model/

---

Tester le modèle fusionné

# Test rapide avec transformers
python3 << 'EOF'
from transformers import AutoTokenizer, AutoModelForCausalLM
import torch

model_path = "output_model"
tokenizer = AutoTokenizer.from_pretrained(model_path)
model = AutoModelForCausalLM.from_pretrained(
    model_path,
    torch_dtype=torch.bfloat16,
    device_map="auto"
)

prompt = "Expliquez la différence entre LoRA et le fine-tuning complet :"
inputs = tokenizer(prompt, return_tensors="pt").to(model.device)

with torch.no_grad():
    outputs = model.generate(**inputs, max_new_tokens=200, temperature=0.7)

print(tokenizer.decode(outputs[0], skip_special_tokens=True))
EOF

---

Publication sur HuggingFace

# Connexion
huggingface-cli login

# Créer et envoyer le dépôt
python3 << 'EOF'
from huggingface_hub import HfApi
api = HfApi()

# Créer le dépôt
api.create_repo("my-merged-model-7b", private=False)

# Téléverser le modèle fusionné
api.upload_folder(
    folder_path="output_model/",
    repo_id="your-username/my-merged-model-7b",
    repo_type="model"
)
print("Téléversé !")
EOF

---

Avancé : fusion évolutive

Utilisez l'optimiseur évolutif de Mergekit pour trouver les poids de fusion optimaux :

# Installer l'optimiseur évolutif
pip install 'mergekit[evo]'

# Lancer la recherche évolutive
mergekit-evolve evolve_config.yaml \
  --storage-path ./evolve-workspace \
  --n-iterations 100 \
  --task mmlu  # Optimiser pour le benchmark MMLU

---

Dépannage

Erreur de mémoire insuffisante (OOM) pendant la fusion

# Utilisez toujours --lazy-unpickle pour les grands modèles
mergekit-yaml config.yaml out/ --lazy-unpickle

# Ajoutez l'option --low-cpu-memory
mergekit-yaml config.yaml out/ --lazy-unpickle --low-cpu-memory

# Vérifiez la RAM disponible avant de fusionner
free -h

# Pour les modèles 7B, il faut environ 30 Go de RAM minimum
# Pour les modèles 13B : environ 60 Go de RAM
# Pour les modèles 70B : environ 280 Go de RAM (ou utilisez un serveur CPU avec beaucoup de RAM)

ValueError : les modèles ne sont pas compatibles

# Les modèles doivent avoir la même architecture
# Vous ne pouvez pas fusionner directement Llama-3 avec Mistral
# Vérifier les configurations des modèles
python3 -c "
import json
for path in ['models/model1/config.json', 'models/model2/config.json']:
    with open(path) as f:
        cfg = json.load(f)
    print(path, ':', cfg.get('model_type'), cfg.get('hidden_size'), cfg.get('num_hidden_layers'))
"

La fusion est très lente

# Utilisez le GPU pour des opérations tensorielles plus rapides
mergekit-yaml config.yaml out/ --lazy-unpickle --cuda

# Assurez-vous que PyTorch avec CUDA est installé
python3 -c "import torch; print(torch.cuda.is_available())"

# Si CUDA n'est pas disponible, installez-le :
pip install torch --index-url https://download.pytorch.org/whl/cu128

Le modèle fusionné produit du charabia

# Causes courantes :
# 1. Fusion de familles de modèles incompatibles (par ex. Llama + Mistral)
# 2. Poids trop extrêmes (t=0 ou t=1 au lieu de 0.3-0.7 pour SLERP)
# 3. Densité trop élevée dans TIES (essayez density: 0.3-0.5)

# Diagnostic : testez d'abord chaque modèle parent
# Puis essayez une fusion SLERP 50/50 comme base

# Vérifier la configuration du modèle fusionné
cat output_model/config.json | python3 -m json.tool

FileNotFoundError pour les fichiers de modèle

# Lister ce qui a été téléchargé
ls -la models/your-model/

# Fichiers requis :
# config.json, tokenizer.json, *.safetensors (ou *.bin)

# Retélécharger en forçant
huggingface-cli download <repo_id> --local-dir models/<name> --force-download

---

Recettes de fusion populaires

Assistant général + codage

# Idéal pour les développeurs qui veulent aussi des capacités générales
models:
  - model: mistralai/Mistral-7B-Instruct-v0.3
    parameters: {weight: 1.0, density: 0.7}
  - model: mistralai/Codestral-7B  
    parameters: {weight: 0.8, density: 0.5}

merge_method: dare_ties
base_model: mistralai/Mistral-7B-Instruct-v0.3
dtype: bfloat16

Amélioration multilingue

# Ajouter des capacités multilingues à un modèle anglais
models:
  - model: meta-llama/Llama-3.2-8B-Instruct
    parameters: {weight: 1.0, density: 0.8}
  - model: utter-project/EuroLLM-9B-Instruct
    parameters: {weight: 0.6, density: 0.4}

merge_method: ties
base_model: meta-llama/Llama-3.2-8B-Instruct
dtype: bfloat16

---

Liens utiles

• GitHub: https://github.com/arcee-ai/mergekit ⭐ 5K+

• Documentation: https://github.com/arcee-ai/mergekit/wiki

• Modèles MergeKit sur HuggingFace: https://huggingface.co/models?other=mergekit

• Discord Arcee.ai: https://discord.gg/arcee

• Article TIES: https://arxiv.org/abs/2306.01708

• Article DARE: https://arxiv.org/abs/2311.03099

• Marketplace Clore.ai: https://clore.ai/marketplace

---

Recommandations GPU Clore.ai

Les configurations multi-GPU de classe 80 Go ne sont pas répertoriées sur la place de marché Clore.ai. Les plus grosses machines répertoriées aujourd’hui sont 4× RTX PRO 6000 Blackwell (96 Go chacune, 380 Go au total) et 8–11× RTX 5090 (32 Go chacune). La capacité A100 / H200 / B200 est proposée en bare metal sur demande. Consultez bare metal sur demande. Consultez Tarifs et disponibilité des GPU avant de dimensionner un déploiement.

Cas d’utilisation	GPU recommandé	Coût estimé sur Clore.ai
Développement/Test	RTX 3090 (24 Go)	0,07–0,21 $/gpu/h
Fusion de modèles (7B–13B)	RTX 4090 (24 Go)	0,14–0,42 $/gpu/h
Grands modèles (70B+)	A100 80 Go	bare metal
Fusion multi-GPU	2-4x A100 80 Go	bare metal

💡 Tous les exemples de ce guide peuvent être déployés sur Clore.ai des serveurs GPU. Parcourez les GPU disponibles et louez à l'heure — sans engagement, accès root complet.