# Mergekit मॉडल मर्जिंग **Mergekit** प्रेट्रेंड बड़े भाषा मॉडलों को मर्ज करने के लिए यह निर्णायक टूलकिट है। 5K+ GitHub स्टार्स के साथ, यह हर प्रमुख मॉडल मर्जिंग एल्गोरिद्म — SLERP, TIES, DARE, DARE-TIES, MoE मर्जिंग, और अधिक — को लागू करता है, जिससे आप बिना किसी प्रशिक्षण डेटा या GPU प्रशिक्षण समय के शक्तिशाली नए मॉडल बना सकते हैं। {% hint style="success" %} सभी उदाहरण GPU सर्वरों पर चलाए जा सकते हैं जिन्हें के माध्यम से किराये पर लिया जा सकता है [CLORE.AI मार्केटप्लेस](https://clore.ai/marketplace). {% endhint %} *** ## Mergekit क्या है? मॉडल मर्जिंग एक शक्तिशाली तकनीक है जो कई LLMs की ताकतों को एकल मॉडल में संयोजित करती है: * **कोई प्रशिक्षण आवश्यक नहीं** — मर्ज वेट स्पेस में होता है, बैकप्रोप के द्वारा नहीं * **क्षमताओं को संयोजित करें** — एक कोडिंग मॉडल को एक निर्देश-अनुकरण मॉडल के साथ मिश्रित करें * **कमज़ोरियों को घटाएँ** — एनसम्बल में व्यक्तिगत मॉडल की विफलताओं को औसत करके कम करें * **Mixture of Experts बनाएं** — मॉडलों को एक स्पैर्स MoE आर्किटेक्चर में मिलाएँ * **डोमेन अनुकूलन** — बेस मॉडल को डोमेन-विशेषीकृत मॉडलों के साथ मर्ज करें Mergekit सभी स्टेट-ऑफ-द-आर्ट एल्गोरिद्म लागू करता है: | एल्गोरिथ्म | विवरण | माध्य/दिन | | ------------------- | -------------------------------------------------- | -------------------------------------------------- | | **SLERP** | दो मॉडलों के बीच स्फेरिकल लिनियर इंटरपोलेशन | दो समान मॉडलों का स्मूद मिश्रण | | **TIES** | अवांछित पैरामीटर ट्रिम करें, साइन चुनें, मर्ज करें | कई मॉडलों को न्यूनतम हस्तक्षेप के साथ संयोजित करना | | **DARE** | रैंडम पैरामीटर ड्रॉप और रीसकेल करें | बड़े मर्ज में पैरामीटर इंटरफेरेंस को कम करना | | **DARE-TIES** | DARE + TIES संयुक्त | मल्टी-मॉडल मर्ज के लिए सर्वश्रेष्ठ समग्र विकल्प | | **Linear** | सरल वेटेड औसत | त्वरित बेसलाइन मर्ज | | **Task Arithmetic** | टास्क वेक्टर जोड़ें/घटाएं | विशिष्ट क्षमताओं को जोड़ना/हटाना | | **Passthrough** | लेयर्स को सीधे कॉपी करें | MoE निर्माण | {% hint style="info" %} मॉडल मर्जिंग आश्चर्यजनक रूप से प्रभावी है। मर्ज किए गए मॉडल अक्सर सम्मिलित ज्ञान को मिलाकर बेंचमार्क पर अपने मूल मॉडलों से बेहतर प्रदर्शन करते हैं। HuggingFace पर MergeKit समुदाय में हज़ारों मर्ज किए गए मॉडलों की मेज़बानी है। {% endhint %} *** ## सर्वर आवश्यकताएँ | घटक | न्यूनतम | अनुशंसित | | --------------- | ----------------------------- | ---------------------------------- | | 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 | {% hint style="warning" %} केवल CPU मर्जिंग के लिए (सबसे सामान्य मोड), RAM आपकी बाधा है। bf16 में दो 7B मॉडल मर्ज करने के लिए न्यूनतम \~28 GB RAM की आवश्यकता होती है। उपयोग करें `--lazy-unpickle` कम मेमोरी उपयोग के लिए। {% endhint %} *** ## पोर्ट्स | पोर्ट | सेवा | नोट्स | | ----- | ---- | --------------------------------- | | 22 | SSH | टर्मिनल एक्सेस और फ़ाइल ट्रांसफ़र | Mergekit कमांड-लाइन टूल के रूप में चलता है — किसी वेब सर्वर की ज़रूरत नहीं। *** ## Clore.ai पर इंस्टॉलेशन ### चरण 1 — एक सर्वर किराए पर लें 1. जाएँ [Clore.ai मार्केटप्लेस](https://clore.ai/marketplace) 2. फ़िल्टर करें **RAM ≥ 64 GB** (बड़े मॉडल मर्ज के लिए महत्वपूर्ण) 3. चुनें **स्टोरेज ≥ 500 GB** (मर्ज किए गए मॉडलों को 2-4 इनपुट मॉडलों + आउटपुट के लिए जगह चाहिए) 4. GPU वैकल्पिक है लेकिन उपयोगी है यदि आप बाद में मर्ज किए गए मॉडल का परीक्षण करना चाहते हैं 5. खुला पोर्ट **22** केवल ### चरण 2 — SSH के द्वारा कनेक्ट करें ```bash ssh root@ -p ``` ### चरण 3 — Python पर्यावरण स्थापित करें ```bash # 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 स्थापित करें ```bash # PyPI से स्थापित करें pip install mergekit # या सोर्स से स्थापित करें (नवीनतम सुविधाओं के लिए अनुशंसित) git clone https://github.com/arcee-ai/mergekit.git cd mergekit pip install -e '.[everything]' ``` ### चरण 5 — HuggingFace CLI स्थापित करें ```bash pip install huggingface_hub huggingface-cli login # अपना HF टोकन दर्ज करें ``` ### चरण 6 — स्थापना सत्यापित करें ```bash mergekit --help mergekit-yaml --help ``` *** ## मर्ज करने के लिए मॉडल डाउनलोड करना ```bash # जिन मॉडलों को आप मर्ज करना चाहते हैं उन्हें डाउनलोड करें # 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 दो मॉडलों को एक स्फेरिकल आर्क के साथ मिलाता है — समान आर्किटेक्चर वाले मॉडलों के लिए सबसे अच्छा: ```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 # attention लेयर्स के लिए 50/50 मिश्रण - filter: mlp value: 0.3 # MLP लेयर्स के लिए मॉडल 2 से 30% - value: 0.5 # बाकी सब के लिए डिफ़ॉल्ट dtype: bfloat16 ``` ```bash mergekit-yaml slerp_merge.yaml merged-model/ --lazy-unpickle ``` ### उदाहरण 2: TIES मर्ज (कई मॉडल) TIES कई मर्ज किए गए मॉडलों के बीच हस्तक्षेप को संभालता है: ```yaml # 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 ``` ```bash mergekit-yaml ties_merge.yaml merged-ties/ --lazy-unpickle ``` ### उदाहरण 3: DARE-TIES मर्ज (सर्वोत्तम समग्र) ```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 ``` ### उदाहरण 4: Task Arithmetic (क्षमतियाँ जोड़ें) बेस मॉडल में एक "skill delta" जोड़ें: ```yaml # 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 आर्किटेक्चर में मिलाएँ: ```yaml # 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" ``` ```bash mergekit-moe moe_merge.yaml merged-moe/ --lazy-unpickle ``` *** ## मर्ज चलाना ### बेसिक कमांड ```bash # एन्वायरनमेंट सक्रिय करें 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 ``` ### प्रगति मॉनिटर करें ```bash # Mergekit प्रत्येक लेयर के लिए प्रगति दिखाता है # सामान्य आउटपुट: # मॉडल 1 लोड कर रहा है... # मॉडल 2 लोड कर रहा है... # लेयर 0/32 मर्ज कर रहा है: embed_tokens # लेयर 1/32 मर्ज कर रहा है: layers.0.self_attn # ... # मर्ज किया गया मॉडल सेव कर रहा है... # हो गया! output_model/ में सेव किया गया ``` *** ## मर्ज किए गए मॉडल का परीक्षण ```bash # 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 पर प्रकाशित करना ```bash # लॉगिन 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 का उपयोग करके अनुकूल मर्ज वज़न खोजें: ```bash # evolutionary optimizer स्थापित करें pip install 'mergekit[evo]' # evolutionary सर्च चलाएँ mergekit-evolve evolve_config.yaml \ --storage-path ./evolve-workspace \ --n-iterations 100 \ --task mmlu # MMLU बेंचमार्क के लिए अनुकूलित करें ``` *** ## समस्या निवारण ### मर्ज के दौरान मेमोरी समाप्त (OOM) ```bash # बड़े मॉडलों के लिए हमेशा --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: मॉडल संगत नहीं हैं` ```bash # मॉडलों की आर्किटेक्चर समान होनी चाहिए # आप सीधे 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')) " ``` ### मर्ज बहुत धीमा है ```bash # तेज़ टेन्सर ऑपरेशन्स के लिए 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 ``` ### मर्ज किया गया मॉडल बकवास उत्पादन कर रहा है ```bash # सामान्य कारण: # 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` मॉडल फ़ाइलों के लिए ```bash # जो डाउनलोड हुआ उसका सूची बनाएं ls -la models/your-model/ # आवश्यक फ़ाइलें: # config.json, tokenizer.json, *.safetensors (या *.bin) # ज़रूरत हो तो फोर्स के साथ फिर से डाउनलोड करें huggingface-cli download --local-dir models/ --force-download ``` *** ## लोकप्रिय मर्ज रेसिपीज़ ### जनरल असिस्टेंट + कोडिंग ```yaml # डेवलपर्स के लिए शानदार जो सामान्य क्षमता भी चाहते हैं 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 ``` ### बहुभाषी बूस्ट ```yaml # अंग्रेज़ी मॉडल में बहुभाषी क्षमताएँ जोड़ें 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**: ⭐ 5K+ * **दस्तावेज़ीकरण**: * **HuggingFace पर MergeKit मॉडल**: * **Arcee.ai Discord**: * **TIES पेपर**: * **DARE पेपर**: * **Clore.ai मार्केटप्लेस**: *** ## 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](https://clore.ai/marketplace) GPU सर्वरों पर। उपलब्ध GPUs ब्राउज़ करें और घंटे के हिसाब से किराए पर लें — कोई प्रतिबद्धता नहीं, पूर्ण रूट एक्सेस।