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.

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

---

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

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.

---

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

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.

---

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

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

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

# 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

pip install huggingface_hub
huggingface-cli login  # Geben Sie Ihr HF-Token ein

Schritt 6 — Installation überprüfen

mergekit --help
mergekit-yaml --help

---

Modelle zum Zusammenführen herunterladen

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

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

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

Beispiel 3: DARE-TIES Merge (Beste Allround-Lösung)

# 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 Arithmetic (Fähigkeiten hinzufügen)

Fügen Sie einem Basismodell ein „Skill-Delta“ hinzu:

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

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

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

---

Den Merge ausführen

Grundlegender Befehl

# 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

# 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

# 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

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

# 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

# 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

# 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

# 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

# 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

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

---

Beliebte Merge-Rezepte

Allgemeiner Assistent + Coding

# 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

# 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: 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 Paper: https://arxiv.org/abs/2306.01708

• DARE Paper: https://arxiv.org/abs/2311.03099

• Clore.ai Marketplace: https://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 GPU-Servern. Durchsuchen Sie verfügbare GPUs und mieten Sie stundenweise — keine Verpflichtungen, voller Root-Zugriff.