> 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-de/training/mergekit.md). # Mergekit-Modellzusammenführung **Mergekit** ist das definitive Toolkit zum Zusammenführen vortrainierter großer Sprachmodelle. Mit über 5.000 GitHub-Sternen implementiert es alle wichtigen Model-Merging-Algorithmen — SLERP, TIES, DARE, DARE-TIES, MoE-Zusammenführung und mehr — und ermöglicht es Ihnen, leistungsstarke neue Modelle ohne Trainingsdaten oder GPU-Trainingszeit zu erstellen. {% hint style="success" %} Alle Beispiele können auf GPU-Servern ausgeführt werden, die über [CLORE.AI Marketplace](https://clore.ai/marketplace). {% endhint %} *** ## Was ist Mergekit? Model Merging ist eine leistungsstarke Technik, die die Stärken mehrerer LLMs in einem einzigen Modell vereint: * **Kein Training erforderlich** — das Zusammenführen passiert im Gewicht-Raum, nicht durch Backpropagation * **Fähigkeiten kombinieren** — mischen Sie ein Coding-Modell mit einem instruktionsorientierten Modell * **Schwächen reduzieren** — durchschnittliche Ausmerzung individueller Modellfehler innerhalb eines Ensembles * **Mixture of Experts erstellen** — kombinieren Sie Modelle zu einer sparsamen MoE-Architektur * **Domänenanpassung** — Base-Model mit domänenspezialisierten Modellen zusammenführen Mergekit implementiert alle state-of-the-art Algorithmen: | Algorithmus | Beschreibung | Am besten für | | ------------------- | ---------------------------------------------------------------- | -------------------------------------------------------- | | **SLERP** | Sphärische lineare Interpolation zwischen zwei Modellen | Sanfte Verschmelzung zweier ähnlicher Modelle | | **TIES** | Trimmen redundanter Parameter, Vorzeichen wählen, zusammenführen | Kombination mehrerer Modelle mit minimaler Interferenz | | **DARE** | Zufällige Parameter fallen lassen und neu skalieren | Reduzierung von Parameterinterferenzen bei großen Merges | | **DARE-TIES** | DARE + TIES kombiniert | Insgesamt am besten für Multi-Modell-Zusammenführungen | | **Linear** | Einfache gewichtete Mittelung | Schnelle Basislinien-Merges | | **Task Arithmetic** | Aufgabe-Vektoren addieren/subtrahieren | Hinzufügen/Entfernen spezifischer Fähigkeiten | | **Passthrough** | Layer direkt kopieren | MoE-Konstruktion | {% hint style="info" %} Model Merging ist überraschend effektiv. Zusammgeführte Modelle übertreffen oft ihre Eltern in Benchmarks, indem sie komplementäres Wissen kombinieren. Die MergeKit-Community auf HuggingFace hostet tausende zusammengeführte Modelle. {% endhint %} *** ## Serveranforderungen | Komponente | Minimum | Empfohlen | | -------------- | ------------------------------------------------ | ------------------------------------------ | | GPU | Nicht erforderlich (CPU-Zusammenführung möglich) | A100 40 GB für große Modelle | | VRAM | — | 80 GB für 70B Modellzusammenführungen | | RAM | 32 GB | 64 GB+ (Modelle werden in den RAM geladen) | | CPU | 8 Kerne | 16+ Kerne | | Speicher | 100 GB | 500 GB+ | | Betriebssystem | Ubuntu 20.04+ | Ubuntu 22.04 | | Python | 3.10+ | 3.11 | {% hint style="warning" %} Für rein CPU-basierte Zusammenführungen (der gebräuchlichste Modus) ist RAM Ihr Engpass. Das Zusammenführen zweier 7B-Modelle in bf16 benötigt mindestens \~28 GB RAM. Verwenden Sie `--lazy-unpickle` für geringeren Speicherverbrauch. {% endhint %} *** ## Ports | Port | Dienst | Hinweise | | ---- | ------ | --------------------------------- | | 22 | SSH | Terminalzugriff und Dateitransfer | Mergekit läuft als Kommandozeilentool — kein Webserver erforderlich. *** ## Installation auf Clore.ai ### Schritt 1 — Einen Server mieten 1. Gehe zu [Clore.ai Marketplace](https://clore.ai/marketplace) 2. Filtere nach **RAM ≥ 64 GB** (kritisch für große Modellzusammenführungen) 3. Wählen Sie **Speicher ≥ 500 GB** (zusammengeführte Modelle benötigen Platz für 2–4 Eingabemodelle + Ausgabe) 4. GPU ist optional, aber nützlich, wenn Sie das zusammengeführte Modell danach testen möchten 5. Öffne Port **22** nur ### Schritt 2 — Verbindung per SSH ```bash ssh root@ -p ``` ### Schritt 3 — Python-Umgebung installieren ```bash # Python 3.11 installieren apt-get update apt-get install -y python3.11 python3.11-venv python3.11-pip git # Virtuelle Umgebung erstellen python3.11 -m venv /opt/mergekit source /opt/mergekit/bin/activate ``` ### Schritt 4 — Mergekit installieren ```bash # Installation von PyPI pip install mergekit # Oder Installation aus dem Quellcode (empfohlen für neueste Features) git clone https://github.com/arcee-ai/mergekit.git cd mergekit pip install -e '.[everything]' ``` ### Schritt 5 — HuggingFace CLI installieren ```bash pip install huggingface_hub huggingface-cli login # Geben Sie Ihr HF-Token ein ``` ### Schritt 6 — Installation überprüfen ```bash mergekit --help mergekit-yaml --help ``` *** ## Modelle zum Zusammenführen herunterladen ```bash # Lade Modelle herunter, die Sie zusammenführen möchten # Verwendung von huggingface_hub python3 << 'EOF' from huggingface_hub import snapshot_download # Modell 1 herunterladen snapshot_download( repo_id="mistralai/Mistral-7B-Instruct-v0.3", local_dir="models/Mistral-7B-Instruct-v0.3" ) # Modell 2 herunterladen snapshot_download( repo_id="meta-llama/Llama-3.2-8B-Instruct", local_dir="models/Llama-3.2-8B-Instruct", token="hf_your-token" # Erforderlich für geschützte Modelle ) EOF # Oder die huggingface_hub CLI verwenden huggingface-cli download mistralai/Mistral-7B-Instruct-v0.3 \ --local-dir models/Mistral-7B-Instruct-v0.3 ``` *** ## Merge-Konfigurationen Mergekit verwendet YAML-Konfigurationsdateien zur Definition von Merges. ### Beispiel 1: SLERP Merge (Zwei Modelle) SLERP mischt zwei Modelle entlang eines sphärischen Bogens — am besten für Modelle derselben Architektur: ```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 # 50/50 Mischung für Attention-Layer - filter: mlp value: 0.3 # 30% von Modell 2 für MLP-Layer - value: 0.5 # Standard für alles andere dtype: bfloat16 ``` ```bash mergekit-yaml slerp_merge.yaml merged-model/ --lazy-unpickle ``` ### Beispiel 2: TIES Merge (Mehrere Modelle) TIES behandelt Interferenzen zwischen mehreren zusammengeführten Modellen: ```yaml # ties_merge.yaml models: - model: models/Mistral-7B-v0.3 parameters: weight: 1.0 # Basismodell, volles Gewicht density: 1.0 - model: models/Mistral-7B-coding parameters: weight: 0.7 # Coding-Fähigkeit density: 0.5 # Behalte 50% der veränderten Parameter - model: models/Mistral-7B-math parameters: weight: 0.5 # Mathematik-Fähigkeit density: 0.3 # Behalte 30% der veränderten Parameter 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 ``` ### Beispiel 3: DARE-TIES Merge (Beste Allround-Lösung) ```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 ``` ### Beispiel 4: Task Arithmetic (Fähigkeiten hinzufügen) Fügen Sie einem Basismodell ein „Skill-Delta“ hinzu: ```yaml # task_arithmetic.yaml # Fügt die Mathematik-Fähigkeit eines auf Mathematik abgestimmten Modells einem allgemeinen Basismodell hinzu models: - model: models/Llama-3.2-8B-Instruct parameters: weight: 1.0 - model: models/Llama-3.2-8B-math parameters: weight: 0.7 # Positiv = diese Fähigkeit hinzufügen # Um eine Fähigkeit ZU ENTFERNEN, verwenden Sie negatives Gewicht: # - 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 ``` ### Beispiel 5: MoE (Mixture of Experts) Kombinieren Sie Modelle zu einer sparsamen MoE-Architektur: ```yaml # moe_merge.yaml base_model: models/Llama-3.2-8B-Instruct gate_mode: hidden # Verwenden Sie Hidden-States, um zu Experten zu routen 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 ``` *** ## Den Merge ausführen ### Grundlegender Befehl ```bash # Umgebung aktivieren source /opt/mergekit/bin/activate # Merge mit lazy unpickling ausführen (spart RAM) mergekit-yaml your_config.yaml output_model/ --lazy-unpickle # Mit CUDA-Beschleunigung (falls GPU verfügbar) mergekit-yaml your_config.yaml output_model/ \ --lazy-unpickle \ --cuda \ --copy-tokenizer # Niedriger Speichermodus (langsamer, funktioniert aber auf kleineren Servern) mergekit-yaml your_config.yaml output_model/ \ --lazy-unpickle \ --low-cpu-memory ``` ### Fortschritt überwachen ```bash # Mergekit zeigt den Fortschritt für jedes Layer an # Typische Ausgabe: # Lade Modell 1... # Lade Modell 2... # Merge Layer 0/32: embed_tokens # Merge Layer 1/32: layers.0.self_attn # ... # Speichere zusammengeführtes Modell... # Fertig! Gespeichert in output_model/ ``` *** ## Das zusammengeführte Modell testen ```bash # Schneller Test mit 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 = "Erklären Sie den Unterschied zwischen LoRA und vollständigem 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 ``` *** ## Auf HuggingFace veröffentlichen ```bash # Login huggingface-cli login # Repository erstellen und pushen python3 << 'EOF' from huggingface_hub import HfApi api = HfApi() # Repo erstellen api.create_repo("my-merged-model-7b", private=False) # Zusammengeführtes Modell hochladen api.upload_folder( folder_path="output_model/", repo_id="your-username/my-merged-model-7b", repo_type="model" ) print("Hochgeladen!") EOF ``` *** ## Fortgeschritten: Evolutionärer Merge Verwenden Sie Mergekits evolutionären Optimierer, um optimale Merge-Gewichte zu finden: ```bash # Evolutionären Optimierer installieren pip install 'mergekit[evo]' # Evolutionäre Suche ausführen mergekit-evolve evolve_config.yaml \ --storage-path ./evolve-workspace \ --n-iterations 100 \ --task mmlu # Für den MMLU-Benchmark optimieren ``` *** ## Fehlerbehebung ### Out of Memory (OOM) während des Merges ```bash # Verwenden Sie immer --lazy-unpickle für große Modelle mergekit-yaml config.yaml out/ --lazy-unpickle # Fügen Sie das Flag --low-cpu-memory hinzu mergekit-yaml config.yaml out/ --lazy-unpickle --low-cpu-memory # Prüfen Sie den verfügbaren RAM vor dem Zusammenführen free -h # Für 7B-Modelle benötigen Sie mindestens ~30 GB RAM # Für 13B-Modelle: ~60 GB RAM # Für 70B-Modelle: ~280 GB RAM (oder verwenden Sie einen CPU-Server mit viel RAM) ``` ### `ValueError: Modelle sind nicht kompatibel` ```bash # Modelle müssen die gleiche Architektur haben # Sie können Llama-3 nicht direkt mit Mistral zusammenführen # Prüfen Sie die Modellkonfigurationen 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')) " ``` ### Der Merge ist sehr langsam ```bash # Verwenden Sie GPU für schnellere Tensor-Operationen mergekit-yaml config.yaml out/ --lazy-unpickle --cuda # Stellen Sie sicher, dass PyTorch mit CUDA installiert ist python3 -c "import torch; print(torch.cuda.is_available())" # Falls CUDA nicht verfügbar ist, installieren Sie es: pip install torch --index-url https://download.pytorch.org/whl/cu121 ``` ### Das zusammengeführte Modell erzeugt Unsinn ```bash # Häufige Ursachen: # 1. Zusammenführen inkompatibler Modellfamilien (z. B. Llama + Mistral) # 2. Gewichte zu extrem (t=0 oder t=1 statt 0.3–0.7 für SLERP) # 3. Zu hohe Dichte in TIES (versuchen Sie density: 0.3–0.5) # Diagnose: Testen Sie zuerst jedes Elternmodell # Versuchen Sie dann als Basislinie einen 50/50 SLERP-Merge # Prüfen Sie die Konfiguration des zusammengeführten Modells cat output_model/config.json | python3 -m json.tool ``` ### `FileNotFoundError` für Modellaus Dateien ```bash # Listen Sie auf, was heruntergeladen wurde ls -la models/your-model/ # Erforderliche Dateien: # config.json, tokenizer.json, *.safetensors (oder *.bin) # Erneut mit Force herunterladen huggingface-cli download --local-dir models/ --force-download ``` *** ## Beliebte Merge-Rezepte ### Allgemeiner Assistent + Coding ```yaml # Großartig für Entwickler, die auch allgemeine Fähigkeiten möchten 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 ``` ### Mehrsprachiger Boost ```yaml # Mehrsprachige Fähigkeiten zu einem englischen Modell hinzufügen 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 ``` *** ## Nützliche Links * **GitHub**: ⭐ 5K+ * **Dokumentation**: * **MergeKit-Modelle auf HuggingFace**: * **Arcee.ai Discord**: * **TIES Paper**: * **DARE Paper**: * **Clore.ai Marketplace**: *** ## Clore.ai GPU-Empfehlungen | Anwendungsfall | Empfohlene GPU | Geschätzte Kosten auf Clore.ai | | ------------------------- | --------------- | ------------------------------ | | Entwicklung/Tests | RTX 3090 (24GB) | \~$0.12/gpu/hr | | Model Merging (7B–13B) | RTX 4090 (24GB) | \~$0.70/gpu/hr | | Große Modelle (70B+) | A100 80GB | \~$1.20/gpu/hr | | Multi-GPU-Zusammenführung | 2–4× A100 80GB | \~$2.40–$4.80/hr | > 💡 Alle Beispiele in diesem Leitfaden können bereitgestellt werden auf [Clore.ai](https://clore.ai/marketplace) GPU-Servern. Durchsuchen Sie verfügbare GPUs und mieten Sie stundenweise — keine Verpflichtungen, voller Root-Zugriff. --- # 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-de/training/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.