> 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-hi/training/mergekit.md). # Mergekit मॉडल मर्जिंग **Mergekit** प्रीट्रेन्ड बड़े भाषा मॉडलों को मर्ज करने के लिए यह अंतिम टूलकिट है। 5K+ GitHub स्टार्स के साथ, यह हर प्रमुख मॉडल-मर्जिंग एल्गोरिद्म — SLERP, TIES, DARE, DARE-TIES, MoE मर्जिंग, और भी बहुत कुछ — लागू करता है, जिससे आप बिना किसी प्रशिक्षण डेटा या GPU प्रशिक्षण समय के शक्तिशाली नए मॉडल बना सकते हैं। {% hint style="success" %} सभी उदाहरण GPU सर्वरों पर चलाए जा सकते हैं, जिन्हें किराए पर लिया गया है [CLORE.AI मार्केटप्लेस](https://clore.ai/marketplace). {% endhint %} *** ## Mergekit क्या है? मॉडल मर्जिंग एक शक्तिशाली तकनीक है जो कई LLMs की ताकतों को एक ही मॉडल में जोड़ती है: * **कोई प्रशिक्षण आवश्यक नहीं** — मर्ज वेट स्पेस में होता है, बैकप्रोप के माध्यम से नहीं * **क्षमताओं को मिलाएं** — एक कोडिंग मॉडल को एक निर्देश-पालन करने वाले मॉडल के साथ मिलाएं * **कमज़ोरियों को कम करें** — एक एन्सेम्बल में प्रत्येक मॉडल की विफलताओं का औसत निकालें * **विशेषज्ञों का मिश्रण बनाएं** — मॉडलों को एक sparse MoE आर्किटेक्चर में मिलाएं * **डोमेन अनुकूलन** — बेस मॉडल को डोमेन-विशेषीकृत मॉडलों के साथ मर्ज करें Mergekit सभी अत्याधुनिक एल्गोरिद्म लागू करता है: | एल्गोरिद्म | विवरण | किसके लिए सर्वोत्तम | | ----------------- | ----------------------------------------------- | --------------------------------------------------- | | **SLERP** | दो मॉडलों के बीच गोलाकार रेखीय प्रक्षेपण | दो समान मॉडलों का सुचारु मिश्रण | | **TIES** | अनावश्यक पैरामीटर काटें, संकेत चुनें, मर्ज करें | न्यूनतम हस्तक्षेप के साथ कई मॉडलों को जोड़ना | | **DARE** | रैंडम पैरामीटर हटाएँ और पुनःस्केल करें | बड़े मर्ज में पैरामीटर हस्तक्षेप को कम करना | | **DARE-TIES** | DARE + TIES का संयोजन | मल्टी-मॉडल मर्ज के लिए सर्वश्रेष्ठ सर्वांगीण विकल्प | | **रेखीय** | सरल भारित औसत | त्वरित बेसलाइन मर्ज | | **टास्क अंकगणित** | टास्क वेक्टर जोड़ें/घटाएँ | विशिष्ट क्षमताएँ जोड़ना/हटाना | | **पासथ्रू** | लेयरों को सीधे कॉपी करें | 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 # ध्यान लेयरों के लिए 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: टास्क अंकगणित (क्षमताएँ जोड़ें) बेस मॉडल में एक "स्किल डेल्टा" जोड़ें: ```yaml # task_arithmetic.yaml # गणित-ट्यून किए गए मॉडल से गणित कौशल को एक सामान्य बेस मॉडल में जोड़ता है 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 (विशेषज्ञों का मिश्रण) मॉडलों को एक sparse MoE आर्किटेक्चर में मिलाएं: ```yaml # moe_merge.yaml base_model: models/Llama-3.2-8B-Instruct gate_mode: hidden # विशेषज्ञों तक रूट करने के लिए hidden states का उपयोग करें dtype: bfloat16 experts: - source_model: models/Llama-3.2-8B-coding positive_prompts: - "कोड लिखें" - "इस फ़ंक्शन को डीबग करें" - "एक एल्गोरिद्म लागू करें" negative_prompts: - "मुझे एक कहानी सुनाओ" - "इतिहास समझाइए" - source_model: models/Llama-3.2-8B-creative positive_prompts: - "एक कहानी लिखो" - "रचनात्मक बनो" - "कल्पना करो" negative_prompts: - "कोड लिखें" - "गणना करो" ``` ```bash mergekit-moe moe_merge.yaml merged-moe/ --lazy-unpickle ``` *** ## मर्ज चलाना ### बुनियादी कमांड ```bash # वातावरण सक्रिय करें source /opt/mergekit/bin/activate # lazy unpickling के साथ मर्ज चलाएँ (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 = "LoRA और पूर्ण fine-tuning के बीच अंतर समझाइए:" 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("अपलोड हो गया!") EOF ``` *** ## उन्नत: विकासवादी मर्ज सर्वोत्तम मर्ज वज़न खोजने के लिए Mergekit के evolutionary optimizer का उपयोग करें: ```bash # evolutionary optimizer स्थापित करें pip install 'mergekit[evo]' # evolutionary search चलाएँ mergekit-evolve evolve_config.yaml \\ --storage-path ./evolve-workspace \\ --n-iterations 100 \\ --task mmlu # MMLU बेंचमार्क के लिए अनुकूलित करें ``` *** ## समस्या निवारण ### मर्ज के दौरान Out of Memory (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 # सुनिश्चित करें कि CUDA के साथ PyTorch स्थापित है python3 -c "import torch; print(torch.cuda.is_available())" # यदि CUDA उपलब्ध नहीं है, तो इसे स्थापित करें: pip install torch --index-url https://download.pytorch.org/whl/cu128 ``` ### मर्ज किया गया मॉडल निरर्थक/अर्थहीन आउटपुट देता है ```bash # सामान्य कारण: # 1. असंगत मॉडल परिवारों को मर्ज करना (जैसे, Llama + Mistral) # 2. वज़न बहुत चरम हैं (SLERP के लिए 0.3-0.7 के बजाय t=0 या t=1) # 3. TIES में density बहुत अधिक है (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) # force के साथ फिर से डाउनलोड करें 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 अनुशंसाएँ {% hint style="warning" %} **Clore.ai marketplace पर multi-GPU 80GB-class rigs सूचीबद्ध नहीं हैं।** आज सूचीबद्ध सबसे बड़े boxes 4× RTX PRO 6000 Blackwell (प्रत्येक 96GB, कुल 380GB) और 8–11× RTX 5090 (प्रत्येक 32GB) हैं। A100 / H200 / B200 क्षमता [bare metal](https://clore.ai/bare-metal) के रूप में अनुरोध पर बेची जाती है। देखें [GPU मूल्य और उपलब्धता](/guides/guides_v2-hi/getting-started/pricing.md) किसी deployment का आकार तय करने से पहले। {% endhint %} | उपयोग-प्रकरण | अनुशंसित GPU | Clore.ai पर अनुमानित लागत | | --------------------- | --------------- | ----------------------------------------- | | विकास/परीक्षण | RTX 3090 (24GB) | $0.07–0.21/gpu/hr | | मॉडल मर्जिंग (7B–13B) | RTX 4090 (24GB) | $0.14–0.42/gpu/hr | | बड़े मॉडल (70B+) | A100 80GB | [bare metal](https://clore.ai/bare-metal) | | मल्टी-GPU मर्जिंग | 2-4x A100 80GB | [bare metal](https://clore.ai/bare-metal) | > 💡 इस गाइड के सभी उदाहरण [Clore.ai](https://clore.ai/marketplace) GPU servers पर तैनात किए जा सकते हैं। उपलब्ध GPUs ब्राउज़ करें और घंटे के हिसाब से किराए पर लें — कोई प्रतिबद्धता नहीं, पूर्ण root access. --- # 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-hi/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.