--- title: "PEFT (Parameter-Efficient Fine-Tuning) (HI)" source: "https://systems-analysis.info/int/PEFT_(Parameter-Efficient_Fine-Tuning)_(HI)" wiki: "systems-analysis.info/int" article: "PEFT_(Parameter-Efficient_Fine-Tuning)_(HI)" language: "hi" categories: - "Category:Hindi" - "Category:Large language models" - "Category:Machine learning" revision_id: 5287 wiki_created_at: 2026-09-06T23:47:09Z wiki_modified_at: 2026-09-06T23:47:09Z downloaded_at: 2026-09-07T23:07:37Z --- # PEFT (Parameter-Efficient Fine-Tuning) (HI) **पैरामीटर-कुशल फाइन-ट्यूनिंग** (अंग्रेज़ी: **Parameter-Efficient Fine-Tuning, PEFT**) — यह बड़े पूर्व-प्रशिक्षित मॉडलों, जैसे कि बड़े भाषा मॉडल (LLM), को न्यूनतम कम्प्यूटेशनल और संसाधन लागत के साथ विशिष्ट कार्यों के लिए अनुकूलित करने के तरीकों का एक समूह है। पारंपरिक **पूर्ण fine-tuning** (*full fine-tuning*) के विपरीत, जिसमें मॉडल के सभी पैरामीटर अपडेट करने की आवश्यकता होती है, PEFT-विधियाँ केवल थोड़े से भारों (कुल संख्या के 1-5% से कम) को संशोधित करने पर ध्यान केंद्रित करती हैं, और मॉडल के मुख्य भाग को अपरिवर्तित («फ्रोज़न») रखती हैं[\[1\]](https://systems-analysis.info/int/PEFT_(Parameter-Efficient_Fine-Tuning)_(HI)#cite_note-survey_arxiv_2025-1)। यह दृष्टिकोण मेमोरी, भंडारण और प्रशिक्षण समय की आवश्यकताओं को काफी कम करता है, जिससे शक्तिशाली मूलभूत मॉडलों की अनुकूलन प्रक्रिया अधिक सुलभ और विनाशकारी विस्मरण (catastrophic forgetting) की समस्या के प्रति अधिक प्रतिरोधी बनती है[\[2\]](https://systems-analysis.info/int/PEFT_(Parameter-Efficient_Fine-Tuning)_(HI)#cite_note-mlm_problems_2025-2)। ## पूर्ण fine-tuning की समस्याएँ पारंपरिक पूर्ण fine-tuning, जिसमें मॉडल के सभी पैरामीटर अपडेट किए जाते हैं, कई गंभीर समस्याओं का सामना करती है, जो PEFT के विकास के लिए उत्प्रेरक बनीं: - **उच्च कम्प्यूटेशनल लागत:** सैकड़ों अरबों पैरामीटर अपडेट करने के लिए विशाल कम्प्यूटेशनल शक्ति (उच्च-प्रदर्शन GPU/TPU) और बड़ी मात्रा में वीडियो मेमोरी (VRAM) की आवश्यकता होती है, जिससे यह प्रक्रिया महंगी और कई शोधकर्ताओं के लिए दुर्गम हो जाती है। - **भंडारण की अक्षमता:** प्रत्येक नए कार्य के लिए मॉडल की पूरी, कई-गीगाबाइट प्रति संग्रहीत करना आवश्यक है, जिससे डिस्क स्थान की आवश्यकताएँ तेज़ी से बढ़ती हैं। - **विनाशकारी विस्मरण (Catastrophic Forgetting):** मॉडल, नए डेटा के अनुकूल होते समय, पूर्व-प्रशिक्षण के दौरान अर्जित सामान्य ज्ञान को «भूल» जाता है, जिससे अन्य कार्यों पर उसकी प्रदर्शनक्षमता घट जाती है। - **ओवरफिटिंग का जोखिम (Overfitting):** छोटे डेटासेट पर, अरबों पैरामीटर वाले मॉडल सामान्यीकरण के पैटर्न सीखने की बजाय प्रशिक्षण उदाहरणों को «याद» कर लेते हैं[\[2\]](https://systems-analysis.info/int/PEFT_(Parameter-Efficient_Fine-Tuning)_(HI)#cite_note-mlm_problems_2025-2)। ## PEFT विधियों की वर्गीकरण प्रणाली PEFT विधियों को इस आधार पर वर्गीकृत किया जा सकता है कि वे मॉडल के पैरामीटर किस प्रकार बदलती हैं। तीन मुख्य श्रेणियाँ हैं: योगात्मक (additive), चयनात्मक (selective) और पुनःपैरामीटरीकरण (reparameterization)[\[3\]](https://systems-analysis.info/int/PEFT_(Parameter-Efficient_Fine-Tuning)_(HI)#cite_note-huggingface_peft_methods-3)। ### योगात्मक विधियाँ ये विधियाँ मॉडल के सभी मूल भारों को फ्रीज़ करती हैं और नए, छोटे प्रशिक्षण योग्य मॉड्यूल जोड़ती हैं। - **Adapters:** सबसे प्रारंभिक योगात्मक विधि। «बॉटलनेक» आर्किटेक्चर वाले छोटे न्यूरल नेटवर्क मॉड्यूल transformer की परतों के बीच डाले जाते हैं। केवल इन adapters के भार प्रशिक्षित किए जाते हैं[\[4\]](https://systems-analysis.info/int/PEFT_(Parameter-Efficient_Fine-Tuning)_(HI)#cite_note-houlsby2019-4)। - **«सॉफ्ट» prompt पर आधारित विधियाँ (Soft Prompts):** मॉडल के भार बदलने की बजाय, ये विधियाँ इनपुट डेटा में प्रशिक्षण योग्य वेक्टर («वर्चुअल token») जोड़ती हैं, जो मॉडल के व्यवहार को निर्देशित करते हैं। प्रमुख रूप: - **Prompt Tuning:** केवल इनपुट embedding में प्रशिक्षण योग्य वेक्टर जोड़ता है। - **Prefix-Tuning:** attention mechanism की प्रत्येक परत पर hidden states में प्रशिक्षण योग्य वेक्टर prefix जोड़ता है, जिससे अधिक सूक्ष्म नियंत्रण मिलता है[\[5\]](https://systems-analysis.info/int/PEFT_(Parameter-Efficient_Fine-Tuning)_(HI)#cite_note-li2021prefix-5)। - **P-Tuning v2:** Prefix-Tuning के विचार का सामान्यीकरण, जो मॉडल की सभी परतों पर प्रशिक्षण योग्य prompt लागू करता है और पूर्ण fine-tuning के बराबर प्रदर्शन प्राप्त करता है[\[6\]](https://systems-analysis.info/int/PEFT_(Parameter-Efficient_Fine-Tuning)_(HI)#cite_note-liu2021ptuningv2-6)। ### चयनात्मक विधियाँ ये विधियाँ नए पैरामीटर नहीं जोड़तीं, बल्कि पहले से मौजूद पैरामीटर के एक छोटे उपसमूह को चुनकर fine-tune करती हैं। - **BitFit:** अत्यंत किफायती विधि, जो केवल bias terms और normalization परतों के पैरामीटर को fine-tune करती है, जिससे कुल पैरामीटर के 0.1% से कम अपडेट होते हैं। - **अंतर प्रूनिंग (Diff Pruning):** प्रशिक्षण प्रक्रिया के दौरान यह गतिशील रूप से निर्धारित करने के लिए एक प्रशिक्षण योग्य मास्क का उपयोग करता है कि कौन से भार अपडेट किए जाने चाहिए[\[3\]](https://systems-analysis.info/int/PEFT_(Parameter-Efficient_Fine-Tuning)_(HI)#cite_note-huggingface_peft_methods-3)। ### पुनःपैरामीटरीकरण विधियाँ यह श्रेणी इस परिकल्पना पर आधारित है कि मॉडल अनुकूलन के लिए भार परिवर्तनों का «आंतरिक रैंक» निम्न होता है। पूर्ण आकार की भार मैट्रिसेज़ अपडेट करने की बजाय, ये विधियाँ उनके निम्न-रैंक प्रतिनिधित्व को अपडेट करती हैं। - **LoRA (Low-Rank Adaptation):** आज का सबसे लोकप्रिय PEFT-तरीका। यह मानता है कि भार मैट्रिक्स अपडेट \`ΔW\` को दो निम्न-रैंक मैट्रिसेज़ के गुणनफल द्वारा सन्निकटित किया जा सकता है: \`ΔW = BA\`। fine-tuning के दौरान मूल मैट्रिक्स \`W\` फ्रीज़ रहती है, और केवल \`A\` और \`B\` प्रशिक्षित होती हैं[\[7\]](https://systems-analysis.info/int/PEFT_(Parameter-Efficient_Fine-Tuning)_(HI)#cite_note-hu2021lora-7)। - **QLoRA:** LoRA को quantization तकनीकों के साथ जोड़ता है ताकि मेमोरी आवश्यकताएँ और भी कम हों, जिससे 65 अरब पैरामीटर वाले मॉडलों को एक उपभोक्ता-स्तरीय GPU पर fine-tune किया जा सके[\[8\]](https://systems-analysis.info/int/PEFT_(Parameter-Efficient_Fine-Tuning)_(HI)#cite_note-dettmers2023qlora-8)। ## प्रदर्शन और संसाधनों की तुलना PEFT-विधियाँ लागत में आमूल कमी करते हुए पूर्ण fine-tuning के बराबर प्रदर्शन प्राप्त करना संभव बनाती हैं। | मॉडल | विधि | प्रशिक्षण योग्य पैरामीटर (%) | benchmark पर परिणाम (Avg. Accuracy) | स्रोत | |------------|-------------------------|--------------------------|-------------------------------------|---------------------------------------------------------------------------------------------------------------------------| | BERT-Large | पूर्ण fine-tuning | 100% | 80.4 (GLUE) | [\[4\]](https://systems-analysis.info/int/PEFT_(Parameter-Efficient_Fine-Tuning)_(HI)#cite_note-houlsby2019-4) | | BERT-Large | Adapters | 3.6% | 80.0 (GLUE) | [\[4\]](https://systems-analysis.info/int/PEFT_(Parameter-Efficient_Fine-Tuning)_(HI)#cite_note-houlsby2019-4) | | LLaMA-7B | LoRA | 0.83% | 74.7% | [\[9\]](https://systems-analysis.info/int/PEFT_(Parameter-Efficient_Fine-Tuning)_(HI)#cite_note-dora_paper-9) | | LLaMA-7B | DoRA (LoRA का एक रूपांतर) | 0.84% | 78.1% | [\[9\]](https://systems-analysis.info/int/PEFT_(Parameter-Efficient_Fine-Tuning)_(HI)#cite_note-dora_paper-9) | PEFT-विधियों का तुलनात्मक प्रदर्शन और दक्षता संसाधन बचत में PEFT के प्रमुख लाभ: - **GPU मेमोरी (VRAM):** LLaMA 65B मॉडल के लिए पूर्ण fine-tuning को सैद्धांतिक रूप से \>780 GB VRAM की आवश्यकता होती है, जबकि **QLoRA** इसे \<48 GB VRAM वाले GPU पर fine-tune करना संभव बनाता है[\[8\]](https://systems-analysis.info/int/PEFT_(Parameter-Efficient_Fine-Tuning)_(HI)#cite_note-dettmers2023qlora-8)। - **भंडारण का आकार:** PEFT के बाद सहेजे गए checkpoint गीगाबाइट नहीं, बल्कि मेगाबाइट में होते हैं। इससे विभिन्न कार्यों के लिए सैकड़ों «adapter» उतनी जगह में संग्रहीत किए जा सकते हैं, जितनी एक पूरी तरह fine-tuned मॉडल ले लेती। ## अनुप्रयोग के क्षेत्र मूलतः NLP के लिए विकसित, PEFT विधियाँ कार्यों की एक विस्तृत श्रृंखला के लिए सफलतापूर्वक अनुकूलित की गई हैं: - **कम्प्यूटर विज़न (CV) और मल्टीमोडल मॉडल (VLM):** Vision Transformer (ViT) और Segment Anything Model (SAM) जैसे मॉडलों को छवि विभाजन कार्यों के लिए अनुकूलित करना, जिसमें बायोमेडिकल क्षेत्र भी शामिल है। - **कोड निर्माण और विश्लेषण:** विशिष्ट सॉफ़्टवेयर परियोजनाओं, आंतरिक API या कोड बेस की विशिष्टताओं के अनुसार LLM को कॉन्फ़िगर करना। - **जनरेटिव मॉडल:** Stable Diffusion जैसे छवि निर्माण मॉडलों को LoRA-adapter (Dreambooth तकनीक) की सहायता से «शैली देना»। - **वाक् संश्लेषण:** विशिष्ट आवाज़, स्वर या भावनात्मक रंग के साथ वाक् उत्पन्न करने के लिए मॉडलों को अनुकूलित करना। ## सन्दर्भ - GitHub पर PEFT लाइब्रेरी का रिपॉज़िटरी - Hugging Face द्वारा PEFT लाइब्रेरी का आधिकारिक दस्तावेज़ीकरण ## साहित्य - Hu, E.J. et al. (2021). *LoRA: Low-Rank Adaptation of Large Language Models*. arXiv:2106.09685. - Dettmers, T. et al. (2023). *QLoRA: Efficient Finetuning of Quantized LLMs*. arXiv:2305.14314. - Houlsby, N. et al. (2019). *Parameter-Efficient Transfer Learning for NLP*. ICML 2019. - Li, X.L.; Liang, P. (2021). *Prefix-Tuning: Optimizing Continuous Prompts for Generation*. arXiv:2101.00190. - Liu, X. et al. (2022). *P-Tuning v2: Prompt Tuning Can Be Comparable to Fine-tuning Universally Across Scales and Tasks*. arXiv:2110.07602. - Ben Zaken, E.; Ravfogel, S.; Goldberg, Y. (2021). *BitFit: Simple Parameter-Efficient Fine-Tuning for Transformer-Based Masked Language Models*. arXiv:2106.10199. - Guo, D.; Rush, A.M.; Kim, Y. (2020). *Parameter-Efficient Transfer Learning with Diff Pruning*. arXiv:2012.07463. - Jiang, Z. et al. (2024). *MoRA: High-Rank Updating for Parameter-Efficient Fine-Tuning*. arXiv:2405.12130. - Mao, K. et al. (2024). *A Survey on LoRA of Large Language Models*. arXiv:2407.11046. - Chen, S. et al. (2024). *Parameter-Efficient Fine Tuning: A Comprehensive Analysis Across Applications*. arXiv:2404.13506. - Zhang, J. et al. (2025). *Parameter-Efficient Fine-Tuning for Foundation Models*. arXiv:2501.13787. ## टिप्पणियाँ 1. [↑](https://systems-analysis.info/int/PEFT_(Parameter-Efficient_Fine-Tuning)_(HI)#cite_ref-survey_arxiv_2025_1-0) «Parameter-Efficient Fine-Tuning for Foundation Models». *arXiv:2501.13787*. [१] 2. ↑ [2.0](https://systems-analysis.info/int/PEFT_(Parameter-Efficient_Fine-Tuning)_(HI)#cite_ref-mlm_problems_2025_2-0) [2.1](https://systems-analysis.info/int/PEFT_(Parameter-Efficient_Fine-Tuning)_(HI)#cite_ref-mlm_problems_2025_2-1) «5 Problems Encountered Fine-Tuning LLMs with Solutions». *Machine Learning Mastery*. [२] 3. ↑ [3.0](https://systems-analysis.info/int/PEFT_(Parameter-Efficient_Fine-Tuning)_(HI)#cite_ref-huggingface_peft_methods_3-0) [3.1](https://systems-analysis.info/int/PEFT_(Parameter-Efficient_Fine-Tuning)_(HI)#cite_ref-huggingface_peft_methods_3-1) «PEFT: Parameter-Efficient Fine-Tuning Methods for LLMs». *Hugging Face Blog*. [३] 4. ↑ [4.0](https://systems-analysis.info/int/PEFT_(Parameter-Efficient_Fine-Tuning)_(HI)#cite_ref-houlsby2019_4-0) [4.1](https://systems-analysis.info/int/PEFT_(Parameter-Efficient_Fine-Tuning)_(HI)#cite_ref-houlsby2019_4-1) [4.2](https://systems-analysis.info/int/PEFT_(Parameter-Efficient_Fine-Tuning)_(HI)#cite_ref-houlsby2019_4-2) Houlsby, N., et al. «Parameter-Efficient Transfer Learning for NLP». *Proceedings of the 36th International Conference on Machine Learning*. [४] 5. [↑](https://systems-analysis.info/int/PEFT_(Parameter-Efficient_Fine-Tuning)_(HI)#cite_ref-li2021prefix_5-0) Li, X.L., Liang, P. «Prefix-Tuning: Optimizing Continuous Prompts for Generation». *arXiv:2101.00190*. [५] 6. [↑](https://systems-analysis.info/int/PEFT_(Parameter-Efficient_Fine-Tuning)_(HI)#cite_ref-liu2021ptuningv2_6-0) Liu, X., et al. «P-Tuning v2: Prompt Tuning Can Be Comparable to Fine-tuning Universally Across Scales and Tasks». *arXiv:2110.07602*. [६] 7. [↑](https://systems-analysis.info/int/PEFT_(Parameter-Efficient_Fine-Tuning)_(HI)#cite_ref-hu2021lora_7-0) Hu, E.J., et al. «LoRA: Low-Rank Adaptation of Large Language Models». *arXiv:2106.09685*. [७] 8. ↑ [8.0](https://systems-analysis.info/int/PEFT_(Parameter-Efficient_Fine-Tuning)_(HI)#cite_ref-dettmers2023qlora_8-0) [8.1](https://systems-analysis.info/int/PEFT_(Parameter-Efficient_Fine-Tuning)_(HI)#cite_ref-dettmers2023qlora_8-1) Dettmers, T., et al. «QLoRA: Efficient Finetuning of Quantized LLMs». *arXiv:2305.14314*. [८] 9. ↑ [9.0](https://systems-analysis.info/int/PEFT_(Parameter-Efficient_Fine-Tuning)_(HI)#cite_ref-dora_paper_9-0) [9.1](https://systems-analysis.info/int/PEFT_(Parameter-Efficient_Fine-Tuning)_(HI)#cite_ref-dora_paper_9-1) «Parameter Efficient Fine Tuning: A Comprehensive Analysis Across Applications». *arXiv:2404.13506*. [९]