Fusion de modèles Mergekit

Mergekit est la boîte à outils définitive pour fusionner des 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 — vous permettant de créer de nouveaux modèles puissants sans données d'entraînement ni temps de formation GPU.

Tous les exemples peuvent être exécutés sur des serveurs GPU loués via CLORE.AI Marketplace.

---

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 des capacités — mélanger un modèle de codage avec un modèle suiveur d'instructions

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

• Créer une Mixture of Experts — combiner des modèles en une architecture MoE éparse

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

Mergekit implémente tous les algorithmes à la pointe :

Algorithme	Description	Idéal pour
SLERP	Interpolation linéaire sphérique entre deux modèles	Mélange fluide de deux modèles similaires
TIES	Élaguer les paramètres redondants, élire des signes, fusionner	Combiner plusieurs modèles avec une interférence minimale
DARE	Supprimer et re-échelonner des paramètres aléatoires	Réduire l'interférence des paramètres lors de grandes fusions
DARE-TIES	DARE + TIES combinés	Meilleur choix général pour les fusions multi-modèles
Linéaire	Moyenne pondérée simple	Fusions de référence rapides
Task Arithmetic	Ajouter/soustraire des vecteurs de tâche	Ajouter/supprimer des capacités spécifiques
Passthrough	Copier des couches directement	Construction MoE

La fusion de modèles est étonnamment efficace. Les modèles fusionnés dépassent 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 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+
OS	Ubuntu 20.04+	Ubuntu 22.04
Python	3.10+	3.11

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

---

Ports

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

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

---

Installation sur Clore.ai

Étape 1 — Louer un serveur

1. Aller à Clore.ai Marketplace

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

3. Choisir 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 optionnel mais utile si vous souhaitez tester le modèle fusionné ensuite

5. Ouvrir le port 22 seulement

Étape 2 — Se connecter 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 le CLI HuggingFace

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

Étape 6 — Vérifier l'installation

mergekit --help
mergekit-yaml --help

---

Téléchargement des modèles à fusionner

# Téléchargez les modèles que vous souhaitez fusionner
# Utilisation de 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 protégés
)
EOF

# Ou utiliser le 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 % provenant du modèle 2 pour les couches MLP
    - value: 0.5  # valeur par défaut pour tout le reste

dtype: bfloat16

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

Exemple 2 : Fusion TIES (Plusieurs modèles)

TIES gère l'interférence 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 complet
      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 (Meilleur choix général)

# 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 : Task Arithmetic (Ajouter des capacités)

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

# task_arithmetic.yaml
# Ajoute la compétence mathématique d'un modèle ajusté pour les maths à 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 (Mixture of Experts)

Combiner des modèles en une architecture MoE éparse :

# 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:
      - "Write code"
      - "Debug this function"
      - "Implement an algorithm"
    negative_prompts:
      - "Tell me a story"
      - "Explain history"
  
  - source_model: models/Llama-3.2-8B-creative
    positive_prompts:
      - "Write a story"
      - "Be creative"
      - "Imagine"
    negative_prompts:
      - "Write code"
      - "Calculate"

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 accélération CUDA (si GPU 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 petits)
mergekit-yaml your_config.yaml output_model/ \
  --lazy-unpickle \
  --low-cpu-memory

Surveiller 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
# ...
# Enregistrement du modèle fusionné...
# Fait ! 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 = "Explain the difference between LoRA and full finetuning:"
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 pousser le dépôt
python3 << 'EOF'
from huggingface_hub import HfApi
api = HfApi()

# Créer un repo
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("Uploaded!")
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

Out of Memory (OOM) pendant la fusion

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

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

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

# Pour les modèles 7B vous avez besoin d'environ 30 Go de RAM minimum
# Pour les modèles 13B : ~60 Go de RAM
# Pour les modèles 70B : ~280 Go de RAM (ou utilisez un serveur CPU à haute mémoire)

ValueError : les modèles ne sont pas compatibles

# Les modèles doivent avoir la même architecture
# Vous ne pouvez pas fusionner Llama-3 avec Mistral directement
# Vérifiez les configs 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 tensor 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/cu121

Le modèle fusionné produit des absurdités

# Causes courantes :
# 1. Fusion de familles de modèles incompatibles (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
# Ensuite, essayez une fusion SLERP 50/50 comme référence

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

FileNotFoundError pour les fichiers du 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 avec force
huggingface-cli download <repo_id> --local-dir models/<name> --force-download

---

Recettes populaires de fusion

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

Boost multilingue

# Ajouter des capacités multilingues à un modèle anglophone
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

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

---

Recommandations GPU Clore.ai

Cas d’utilisation	GPU recommandé	Coût estimé sur Clore.ai
Développement/Test	RTX 3090 (24GB)	~$0.12/gpu/hr
Fusion de modèles (7B–13B)	RTX 4090 (24GB)	~$0.70/gpu/hr
Grands modèles (70B+)	A100 80GB	~$1.20/gpu/hr
Fusion multi-GPU	2-4x A100 80GB	~2,40–4,80 $/heure

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