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.

Alle Beispiele können auf GPU-Servern ausgeführt werden, die gemietet wurden über CLORE.AI-Marktplatz.

---

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

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.

---

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

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.

---

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

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

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

Schritt 3 — Python-Umgebung installieren

# 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

# 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

pip install huggingface_hub
huggingface-cli login  # Gib deinen HF-Token ein

Schritt 6 — Installation überprüfen

mergekit --help
mergekit-yaml --help

---

Modelle zum Zusammenführen herunterladen

# 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:

# 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

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

Beispiel 2: TIES-Merge (mehrere Modelle)

TIES behandelt Interferenzen zwischen mehreren zusammengeführten Modellen:

# 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

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

Beispiel 3: DARE-TIES-Merge (der beste Allrounder)

# 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

Beispiel 4: Task-Arithmetik (Fähigkeiten hinzufügen)

Füge einem Basismodell ein "Fähigkeits-Delta" hinzu:

# 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:

# 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"

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

---

Merge ausführen

Grundbefehl

# 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

# 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

# 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

# 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:

# 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

# 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

# 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

# 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

# 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

# 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 <repo_id> --local-dir models/<name> --force-download

---

Beliebte Merge-Rezepte

Allgemeiner Assistent + Programmierung

# 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

# 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: https://github.com/arcee-ai/mergekit ⭐ 5K+

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

• MergeKit-Modelle auf HuggingFace: https://huggingface.co/models?other=mergekit

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

• TIES-Artikel: https://arxiv.org/abs/2306.01708

• DARE-Artikel: https://arxiv.org/abs/2311.03099

• Clore.ai-Marktplatz: https://clore.ai/marketplace

---

GPU-Empfehlungen für Clore.ai

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 auf Anfrage verkauft. Prüfe GPU-Preise & Verfügbarkeit bevor du eine Bereitstellung dimensionierst.

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
Multi-GPU-Zusammenführung	2-4x A100 80GB	Bare Metal

💡 Alle Beispiele in diesem Leitfaden können bereitgestellt werden auf Clore.ai GPU-Servern. Durchsuchen Sie verfügbare GPUs und mieten Sie stundenweise — keine Verpflichtungen, voller Root-Zugriff.