नमस्ते!

चूंकि आप यहां हैं, इसलिए आप शायद ओपन-सोर्स AI मॉडल को फ़ाइन-ट्यून कैसे करें (जैसे LLaMA, Mistral, GPT‑J, आदि) अपने स्वयं के डेटा या एप्लिकेशन के लिए इसमें रुचि रखते हैं। नीचे एक स्पष्ट, चरण-दर-चरण अवलोकन दिया गया है जिसका आप पालन कर सकते हैं, साथ ही लिंक और उपकरण जो आमतौर पर वास्तविक दुनिया की परियोजनाओं में उपयोग किए जाते हैं।

1. “ओपन-सोर्स AI मॉडल को फ़ाइन-ट्यून करने” का क्या मतलब है?

फ़ाइन‑ट्यूनिंग का मतलब है:

  • आप एक पूर्व-प्रशिक्षित मॉडल से शुरुआत करते हैं (जैसे: एक बड़ा भाषा मॉडल)।
  • आप इसे अपने स्वयं के डेटासेट पर थोड़ा और प्रशिक्षित करते हैं।
  • परिणाम एक मॉडल है जो:
    • उन सभी सामान्य चीजों को जानता है जो बेस मॉडल जानता था, प्लस
    • आपके विशिष्ट डोमेन (कोड, PDF, चैट शैली, उत्पाद दस्तावेज़ीकरण, आदि) में बेहतर प्रदर्शन करता है।

यह RAG (पुनर्प्राप्ति संवर्धित पीढ़ी) से अलग है, जहाँ आप मॉडल के भार को नहीं बदलते हैं; आप केवल एक वेक्टर डेटाबेस से एक प्रासंगिक संदर्भ फ़ीड करते हैं। कई व्यावसायिक उपयोग के मामलों के लिए, RAG पर्याप्त है; फ़ाइन-ट्यूनिंग तब उपयोगी हो जाती है जब:

  • आप लगातार कस्टम टोन या शैली चाहते हैं।
  • आप चाहते हैं कि मॉडल मज़बूती से जटिल निर्देशों का पालन करे।
  • आपको इसकी बहुत अच्छी तरह से विशेष तकनीकी या व्यावसायिक भाषा बोलने की आवश्यकता है।
  • आप दोहराए जाने वाले पैटर्न के लिए प्रॉम्प्ट लंबाई और लागत को कम करना चाहते हैं।

2. सही ओपन-सोर्स मॉडल चुनें

मॉडल खोजने के लिए लोकप्रिय स्थान:

कैसे चुनें:

  • कार्य का प्रकार

    • चैट / सामान्य सहायक – निर्देश के लिए फ़ाइन-ट्यून LLM चुनें (जैसे: *-instruct)।
    • कोड – CodeLlama जैसे कोड में विशेषज्ञता वाले मॉडल।
    • वर्गीकरण / एम्बेडिंग – छोटे ट्रांसफार्मर एनकोडर (जैसे: sentence-transformers)।

  • आकार बनाम हार्डवेयर

    • 7B–8B मॉडल: सिंगल 24 GB GPU (जैसे RTX 4090 या A5000) के लिए अच्छे हैं।
    • 13B–34B+ मॉडल: को मल्टीपल GPU या 4-बिट क्वांटिज़ेशन की आवश्यकता हो सकती है।

3. फ़ाइन-ट्यूनिंग के लिए अपना डेटासेट तैयार करना

आपके डेटासेट को यह प्रतिबिंबित करना चाहिए कि आप मॉडल को कैसा व्यवहार करते हुए देखना चाहते हैं।

3.1 चैट मॉडल के लिए विशिष्ट प्रारूप

एक सामान्य JSONL प्रारूप (प्रति पंक्ति एक JSON ऑब्जेक्ट):

{"instruction": "फ़ाइन-ट्यूनिंग क्या है, समझाएं।", "input": "", "output": "फ़ाइन-ट्यूनिंग है..."}
{"instruction": "इस टेक्स्ट का फ्रेंच में अनुवाद करें।", "input": "सुप्रभात", "output": "बोनजोर"}

या एक संवादात्मक प्रारूप (OpenAI शैली):

{
  "messages": [
    {"role": "system", "content": "आप एक सहायक कोडिंग सहायक हैं।"},
    {"role": "user", "content": "दो नंबर जोड़ने के लिए एक पायथन फ़ंक्शन लिखें।"},
    {"role": "assistant", "content": "def add(a, b):
    return a + b"}
  ]
}

SEO और खोज के लिए: बहुत से लोग "फ़ाइन-ट्यूनिंग LLaMA JSONL प्रारूप" या "निर्देश फ़ाइन ट्यूनिंग डेटासेट उदाहरण" खोजते हैं – ऊपर दिए गए दो स्वरूपों में से किसी एक का उपयोग आम तौर पर आधुनिक फ़ाइन‑ट्यूनिंग स्क्रिप्ट के साथ काम करता है।

3.2 डेटा गुणवत्ता युक्तियाँ

  • स्थिरता: हर जगह एक ही संरचना का उपयोग करें (समान कुंजी, कार्य, स्वरूपण)।
  • साफ़ प्रतिक्रियाएँ: मतिभ्रम और गलत सामग्री से बचें।
  • विविधता: आसान/मध्यम/कठिन उदाहरणों और विविध वाक्यांशों को मिलाएं।
  • पर्याप्त डेटा:
    • छोटे व्यवहार समायोजन: 1k–5k उच्च गुणवत्ता वाले उदाहरण काम कर सकते हैं।
    • बड़ा डोमेन अनुकूलन: 10k–100k+ उदाहरण बेहतर हैं।

4. हार्डवेयर और पर्यावरण आवश्यकताएँ

4.1 हार्डवेयर

  • 7B–8B मॉडल (QLoRA / LoRA) के लिए:
    • 1 × 16–24 GB GPU आमतौर पर पर्याप्त होता है।
  • 13B+ मॉडल के लिए:
    • मल्टीपल GPU या अधिक आक्रामक क्वांटिज़ेशन।
  • केवल CPU: संभव है, लेकिन बहुत धीमा; अनुशंसित नहीं है जब तक कि मॉडल छोटा न हो।

4.2 सॉफ्टवेयर

आम स्टैक:

बेसिक्स इंस्टॉल करें:

pip install "transformers[torch]" datasets accelerate peft bitsandbytes

5. फ़ाइन-ट्यूनिंग विधियाँ: पूर्ण फ़ाइन-ट्यून बनाम LoRA / QLoRA

5.1 पूर्ण फ़ाइन-ट्यूनिंग

  • आप मॉडल के सभी वेट को अपडेट करते हैं।
  • लाभ: अधिकतम क्षमता और लचीलापन।
  • नुकसान: बहुत अधिक GPU मेमोरी और समय की आवश्यकता होती है।

अधिकांश टीमों के लिए, 7B+ मॉडल का पूर्ण फ़ाइन‑ट्यूनिंग अतिशयोक्तिपूर्ण है।

5.2 LoRA / QLoRA (अधिकांश मामलों के लिए अनुशंसित)

  • केवल एक जमे हुए बेस मॉडल के शीर्ष पर छोटे एडेप्टर लेयर्स को प्रशिक्षित करें।
  • QLoRA = LoRA + क्वांटाइज़्ड बेस मॉडल (जैसे: 4 बिट)।
  • बहुत सस्ता और इसके लिए बहुत अच्छा काम करता है:
    • शैली / व्यवहार में बदलाव
    • डोमेन ज्ञान
    • निर्देशों का पालन करना

संसाधन:

अधिकांश "एकल GPU पर ओपन-सोर्स LLM को फ़ाइन-ट्यून कैसे करें" ट्यूटोरियल जो आप ऑनलाइन देखते हैं, QLoRA का उपयोग करते हैं।

6. चरण दर चरण: LoRA के साथ ओपन-सोर्स मॉडल को फ़ाइन-ट्यून करें

नीचे हगिंग फ़ेस के transformers और peft का उपयोग करके एक छोटा उदाहरण दिया गया है। यह एक उत्पादन कोड नहीं है, लेकिन यह आपको सटीक टुकड़े देता है जिनकी आपको आवश्यकता है।

6.1 एक बेस मॉडल लोड करें

from transformers import AutoModelForCausalLM, AutoTokenizer

model_name = "mistralai/Mistral-7B-Instruct-v0.2"  # उदाहरण

tokenizer = AutoTokenizer.from_pretrained(model_name)
model = AutoModelForCausalLM.from_pretrained(
    model_name,
    load_in_4bit=True,            # QLoRA शैली लोडिंग
    device_map="auto"
)

6.2 अपना डेटासेट तैयार करें

from datasets import load_dataset

# यह मानते हुए कि आपका डेटासेट {"instruction", "input", "output"} के साथ एक JSONL फ़ाइल है
dataset = load_dataset("json", data_files={"train": "train.jsonl", "validation": "val.jsonl"})

def format_example(example):
    if example["input"]:
        prompt = f"Instruction: {example['instruction']}
Input: {example['input']}
Answer:"
    else:
        prompt = f"Instruction: {example['instruction']}
Answer:"
    return {
        "prompt": prompt,
        "label": example["output"]
    }

dataset = dataset.map(format_example)

def tokenize(batch):
    inputs = tokenizer(batch["prompt"], truncation=True, padding="max_length", max_length=1024)
    labels = tokenizer(batch["label"], truncation=True, padding="max_length", max_length=1024)
    inputs["labels"] = labels["input_ids"]
    return inputs

tokenized = dataset.map(tokenize, batched=True, remove_columns=dataset["train"].column_names)

6.3 LoRA एडेप्टर संलग्न करें

from peft import LoraConfig, get_peft_model, TaskType

lora_config = LoraConfig(
    r=16,
    lora_alpha=32,
    target_modules=["q_proj", "v_proj"],  # मॉडल के अनुसार भिन्न हो सकता है
    lora_dropout=0.05,
    bias="none",
    task_type=TaskType.CAUSAL_LM,
)

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

6.4 प्रशिक्षित करना

from transformers import TrainingArguments, Trainer

training_args = TrainingArguments(
    output_dir="./mistral-finetuned",
    per_device_train_batch_size=2,
    per_device_eval_batch_size=2,
    gradient_accumulation_steps=8,
    num_train_epochs=3,
    learning_rate=2e-4,
    fp16=True,
    logging_steps=50,
    save_steps=500,
    evaluation_strategy="steps",
    eval_steps=500,
    save_total_limit=3,
    report_to="none"
)

trainer = Trainer(
    model=model,
    args=training_args,
    train_dataset=tokenized["train"],
    eval_dataset=tokenized["validation"]
)

trainer.train()
model.save_pretrained("./mistral-finetuned-lora")
tokenizer.save_pretrained("./mistral-finetuned-lora")

अब आपके पास आपके डेटासेट पर फ़ाइन‑ट्यूनिंग के साथ एक LoRA-अनुकूलित ओपन-सोर्स मॉडल है।

7. अपने फ़ाइन-ट्यून मॉडल का उत्पादन में उपयोग करना

7.1 LoRA वेट को मर्ज करें (वैकल्पिक)

तैनाती को आसान बनाने के लिए, आप LoRA एडेप्टर को बेस मॉडल में मर्ज कर सकते हैं:

from peft import PeftModel

base_model = AutoModelForCausalLM.from_pretrained(model_name, device_map="auto")
lora_model = PeftModel.from_pretrained(base_model, "./mistral-finetuned-lora")
merged = lora_model.merge_and_unload()
merged.save_pretrained("./mistral-finetuned-merged")
tokenizer.save_pretrained("./mistral-finetuned-merged")

फिर आप कर सकते हैं:

7.2 एक Laravel एप्लिकेशन के साथ एकीकरण

आम पैटर्न:

  1. मॉडल को एक HTTP API (पायथन माइक्रोसर्विस) के रूप में परोसा जाता है

    • एक /generate एंडपॉइंट को उजागर करें जो आपके फ़ाइन‑ट्यून मॉडल को कॉल करता है।
    • गुज़ल या Http क्लाइंट का उपयोग करके इसे Laravel से कॉल करें।

  2. एक अनुमान प्रदाता का उपयोग करें जो कस्टम मॉडल का समर्थन करता है

    • उदाहरण के लिए: हगिंग फ़ेस अनुमान एंडपॉइंट या अन्य क्लाउड प्रदाता।
    • अपने मॉडल को निजी तौर पर संग्रहीत करें और अपने Laravel बैकएंड से REST के माध्यम से कॉल करें।

एक विशिष्ट Laravel सेटअप के लिए, लोग "Laravel में ठीक से ट्यून किए गए LLaMA मॉडल का उपयोग करें" या "Laravel को स्थानीय LLM से कनेक्ट करें" की खोज करते हैं; कुंजी मॉडल को एक अलग सेवा के रूप में मानना ​​है और HTTP द्वारा इसके साथ संवाद करना है।

8. आपको कब फ़ाइन-ट्यूनिंग की आवश्यकता नहीं हो सकती है

कई वास्तविक दुनिया के अनुप्रयोगों में, आप निम्न को मिलाकर उत्कृष्ट परिणाम प्राप्त कर सकते हैं:

  1. एक मजबूत ओपन-सोर्स मॉडल (जैसे: Llama 3 निर्देश या मिस्ट्रल निर्देश)।
  2. प्रॉम्प्ट इंजीनियरिंग (स्पष्ट निर्देश, सुसंगत सिस्टम संदेश)।
  3. एक वेक्टर डेटाबेस के साथ RAG:

फ़ाइन‑ट्यूनिंग विशेष रूप से तब सार्थक है जब:

  • आप बार-बार समान प्रश्न पूछते हैं और संक्षिप्त संकेतों की आवश्यकता होती है।
  • आप एक ब्रांड की आवाज वाला सहायक और ब्रांड के लिए सुरक्षित चाहते हैं।
  • आपको किसी विशिष्ट डोमेन में उच्च गुणवत्ता के साथ छोटे हार्डवेयर पर चलने की आवश्यकता है।

9. कानूनी और लाइसेंसिंग विचार

किसी भी ओपन-सोर्स मॉडल को ठीक से ट्यून करने से पहले:

  • इसके हगिंग फ़ेस पेज पर लाइसेंस की जाँच करें।
    • कुछ स्वतंत्र रूप से व्यावसायिक उपयोग की अनुमति देते हैं।
    • अन्य में प्रतिबंध हैं (जैसे: Llama 2 / 3 लाइसेंस, मॉडल केवल अनुसंधान के लिए, आदि)।
  • आपके द्वारा उपयोग किए जाने वाले प्रशिक्षण डेटा के लाइसेंस की जाँच करें (उचित सहमति और सुरक्षा के बिना कोई निजी/गोपनीय डेटा नहीं)।

उपयोगी पठन:

10. सारांश: ओपन-सोर्स AI मॉडल को कैसे फ़ाइन-ट्यून करें

  1. हगिंग फ़ेस से एक मॉडल चुनें जो आपके कार्य और हार्डवेयर के अनुकूल हो।
  2. एक स्थिर JSON/JSONL चैट या निर्देश प्रारूप में उच्च गुणवत्ता वाला प्रशिक्षण डेटा तैयार करें।
  3. PyTorch, transformers, datasets, peft और (वैकल्पिक रूप से) bitsandbytes के साथ पर्यावरण को कॉन्फ़िगर करें।
  4. उचित लागत पर एक एकल GPU पर फ़ाइन‑ट्यूनिंग के लिए LoRA/QLoRA का उपयोग करें।
  5. बनाए रखे गए डेटा पर मूल्यांकन करें और प्रॉम्प्ट और प्रशिक्षण सेट को परिष्कृत करें।
  6. एक सेवा के रूप में तैनात करें (उदाहरण के लिए: vLLM, TGI या llama.cpp के माध्यम से) और इसे अपने Laravel या अन्य बैकएंड से कॉल करें।

अगर आप मुझे बताते हैं:

  • आप किस प्रकार का एप्लिकेशन बना रहे हैं (चैटबॉट, कोड सहायक, सामग्री जनरेटर, आदि),
  • आपके पास कौन सा हार्डवेयर है,
  • यदि आप ऑन‑प्रेम या क्लाउड में तैनात करना चाहते हैं,

तो मैं आपके सटीक उपयोग के मामले के अनुरूप एक ठोस, न्यूनतम कॉन्फ़िगरेशन को रेखांकित कर सकता हूं।