> For the complete documentation index, see [llms.txt](https://docs.clore.ai/llms.txt). Markdown versions of documentation pages are available by appending `.md` to page URLs; this page is available as [Markdown](https://docs.clore.ai/guides/guides_v2-fr/entrainement/mergekit.md). # 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. {% hint style="success" %} Tous les exemples peuvent être exécutés sur des serveurs GPU loués via [CLORE.AI Marketplace](https://clore.ai/marketplace). {% endhint %} *** ## 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 | {% hint style="info" %} 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. {% endhint %} *** ## 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 | {% hint style="warning" %} 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. {% endhint %} *** ## 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](https://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 ```bash ssh root@ -p ``` ### Étape 3 — Installer l'environnement Python ```bash # 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 ```bash # 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 ```bash pip install huggingface_hub huggingface-cli login # Entrez votre token HF ``` ### Étape 6 — Vérifier l'installation ```bash mergekit --help mergekit-yaml --help ``` *** ## Téléchargement des modèles à fusionner ```bash # 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 : ```yaml # 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 ``` ```bash 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 : ```yaml # 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 ``` ```bash mergekit-yaml ties_merge.yaml merged-ties/ --lazy-unpickle ``` ### Exemple 3 : Fusion DARE-TIES (Meilleur choix général) ```yaml # 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 ``` ```bash 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 : ```yaml # 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 : ```yaml # 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" ``` ```bash mergekit-moe moe_merge.yaml merged-moe/ --lazy-unpickle ``` *** ## Exécution de la fusion ### Commande de base ```bash # 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 ```bash # 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é ```bash # 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 ```bash # 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 : ```bash # 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 ```bash # 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` ```bash # 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 ```bash # 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 ```bash # 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 ```bash # 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 --local-dir models/ --force-download ``` *** ## Recettes populaires de fusion ### Assistant général + Codage ```yaml # 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 ```yaml # 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**: ⭐ 5K+ * **Documentation**: * **Modèles MergeKit sur HuggingFace**: * **Discord Arcee.ai**: * **Article TIES**: * **Article DARE**: * **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](https://clore.ai/marketplace) serveurs GPU. Parcourez les GPU disponibles et louez à l’heure — sans engagement, avec accès root complet. --- # Agent Instructions This documentation is published with GitBook. GitBook is the documentation platform designed so that both humans and AI agents can read, navigate, and reason over technical content effectively. Learn more at gitbook.com. ## Querying This Documentation If you need additional information that is not directly available in this page, you can query the documentation dynamically by asking a question. Perform an HTTP GET request on the current page URL with the `ask` query parameter: ``` GET https://docs.clore.ai/guides/guides_v2-fr/entrainement/mergekit.md?ask= ``` The question should be specific, self-contained, and written in natural language. The response will contain a direct answer to the question and relevant excerpts and sources from the documentation. Use this mechanism when the answer is not explicitly present in the current page, you need clarification or additional context, or you want to retrieve related documentation sections.