Mergekit मॉडल Merging

Mergekit प्रेट्रेंड बड़े भाषा मॉडलों को मर्ज करने के लिए यह निर्णायक टूलकिट है। 5K+ GitHub स्टार्स के साथ, यह हर प्रमुख मॉडल मर्जिंग एल्गोरिद्म — SLERP, TIES, DARE, DARE-TIES, MoE मर्जिंग, और अधिक — को लागू करता है, जिससे आप बिना किसी प्रशिक्षण डेटा या GPU प्रशिक्षण समय के शक्तिशाली नए मॉडल बना सकते हैं।

सभी उदाहरण GPU सर्वरों पर चलाए जा सकते हैं जिन्हें के माध्यम से किराये पर लिया जा सकता है CLORE.AI मार्केटप्लेस.

---

Mergekit क्या है?

मॉडल मर्जिंग एक शक्तिशाली तकनीक है जो कई LLMs की ताकतों को एकल मॉडल में संयोजित करती है:

• कोई प्रशिक्षण आवश्यक नहीं — मर्ज वेट स्पेस में होता है, बैकप्रोप के द्वारा नहीं

• क्षमताओं को संयोजित करें — एक कोडिंग मॉडल को एक निर्देश-अनुकरण मॉडल के साथ मिश्रित करें

• कमज़ोरियों को घटाएँ — एनसम्बल में व्यक्तिगत मॉडल की विफलताओं को औसत करके कम करें

• Mixture of Experts बनाएं — मॉडलों को एक स्पैर्स MoE आर्किटेक्चर में मिलाएँ

• डोमेन अनुकूलन — बेस मॉडल को डोमेन-विशेषीकृत मॉडलों के साथ मर्ज करें

Mergekit सभी स्टेट-ऑफ-द-आर्ट एल्गोरिद्म लागू करता है:

एल्गोरिथ्म	विवरण	माध्य/दिन
SLERP	दो मॉडलों के बीच स्फेरिकल लिनियर इंटरपोलेशन	दो समान मॉडलों का स्मूद मिश्रण
TIES	अवांछित पैरामीटर ट्रिम करें, साइन चुनें, मर्ज करें	कई मॉडलों को न्यूनतम हस्तक्षेप के साथ संयोजित करना
DARE	रैंडम पैरामीटर ड्रॉप और रीसकेल करें	बड़े मर्ज में पैरामीटर इंटरफेरेंस को कम करना
DARE-TIES	DARE + TIES संयुक्त	मल्टी-मॉडल मर्ज के लिए सर्वश्रेष्ठ समग्र विकल्प
Linear	सरल वेटेड औसत	त्वरित बेसलाइन मर्ज
Task Arithmetic	टास्क वेक्टर जोड़ें/घटाएं	विशिष्ट क्षमताओं को जोड़ना/हटाना
Passthrough	लेयर्स को सीधे कॉपी करें	MoE निर्माण

मॉडल मर्जिंग आश्चर्यजनक रूप से प्रभावी है। मर्ज किए गए मॉडल अक्सर सम्मिलित ज्ञान को मिलाकर बेंचमार्क पर अपने मूल मॉडलों से बेहतर प्रदर्शन करते हैं। HuggingFace पर MergeKit समुदाय में हज़ारों मर्ज किए गए मॉडलों की मेज़बानी है।

---

सर्वर आवश्यकताएँ

घटक	न्यूनतम	अनुशंसित
GPU	अनिवार्य नहीं (CPU मर्ज संभव)	बड़े मॉडलों के लिए A100 40 GB
VRAM	आणविक गतिशीलता	70B मॉडल मर्ज के लिए 80 GB
RAM	32 GB	64 GB+ (मॉडल RAM में लोड होते हैं)
CPU	8 कोर	16+ कोर
स्टोरेज	100 GB	500 GB+
ऑपरेटिंग सिस्टम	Ubuntu 20.04+	Ubuntu 22.04
Python	3.10+	3.11

केवल CPU मर्जिंग के लिए (सबसे सामान्य मोड), RAM आपकी बाधा है। bf16 में दो 7B मॉडल मर्ज करने के लिए न्यूनतम ~28 GB RAM की आवश्यकता होती है। उपयोग करें --lazy-unpickle कम मेमोरी उपयोग के लिए।

---

पोर्ट्स

पोर्ट	सेवा	नोट्स
22	SSH	टर्मिनल एक्सेस और फ़ाइल ट्रांसफ़र

Mergekit कमांड-लाइन टूल के रूप में चलता है — किसी वेब सर्वर की ज़रूरत नहीं।

---

Clore.ai पर इंस्टॉलेशन

चरण 1 — एक सर्वर किराए पर लें

1. जाएँ Clore.ai मार्केटप्लेस

2. फ़िल्टर करें RAM ≥ 64 GB (बड़े मॉडल मर्ज के लिए महत्वपूर्ण)

3. चुनें स्टोरेज ≥ 500 GB (मर्ज किए गए मॉडलों को 2-4 इनपुट मॉडलों + आउटपुट के लिए जगह चाहिए)

4. GPU वैकल्पिक है लेकिन उपयोगी है यदि आप बाद में मर्ज किए गए मॉडल का परीक्षण करना चाहते हैं

5. खुला पोर्ट 22 केवल

चरण 2 — SSH के द्वारा कनेक्ट करें

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

चरण 3 — Python पर्यावरण स्थापित करें

# Python 3.11 इंस्टॉल करें
apt-get update
apt-get install -y python3.11 python3.11-venv python3.11-pip git

# वर्चुअल एन्वायरनमेंट बनाएं
python3.11 -m venv /opt/mergekit
source /opt/mergekit/bin/activate

चरण 4 — Mergekit स्थापित करें

# PyPI से स्थापित करें
pip install mergekit

# या सोर्स से स्थापित करें (नवीनतम सुविधाओं के लिए अनुशंसित)
git clone https://github.com/arcee-ai/mergekit.git
cd mergekit
pip install -e '.[everything]'

चरण 5 — HuggingFace CLI स्थापित करें

pip install huggingface_hub
huggingface-cli login  # अपना HF टोकन दर्ज करें

चरण 6 — स्थापना सत्यापित करें

mergekit --help
mergekit-yaml --help

---

मर्ज करने के लिए मॉडल डाउनलोड करना

# जिन मॉडलों को आप मर्ज करना चाहते हैं उन्हें डाउनलोड करें
# huggingface_hub का उपयोग करते हुए

python3 << 'EOF'
from huggingface_hub import snapshot_download

# मॉडल 1 डाउनलोड करें
snapshot_download(
    repo_id="mistralai/Mistral-7B-Instruct-v0.3",
    local_dir="models/Mistral-7B-Instruct-v0.3"
)

# मॉडल 2 डाउनलोड करें
snapshot_download(
    repo_id="meta-llama/Llama-3.2-8B-Instruct",
    local_dir="models/Llama-3.2-8B-Instruct",
    token="hf_your-token"  # गेटेड मॉडलों के लिए आवश्यक
)
EOF

# या huggingface_hub CLI का उपयोग करें
huggingface-cli download mistralai/Mistral-7B-Instruct-v0.3 \
  --local-dir models/Mistral-7B-Instruct-v0.3

---

मर्ज कॉन्फ़िगरेशन

Mergekit मर्ज को परिभाषित करने के लिए YAML कॉन्फ़िगरेशन फ़ाइलों का उपयोग करता है।

उदाहरण 1: SLERP मर्ज (दो मॉडल)

SLERP दो मॉडलों को एक स्फेरिकल आर्क के साथ मिलाता है — समान आर्किटेक्चर वाले मॉडलों के लिए सबसे अच्छा:

# 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  # attention लेयर्स के लिए 50/50 मिश्रण
    - filter: mlp
      value: 0.3  # MLP लेयर्स के लिए मॉडल 2 से 30%
    - value: 0.5  # बाकी सब के लिए डिफ़ॉल्ट

dtype: bfloat16

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

उदाहरण 2: TIES मर्ज (कई मॉडल)

TIES कई मर्ज किए गए मॉडलों के बीच हस्तक्षेप को संभालता है:

# ties_merge.yaml
models:
  - model: models/Mistral-7B-v0.3
    parameters:
      weight: 1.0    # बेस मॉडल, पूर्ण वज़न
      density: 1.0

  - model: models/Mistral-7B-coding
    parameters:
      weight: 0.7    # कोडिंग क्षमता
      density: 0.5   # बदले गए पैरामीटर का 50% रखें

  - model: models/Mistral-7B-math
    parameters:
      weight: 0.5    # मैथ क्षमता
      density: 0.3   # बदले गए पैरामीटर का 30% रखें

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

उदाहरण 3: DARE-TIES मर्ज (सर्वोत्तम समग्र)

# 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

उदाहरण 4: Task Arithmetic (क्षमतियाँ जोड़ें)

बेस मॉडल में एक "skill delta" जोड़ें:

# task_arithmetic.yaml
# एक math-ट्यून किए गए मॉडल से गणित कौशल को सामान्य बेस मॉडल में जोड़ता है
models:
  - model: models/Llama-3.2-8B-Instruct
    parameters:
      weight: 1.0
  
  - model: models/Llama-3.2-8B-math
    parameters:
      weight: 0.7   # सकारात्मक = यह क्षमता जोड़ें
  
  # किसी क्षमता को हटाने के लिए, नकारात्मक वज़न का उपयोग करें:
  # - 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

उदाहरण 5: MoE (Mixture of Experts)

मॉडलों को एक स्पैर्स MoE आर्किटेक्चर में मिलाएँ:

# moe_merge.yaml
base_model: models/Llama-3.2-8B-Instruct

gate_mode: hidden  # एक्सपर्ट्स को रूट करने के लिए हिडन स्टेट्स का उपयोग करें
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

---

मर्ज चलाना

बेसिक कमांड

# एन्वायरनमेंट सक्रिय करें
source /opt/mergekit/bin/activate

# लेज़ी अनपिकलिंग के साथ मर्ज चलाएँ (RAM बचाता है)
mergekit-yaml your_config.yaml output_model/ --lazy-unpickle

# CUDA त्वरक के साथ (यदि GPU उपलब्ध है)
mergekit-yaml your_config.yaml output_model/ \
  --lazy-unpickle \
  --cuda \
  --copy-tokenizer

# लो मेमोरी मोड (धीमा पर छोटे सर्वरों पर काम करता है)
mergekit-yaml your_config.yaml output_model/ \
  --lazy-unpickle \
  --low-cpu-memory

प्रगति मॉनिटर करें

# Mergekit प्रत्येक लेयर के लिए प्रगति दिखाता है
# सामान्य आउटपुट:
# मॉडल 1 लोड कर रहा है...
# मॉडल 2 लोड कर रहा है...
# लेयर 0/32 मर्ज कर रहा है: embed_tokens
# लेयर 1/32 मर्ज कर रहा है: layers.0.self_attn
# ...
# मर्ज किया गया मॉडल सेव कर रहा है...
# हो गया! output_model/ में सेव किया गया

---

मर्ज किए गए मॉडल का परीक्षण

# 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

---

HuggingFace पर प्रकाशित करना

# लॉगिन
huggingface-cli login

# रिपॉजिटरी बनाएं और पुश करें
python3 << 'EOF'
from huggingface_hub import HfApi
api = HfApi()

# रिपो बनाएं
api.create_repo("my-merged-model-7b", private=False)

# मर्ज किया हुआ मॉडल अपलोड करें
api.upload_folder(
    folder_path="output_model/",
    repo_id="your-username/my-merged-model-7b",
    repo_type="model"
)
print("Uploaded!")
EOF

---

उन्नत: Evolutionary Merge

Mergekit के evolutionary optimizer का उपयोग करके अनुकूल मर्ज वज़न खोजें:

# evolutionary optimizer स्थापित करें
pip install 'mergekit[evo]'

# evolutionary सर्च चलाएँ
mergekit-evolve evolve_config.yaml \
  --storage-path ./evolve-workspace \
  --n-iterations 100 \
  --task mmlu  # MMLU बेंचमार्क के लिए अनुकूलित करें

---

समस्या निवारण

मर्ज के दौरान मेमोरी समाप्त (OOM)

# बड़े मॉडलों के लिए हमेशा --lazy-unpickle का उपयोग करें
mergekit-yaml config.yaml out/ --lazy-unpickle

# --low-cpu-memory फ़्लैग जोड़ें
mergekit-yaml config.yaml out/ --lazy-unpickle --low-cpu-memory

# मर्ज करने से पहले उपलब्ध RAM चेक करें
free -h

# 7B मॉडलों के लिए आपको ~30 GB RAM न्यूनतम चाहिए
# 13B मॉडलों के लिए: ~60 GB RAM
# 70B मॉडलों के लिए: ~280 GB RAM (या उच्च-RAM CPU सर्वर का उपयोग करें)

ValueError: मॉडल संगत नहीं हैं

# मॉडलों की आर्किटेक्चर समान होनी चाहिए
# आप सीधे Llama-3 को Mistral के साथ मर्ज नहीं कर सकते
# मॉडल कॉन्फ़िग्स जांचें
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'))
"

मर्ज बहुत धीमा है

# तेज़ टेन्सर ऑपरेशन्स के लिए GPU का उपयोग करें
mergekit-yaml config.yaml out/ --lazy-unpickle --cuda

# सुनिश्चित करें कि PyTorch CUDA के साथ इंस्टॉल हो
python3 -c "import torch; print(torch.cuda.is_available())"

# यदि CUDA उपलब्ध नहीं है, तो इसे इंस्टॉल करें:
pip install torch --index-url https://download.pytorch.org/whl/cu121

मर्ज किया गया मॉडल बकवास उत्पादन कर रहा है

# सामान्य कारण:
# 1. असंगत मॉडल फैमिली का मर्ज (उदा., Llama + Mistral)
# 2. वज़न बहुत चरम (SLERP के लिए t=0 या t=1 के बजाय 0.3-0.7)
# 3. TIES में बहुत उच्च density (डेंसिटी: 0.3-0.5 आज़माएँ)

# डायग्नोस्टिक: पहले प्रत्येक पेरेन्ट मॉडल का परीक्षण करें
# फिर बेसलाइन के रूप में 50/50 SLERP मर्ज आज़माएँ

# मर्ज किए गए मॉडल का कॉन्फ़िग़ देखें
cat output_model/config.json | python3 -m json.tool

FileNotFoundError मॉडल फ़ाइलों के लिए

# जो डाउनलोड हुआ उसका सूची बनाएं
ls -la models/your-model/

# आवश्यक फ़ाइलें:
# config.json, tokenizer.json, *.safetensors (या *.bin)

# ज़रूरत हो तो फोर्स के साथ फिर से डाउनलोड करें
huggingface-cli download <repo_id> --local-dir models/<name> --force-download

---

लोकप्रिय मर्ज रेसिपीज़

जनरल असिस्टेंट + कोडिंग

# डेवलपर्स के लिए शानदार जो सामान्य क्षमता भी चाहते हैं
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

बहुभाषी बूस्ट

# अंग्रेज़ी मॉडल में बहुभाषी क्षमताएँ जोड़ें
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

---

उपयोगी लिंक

• GitHub: https://github.com/arcee-ai/mergekit ⭐ 5K+

• दस्तावेज़ीकरण: https://github.com/arcee-ai/mergekit/wiki

• HuggingFace पर MergeKit मॉडल: https://huggingface.co/models?other=mergekit

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

• TIES पेपर: https://arxiv.org/abs/2306.01708

• DARE पेपर: https://arxiv.org/abs/2311.03099

• Clore.ai मार्केटप्लेस: https://clore.ai/marketplace

---

Clore.ai GPU सिफारिशें

उपयोग केस	सिफारिश की गई GPU	Clore.ai पर अनुमानित लागत
डेवलपमेंट/टेस्टिंग	RTX 3090 (24GB)	~$0.12/gpu/hr
मॉडल मर्जिंग (7B–13B)	RTX 4090 (24GB)	~$0.70/gpu/hr
बड़े मॉडल (70B+)	A100 80GB	~$1.20/gpu/hr
मल्टी-GPU मर्जिंग	2-4x A100 80GB	~$2.40–$4.80/hr

💡 इस गाइड के सभी उदाहरण तैनात किए जा सकते हैं Clore.ai GPU सर्वरों पर। उपलब्ध GPUs ब्राउज़ करें और घंटे के हिसाब से किराए पर लें — कोई प्रतिबद्धता नहीं, पूर्ण रूट एक्सेस।