> 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 ultimative Toolkit zum Zusammenführen vortrainierter großer Sprachmodelle. Mit über 5K GitHub-Sternen implementiert es jeden wichtigen Modell-Zusammenführungsalgorithmus — SLERP, TIES, DARE, DARE-TIES, MoE-Zusammenführung und mehr — und ermöglicht es dir, leistungsstarke neue Modelle ohne Trainingsdaten oder GPU-Trainingszeit zu erstellen. {% hint style="success" %} Alle Beispiele können auf GPU-Servern ausgeführt werden, die gemietet wurden über [CLORE.AI-Marktplatz](https://clore.ai/marketplace). {% endhint %} *** ## Was ist Mergekit? Die Modellzusammenführung ist eine leistungsstarke Technik, die die Stärken mehrerer LLMs in einem einzigen Modell vereint: * **Kein Training erforderlich** — die Zusammenführung erfolgt im Gewichtsraum, nicht durch Backpropagation * **Fähigkeiten kombinieren** — kombiniere ein Coding-Modell mit einem Modell, das Anweisungen befolgt * **Schwächen reduzieren** — gleiche einzelne Modellfehler über ein Ensemble aus * **Mixture of Experts erstellen** — kombiniere Modelle zu einer sparsamen MoE-Architektur * **Domänenanpassung** — führe das Basismodell mit domänenspezialisierten Modellen zusammen Mergekit implementiert alle modernsten Algorithmen: | Algorithmus | Beschreibung | Am besten geeignet für | | ------------------- | -------------------------------------------------------------- | ----------------------------------------------------------------- | | **SLERP** | Sphärische lineare Interpolation zwischen zwei Modellen | Sanftes Überblenden zweier ähnlicher Modelle | | **TIES** | Redundante Parameter kürzen, Vorzeichen wählen, zusammenführen | Zusammenführen mehrerer Modelle mit minimaler Beeinträchtigung | | **DARE** | Zufällige Parameter entfernen und neu skalieren | Reduzierung der Parameterinterferenz bei großen Zusammenführungen | | **DARE-TIES** | Kombination aus DARE + TIES | Die beste Allround-Lösung für Zusammenführungen mehrerer Modelle | | **Linear** | Einfacher gewichteter Durchschnitt | Schnelle Basis-Zusammenführungen | | **Task-Arithmetik** | Aufgabenvectoren addieren/subtrahieren | Bestimmte Fähigkeiten hinzufügen/entfernen | | **Passthrough** | Layer direkt kopieren | MoE-Konstruktion | {% hint style="info" %} Die Modellzusammenführung ist erstaunlich effektiv. Zusammengeführte Modelle übertreffen ihre Eltern auf Benchmarks oft, indem sie komplementäres Wissen kombinieren. Die MergeKit-Community auf HuggingFace hostet Tausende zusammengeführte Modelle. {% endhint %} *** ## Serveranforderungen | Komponente | Minimum | Empfohlen | | -------------- | ---------------------------------------------------- | -------------------------------------------- | | GPU | Nicht erforderlich (Zusammenführung auf CPU möglich) | A100 40 GB für große Modelle | | VRAM | — | 80 GB für Zusammenführungen von 70B-Modellen | | 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 Zusammenführungen nur auf der CPU (der häufigste Modus) ist der RAM dein Engpass. Das Zusammenführen von zwei 7B-Modellen in bf16 erfordert mindestens etwa 28 GB RAM. Verwende `--lazy-unpickle` für geringeren Speicherverbrauch. {% endhint %} *** ## Ports | Port | Dienst | Hinweise | | ---- | ------ | --------------------------------- | | 22 | SSH | Terminalzugriff und Dateitransfer | Mergekit läuft als Kommandozeilenwerkzeug — kein Webserver erforderlich. *** ## Installation auf Clore.ai ### Schritt 1 — Server mieten 1. Gehe zu [Clore.ai-Marktplatz](https://clore.ai/marketplace) 2. Filtern nach **RAM ≥ 64 GB** (entscheidend für große Modellzusammenführungen) 3. Wähle **Speicher ≥ 500 GB** (zusammengeführte Modelle benötigen Platz für 2–4 Eingangsmodelle + Ausgabe) 4. GPU ist optional, aber nützlich, wenn du das zusammengeführte Modell anschließend testen möchtest 5. Port öffnen **22** nur ### Schritt 2 — Verbinde dich 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 # Aus PyPI installieren pip install mergekit # Oder aus dem Quellcode installieren (empfohlen für die neuesten Funktionen) 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 # Gib deinen HF-Token ein ``` ### Schritt 6 — Installation überprüfen ```bash mergekit --help mergekit-yaml --help ``` *** ## Modelle zum Zusammenführen herunterladen ```bash # Lade die Modelle herunter, die du zusammenführen möchtest # Mit 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 Modelle mit Zugriffsbeschränkung ) EOF # Oder verwende die huggingface_hub-CLI huggingface-cli download mistralai/Mistral-7B-Instruct-v0.3 \\ --local-dir models/Mistral-7B-Instruct-v0.3 ``` *** ## Merge-Konfigurationen Mergekit verwendet YAML-Konfigurationsdateien, um Zusammenführungen zu definieren. ### 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 # Programmierfähigkeit density: 0.5 # Behalte 50 % der geänderten Parameter - model: models/Mistral-7B-math parameters: weight: 0.5 # Mathe-Fähigkeit density: 0.3 # Behalte 30 % der geä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 (der beste Allrounder) ```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-Arithmetik (Fähigkeiten hinzufügen) Füge einem Basismodell ein "Fähigkeits-Delta" hinzu: ```yaml # task_arithmetic.yaml # Fügt die Mathe-Fähigkeit eines auf Mathe abgestimmten Modells zu 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, verwende ein 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 (Expertenmischung) Kombiniere Modelle zu einer sparsamen MoE-Architektur: ```yaml # moe_merge.yaml base_model: models/Llama-3.2-8B-Instruct gate_mode: hidden # Verwendet verborgene Zustände, um an Experten weiterzuleiten dtype: bfloat16 experts: - source_model: models/Llama-3.2-8B-coding positive_prompts: - "Schreibe Code" - "Debugge diese Funktion" - "Implementiere einen Algorithmus" negative_prompts: - "Erzähl mir eine Geschichte" - "Erkläre Geschichte" - source_model: models/Llama-3.2-8B-creative positive_prompts: - "Schreibe eine Geschichte" - "Sei kreativ" - "Stell dir vor" negative_prompts: - "Schreibe Code" - "Berechne" ``` ```bash mergekit-moe moe_merge.yaml merged-moe/ --lazy-unpickle ``` *** ## Merge ausführen ### Grundbefehl ```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 # Niedrigspeichermodus (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 jede Schicht an # Typische Ausgabe: # Modell 1 wird geladen... # Modell 2 wird geladen... # Schicht 0/32 wird zusammengeführt: embed_tokens # Schicht 1/32 wird zusammengeführt: layers.0.self_attn # ... # Zusammengeführtes Modell wird gespeichert... # Fertig! Gespeichert in output_model/ ``` *** ## Das zusammengeführte Modell testen ```bash # Schnelltest 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äre 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 ``` *** ## Veröffentlichen bei HuggingFace ```bash # Anmelden huggingface-cli login # Repository erstellen und hochladen 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 Verwende den evolutionären Optimierer von Mergekit, 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 ### Speicher voll (OOM) während der Zusammenführung ```bash # Verwende bei großen Modellen immer --lazy-unpickle mergekit-yaml config.yaml out/ --lazy-unpickle # Füge den Schalter --low-cpu-memory hinzu mergekit-yaml config.yaml out/ --lazy-unpickle --low-cpu-memory # Vor dem Zusammenführen verfügbaren RAM prüfen free -h # Für 7B-Modelle benötigst du mindestens ~30 GB RAM # Für 13B-Modelle: ~60 GB RAM # Für 70B-Modelle: ~280 GB RAM (oder verwende einen CPU-Server mit viel RAM) ``` ### `ValueError: Modelle sind nicht kompatibel` ```bash # Modelle müssen dieselbe Architektur haben # Du kannst Llama-3 nicht direkt mit Mistral zusammenführen # Modellkonfigurationen prüfen 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')) " ``` ### Merge ist sehr langsam ```bash # Verwende eine GPU für schnellere Tensoroperationen mergekit-yaml config.yaml out/ --lazy-unpickle --cuda # Stelle sicher, dass PyTorch mit CUDA installiert ist python3 -c "import torch; print(torch.cuda.is_available())" # Falls CUDA nicht verfügbar ist, installiere es: pip install torch --index-url https://download.pytorch.org/whl/cu128 ``` ### Das zusammengeführte Modell erzeugt Kauderwelsch ```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 (versuche density: 0,3-0,5) # Diagnose: Teste zuerst jedes Elternmodell # Versuche dann als Ausgangsbasis einen 50/50-SLERP-Merge # Konfiguration des zusammengeführten Modells prüfen cat output_model/config.json | python3 -m json.tool ``` ### `FileNotFoundError` für Modelldateien ```bash # Auflisten, was heruntergeladen wurde ls -la models/your-model/ # Erforderliche Dateien: # config.json, tokenizer.json, *.safetensors (oder *.bin) # Erneut mit Erzwingung herunterladen huggingface-cli download --local-dir models/ --force-download ``` *** ## Beliebte Merge-Rezepte ### Allgemeiner Assistent + Programmierung ```yaml # Ideal für Entwickler, die auch allgemeine Fähigkeiten wollen 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 # Füge dem englischen Modell mehrsprachige Fähigkeiten hinzu 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-Artikel**: * **DARE-Artikel**: * **Clore.ai-Marktplatz**: *** ## GPU-Empfehlungen für Clore.ai {% hint style="warning" %} **Multi-GPU-Rigs der 80GB-Klasse sind auf dem Clore.ai-Marktplatz nicht gelistet.** Die größten heute gelisteten Systeme sind 4× RTX PRO 6000 Blackwell (je 96 GB, 380 GB gesamt) und 8–11× RTX 5090 (je 32 GB). Kapazitäten für A100 / H200 / B200 werden als [Bare Metal](https://clore.ai/bare-metal) auf Anfrage verkauft. Prüfe [GPU-Preise & Verfügbarkeit](/guides/guides_v2-de/erste-schritte/pricing.md) bevor du eine Bereitstellung dimensionierst. {% endhint %} | Anwendungsfall | Empfohlene GPU | Geschätzte Kosten bei Clore.ai | | ------------------------------ | ---------------- | ----------------------------------------- | | Entwicklung/Testen | RTX 3090 (24 GB) | 0,07–0,21 $/GPU/Stunde | | Modellzusammenführung (7B–13B) | RTX 4090 (24 GB) | 0,14–0,42 $/GPU/Stunde | | Große Modelle (70B+) | A100 80GB | [Bare Metal](https://clore.ai/bare-metal) | | Multi-GPU-Zusammenführung | 2-4x A100 80GB | [Bare Metal](https://clore.ai/bare-metal) | > 💡 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, and the optional `goal` query parameter: ``` GET https://docs.clore.ai/guides/guides_v2-de/training/mergekit.md?ask=&goal= ``` `ask` is the immediate question: it should be specific, self-contained, and written in natural language. `goal` is optional and describes the broader end goal you are ultimately trying to accomplish on behalf of the user. GitBook uses it to tailor the answer towards what is most useful for that goal. 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.