स्थानीय स्तर पर एलएलएम को कैसे फाइन-ट्यून करें

जीपीयू के रैक की आवश्यकता के लिए स्थानीय रूप से उपयोग किए जाने वाले एक बड़े भाषा मॉडल को फाइन-ट्यून करना। 2026 में, परिमाणीकरण और लोआरए जैसे पैरामीटर-कुशल तरीकों के लिए धन्यवाद, आप 12-24 जीबी वीआरएएम के साथ एकल उपभोक्ता जीपीयू पर 7-8बी पैरामीटर मॉडल को ठीक कर सकते हैं – या एकीकृत मेमोरी के साथ ऐप्पल सिलिकॉन पर भी। यह मार्गदर्शिका पूरी पाइपलाइन से गुजरती है: डेटा तैयार करना, लोरा फाइन-ट्यूनिंग चलाना, और परिणाम को एक मॉडल में विलय करना जिसे आप वास्तव में चला सकते हैं।

सामग्री तालिका

• संकेत देने के बजाय फ़ाइन-ट्यून क्यों
• हार्डवेयर और सॉफ्टवेयर आवश्यकताएँ
• एक प्रशिक्षण डेटासेट तैयार करना
• लोरा के साथ फाइन-ट्यूनिंग
• प्रशिक्षण लूप चलाना
• मॉडल का विलय और निर्यात
• अपने फाइन-ट्यून्ड मॉडल को स्थानीय स्तर पर चलाना
• सामान्य ख़तरे
• अक्सर पूछे जाने वाले प्रश्न

संकेत देने के बजाय फ़ाइन-ट्यून क्यों

प्रॉम्प्ट इंजीनियरिंग और आरएजी अधिकांश समस्याओं का समाधान करते हैं – पहले उन्हें आज़माएँ। फाइन-ट्यूनिंग विशेष रूप से अतिरिक्त प्रयास के लायक है जब आपको मॉडल को लगातार एक संकीर्ण आउटपुट प्रारूप का पालन करने, हजारों पीढ़ियों में एक विशिष्ट टोन अपनाने, या अच्छे संकेतों और उदाहरणों के साथ भी बेस मॉडल असंगत रूप से संभालने वाले कार्य को करने की आवश्यकता होती है। यह हर संकेत में व्यवहार को दोबारा समझाने के बजाय उसे वज़न में बदल देता है।

हार्डवेयर और सॉफ्टवेयर आवश्यकताएँ

4-बिट परिमाणीकरण और लोआरए के साथ 7-8बी पैरामीटर बेस मॉडल के लिए, एकल जीपीयू पर 12-16 जीबी वीआरएएम यथार्थवादी है। बड़े 13-14B मॉडल आपको 24GB कार्ड की ओर धकेलते हैं। कोर स्टैक स्थापित करें:

pip install torch transformers peft bitsandbytes accelerate datasets trl

peft(पैरामीटर-कुशल फाइन-ट्यूनिंग) LoRA लागू करता है।bitsandbytes4-बिट परिमाणीकरण को संभालता है ताकि बेस मॉडल मेमोरी में फिट हो जाए।trlविशेष रूप से भाषा मॉडल फाइन-ट्यूनिंग के लिए निर्मित एक प्रशिक्षण लूप प्रदान करता है।

एक प्रशिक्षण डेटासेट तैयार करना

संकीर्ण कार्यों के लिए वॉल्यूम से अधिक प्रारूप मायने रखता है – 200-500 उच्च-गुणवत्ता वाले उदाहरण अक्सर 5,000 शोर वाले उदाहरणों से बेहतर प्रदर्शन करते हैं। JSONL:

{"instruction": "Summarize this support ticket in one sentence.", "input": "Customer reports login failures since the 2.3 update...", "output": "User cannot log in after updating to version 2.3."}
{"instruction": "Summarize this support ticket in one sentence.", "input": "Payment declined for annual plan renewal...", "output": "Annual plan renewal payment was declined."}

इसेdatasetsसे लोड करें पुस्तकालय:

from datasets import load_dataset

dataset = load_dataset("json", data_files="train.jsonl", split="train")

def format_example(example):
    return {
        "text": f"### Instruction:\n{example['instruction']}\n\n### Input:\n{example['input']}\n\n### Response:\n{example['output']}"
    }

dataset = dataset.map(format_example)

लोरा के साथ फाइन-ट्यूनिंग

LoRA बेस मॉडल के वज़न को फ़्रीज़ कर देता है और इसके बजाय ध्यान परतों में इंजेक्ट किए गए छोटे निम्न-रैंक एडाप्टर मैट्रिसेस को प्रशिक्षित करता है। यह प्रशिक्षण योग्य मापदंडों को अरबों से घटाकर लाखों कर देता है, यही कारण है कि यह उपभोक्ता हार्डवेयर पर फिट बैठता है:

from transformers import AutoModelForCausalLM, AutoTokenizer, BitsAndBytesConfig
from peft import LoraConfig, get_peft_model
import torch

model_name = "meta-llama/Meta-Llama-3-8B"

bnb_config = BitsAndBytesConfig(
    load_in_4bit=True,
    bnb_4bit_quant_type="nf4",
    bnb_4bit_compute_dtype=torch.bfloat16,
)

tokenizer = AutoTokenizer.from_pretrained(model_name)
model = AutoModelForCausalLM.from_pretrained(model_name, quantization_config=bnb_config, device_map="auto")

lora_config = LoraConfig(
    r=16,
    lora_alpha=32,
    target_modules=["q_proj", "k_proj", "v_proj", "o_proj"],
    lora_dropout=0.05,
    bias="none",
    task_type="CAUSAL_LM",
)

model = get_peft_model(model, lora_config)
model.print_trainable_parameters()

वह अंतिम पंक्ति आम तौर पर “प्रशिक्षण योग्य पैरामीटर: कुल का 0.06%” जैसा कुछ प्रिंट करती है – यह एक ठोस अनुस्मारक है कि यह एक एकल जीपीयू पर क्यों फिट बैठता है जहां पूर्ण फाइन-ट्यूनिंग नहीं होगी।

प्रशिक्षण लूप चलाना

trl‘sSFTTrainerगले मिलते चेहरे को लपेटता हैTrainerअनुदेश ट्यूनिंग के लिए समझदार डिफ़ॉल्ट के साथ:

from trl import SFTTrainer, SFTConfig

training_args = SFTConfig(
    output_dir="./lora-output",
    per_device_train_batch_size=2,
    gradient_accumulation_steps=4,
    num_train_epochs=3,
    learning_rate=2e-4,
    logging_steps=10,
    save_strategy="epoch",
    bf16=True,
)

trainer = SFTTrainer(
    model=model,
    train_dataset=dataset,
    args=training_args,
    dataset_text_field="text",
)

trainer.train()

ग्रेडिएंट संचय आपको वजन अपडेट करने से पहले कई छोटे बैचों में ग्रेडिएंट जमा करके आपके वीआरएएम की तुलना में बड़े बैच आकार का अनुकरण करने की अनुमति देता है – सेटper_device_train_batch_sizeजितनी अधिक मेमोरी अनुमति दे, तब बढ़ाएँgradient_accumulation_steps8-16 के प्रभावी बैच आकार तक पहुंचने के लिए।

मॉडल का विलय और निर्यात

प्रशिक्षण के बाद, LoRA एडाप्टर वज़न को एक स्टैंडअलोन चेकपॉइंट के लिए बेस मॉडल में वापस मर्ज करें जिसे आप वितरित या परिवर्तित कर सकते हैं:

from peft import PeftModel

base_model = AutoModelForCausalLM.from_pretrained(model_name, torch_dtype=torch.bfloat16, device_map="auto")
merged_model = PeftModel.from_pretrained(base_model, "./lora-output/checkpoint-final")
merged_model = merged_model.merge_and_unload()

merged_model.save_pretrained("./merged-model")
tokenizer.save_pretrained("./merged-model")

अपने फाइन-ट्यून्ड मॉडल को स्थानीय स्तर पर चलाना

|||| के साथ तेजी से स्थानीय अनुमान के लिए मर्ज किए गए मॉडल को जीजीयूएफ प्रारूप में परिवर्तित करें या ओलामा:llama.cpp📋कॉपी

python convert_hf_to_gguf.py ./merged-model --outfile my-model.gguf --outtype q4_k_m

ollama create my-model -f Modelfile
ollama run my-model

सामान्य ख़तरेq4_k_mछोटे डेटासेट पर ओवरफिटिंग सबसे आम विफलता है – यदि आपका नुकसान एक युग के भीतर शून्य के करीब चला जाता है, तो आप सामान्यीकरण के बजाय याद रखने की संभावना रखते हैं, और सत्यापन हानि को प्रशिक्षण हानि से अलग से देखा जाना चाहिए। सीखने की दर दूसरा सबसे आम मुद्दा है: 2e-4 अधिकांश 7-8B LoRA सेटअप के लिए काम करता है, लेकिन छोटे डेटासेट पर उच्चतर जाने से प्रशिक्षण तेजी से अस्थिर हो जाता है।

त्वरित फ़ॉर्मेटिंग स्थिरता भी देखें। यदि आपका प्रशिक्षण डेटा एक विशिष्ट निर्देश टेम्पलेट का उपयोग करता है, तो आपके अनुमान कॉल को बिल्कुल उसी टेम्पलेट का उपयोग करना चाहिए – अनुमान के समय एक बेमेल प्रारूप चुपचाप बिना किसी त्रुटि के आउटपुट गुणवत्ता को कम कर देता है।

एक बार फाइन-ट्यून किए जाने पर मॉडलों को कुशलतापूर्वक चलाने के बारे में अधिक जानकारी के लिए, हमारा

होम लैब और डेवऑप्स गाइड

स्व-होस्टिंग बुनियादी ढांचे को शामिल करता है, और यदि आप अपने मॉडल के आसपास एक एपीआई बना रहे हैं, तो हमारादेखें फास्टएपीआई रेस्ट ट्यूटोरियल.अक्सर पूछे जाने वाले प्रश्नमुझे वास्तव में कितने डेटा की आवश्यकता है?

संकीर्ण, अच्छी तरह से परिभाषित कार्यों के लिए, 200-500 उच्च-गुणवत्ता वाले उदाहरण अक्सर पर्याप्त होते हैं। हजारों विविध उदाहरणों से व्यापक व्यवहार परिवर्तन (स्वर, बहु-कार्य निर्देश का पालन) लाभ होता है।

क्या मैं मैकबुक को फाइन-ट्यून कर सकता हूँ?
For narrow, well-defined tasks, 200-500 high-quality examples is often enough. Broader behavior changes (tone, multi-task instruction following) benefit from thousands of diverse examples.

Can I fine-tune on a MacBook?
हाँ, Apple सिलिकॉन पर MLX या llama.cpp के प्रशिक्षण समर्थन का उपयोग कर रहा हूँ। एकीकृत मेमोरी का मतलब है कि 32-64GB मैकबुक 7-8B LoRA फाइन-ट्यूनिंग को संभाल सकता है, हालांकि समर्पित NVIDIA GPU की तुलना में धीमा है।

लोरा और क्यूलोरा में क्या अंतर है?
QLoRA, LoRA के शीर्ष पर जमे हुए बेस मॉडल का 4-बिट परिमाणीकरण जोड़ता है, न्यूनतम गुणवत्ता हानि के साथ मेमोरी आवश्यकताओं को और कम करता है – यह 8B मॉडल को 12-16GB GPU पर प्रशिक्षित करने योग्य बनाता है।

क्या मुझे फाइन-ट्यून करने की आवश्यकता है, या आरएजी काम करेगा?
यदि समस्या यह है कि “मॉडल को यह जानकारी नहीं पता है,” RAG का उपयोग करें। यदि समस्या यह है कि “मॉडल जानकारी जानता है, लेकिन मेरी ज़रूरत के अनुसार प्रारूपित या व्यवहार नहीं करेगा,” फ़ाइन-ट्यूनिंग बेहतर उपकरण है।

लोरा को ठीक करने में कितना समय लगता है?
एकल उपभोक्ता जीपीयू पर 500 उदाहरणों और 3 युगों के लिए, अनुक्रम लंबाई और जीपीयू वर्ग के आधार पर 20 मिनट से लेकर कुछ घंटों तक की अपेक्षा करें।

फाइन-ट्यून के लिए तैयार हैं?

विस्तार करने से पहले किसी एक संकीर्ण कार्य के लिए 200-300 उदाहरणों के एक छोटे, साफ़ डेटासेट से शुरुआत करें। उपरोक्त पाइपलाइन – लोरा एडॉप्टर, एसएफटीट्रेनर, मर्ज, जीजीयूएफ एक्सपोर्ट – वही आकार है जिसका उपयोग फाइन-ट्यून्स के उत्पादन के लिए किया जाता है, बस उस पैमाने पर जो आपके पास पहले से मौजूद हार्डवेयर पर फिट बैठता है।