ओपन-सोर्स एआई मॉडल को फाइन-ट्यून करने के लिए शुरुआती गाइड

नमस्ते!

चूंकि आप यहां हैं, इसलिए आप संभवतः अपने स्वयं के उपयोग (चैटबॉट, कोडिंग सहायक, डोमेन विशेषज्ञ, आदि) के लिए एक ओपन-सोर्स एआई मॉडल को फाइन-ट्यून करने में रुचि रखते हैं। नीचे एक स्पष्ट, शुरुआती-अनुकूल अवलोकन दिया गया है जिसका आप सीधे लारवेल या सामान्य वेब-देव संदर्भ में उपयोग कर सकते हैं।

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

फाइन-ट्यूनिंग एक मौजूदा पूर्व-प्रशिक्षित मॉडल (जैसे LLaMA-2, मिस्ट्रल, या हगिंग फेस पर मॉडल) लेना और इसे अपने स्वयं के डेटा पर थोड़ा और प्रशिक्षित करना है ताकि यह:

• आपके डोमेन (कानून, वित्त, चिकित्सा, गेमिंग, आदि) के अनुकूल हो
• आपकी टोन और शैली सीखे
• विशिष्ट कार्यों (QA, कोडिंग, वर्गीकरण, समर्थन, आदि) पर सुधार करे

शुरू से प्रशिक्षण (महंगा और धीमा) के बजाय, आप एक मजबूत आधार मॉडल का पुन: उपयोग करते हैं और इसे विशेषज्ञ बनाते हैं।

2. फाइन-ट्यूनिंग के लिए मुख्य विकल्प

यहां तीन मुख्य दृष्टिकोण हैं जो आपको बहुत देखने को मिलेंगे:

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

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

यह आमतौर पर जरूरत से ज्यादा है जब तक कि आप एक शोध प्रयोगशाला या बड़ी कंपनी न हों।

2.2 लोरा / पीईएफटी (पैरामीटर-कुशल फाइन-ट्यूनिंग)

• आप बेस मॉडल को जमा रखते हैं और केवल छोटे एडाप्टर परतों (लोरा मैट्रिक्स) को प्रशिक्षित करते हैं।
• पुस्तकालयों का उपयोग करता है जैसे:
  • पीईएफटी (हगिंग फेस)
  • लोरा पेपर

फायदे:

• बहुत कम VRAM आवश्यकता
• तेज़
• आप पूरे मॉडल के बजाय केवल एडाप्टर साझा कर सकते हैं

नुकसान:

• पूर्ण फाइन-ट्यूनिंग की तुलना में थोड़ा कम अभिव्यंजक, लेकिन आमतौर पर पर्याप्त अच्छा होता है।

2.3 QLoRA (परिमाणित लोरा)

• परिमाणीकरण (जैसे 4-बिट) को लोरा के साथ जोड़ता है:
  • आप बेस मॉडल को कम परिशुद्धता (int4 या int8) में लोड करते हैं।
  • शीर्ष पर लोरा एडाप्टर को प्रशिक्षित करें।

फायदे:

• एक एकल GPU पर बड़े मॉडल को फाइन-ट्यून कर सकते हैं (यहां तक कि 24 GB जैसे उपभोक्ता GPU)।
• LLaMA-शैली मॉडल के लिए बहुत लोकप्रिय।

अधिकांश व्यक्तिगत डेवलपर्स के लिए अनुशंसित।

3. एक ओपन-सोर्स बेस मॉडल चुनना

मॉडल कहां खोजें:

• हगिंग फेस मॉडल हब
• मेटा LLaMA 2 & 3
• मिस्ट्रल मॉडल
• फाल्कन मॉडल
• गेमा

आम विकल्प:

• चैट / सहायक:
  • mistralai/Mistral-7B-Instruct-v0.2
  • meta-llama/Llama-3-8b-instruct (यदि लाइसेंस और पहुंच आपके उपयोग के मामले के अनुकूल हैं)
• कोड:
  • codellama/CodeLlama-7b-Instruct-hf
  • deepseek-ai/deepseek-coder-6.7b-instruct

जांचें:

• लाइसेंस (व्यावसायिक बनाम गैर-व्यावसायिक)
• मॉडल आकार (7B एक अच्छा शुरुआती बिंदु है)
• निर्देश-ट्यून बनाम बेस: चैटबॉट के लिए, एक निर्देश/चैट मॉडल चुनें।

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

आपका डेटा प्रारूप लोगों की तुलना में अधिक मायने रखता है।

4.1 आपको किस डेटा का उपयोग करना चाहिए?

उदाहरण:

• ग्राहक सहायता चैट लॉग
• FAQ दस्तावेज़
• ज्ञान-आधार लेख
• कोड रिपॉजिटरी + स्पष्टीकरण
• डोमेन-विशिष्ट अनुसंधान पत्र

डेटा को साफ करें:

• PII / रहस्यों को हटा दें (API कुंजियाँ, ईमेल, पासवर्ड)।
• समान ग्रंथों को डिडुप्लिकेट करें।
• स्पष्ट स्वरूपण समस्याओं को ठीक करें।

4.2 विशिष्ट निर्देश प्रारूप

चैट मॉडल के लिए, हगिंग फेस पर एक आम प्रारूप है:

{
  "instruction": "सरल शब्दों में बताएं कि फाइन-ट्यूनिंग क्या है।",
  "input": "",
  "output": "फाइन-ट्यूनिंग एक मौजूदा प्रशिक्षित मॉडल लेना और इसे अपने स्वयं के डेटा पर और प्रशिक्षित करना है..."
}

या एक अधिक चैट-जैसा प्रारूप:

{
  "messages": [
    {"role": "system", "content": "आप लेखांकन प्रश्नों के लिए एक सहायक सहायक हैं।"},
    {"role": "user", "content": "मैं इनवॉइस भुगतान कैसे रिकॉर्ड करूं?"},
    {"role": "assistant", "content": "इनवॉइस भुगतान रिकॉर्ड करने के लिए, आपको..."}
  ]
}

इसे .jsonl (प्रति पंक्ति एक JSON ऑब्जेक्ट), .json, या हगिंग फेस पर डेटासेट में स्टोर करें।

5. न्यूनतम उदाहरण: हगिंग फेस + लोरा के साथ फाइन-ट्यूनिंग

आपको आमतौर पर आवश्यकता होगी:

• पायथन 3.10+
• एक GPU (आदर्श रूप से 7B के लिए >= 16 GB VRAM; 24 GB अधिक आरामदायक है)
• पुस्तकालय:
  • transformers
  • datasets
  • peft
  • bitsandbytes
  • accelerate

5.1 निर्भरताएँ स्थापित करें

pip install "transformers>=4.39.0" "datasets" "accelerate" "peft" "bitsandbytes"

5.2 सरल QLoRA स्क्रिप्ट (वैचारिक)

from datasets import load_dataset
from transformers import AutoModelForCausalLM, AutoTokenizer, TrainingArguments, Trainer
from peft import LoraConfig, get_peft_model
import torch

model_name = "mistralai/Mistral-7B-Instruct-v0.2"
dataset_path = "path_or_hf_dataset"  # e.g. "my-username/my-dataset"

tokenizer = AutoTokenizer.from_pretrained(model_name)
tokenizer.pad_token = tokenizer.eos_token

model = AutoModelForCausalLM.from_pretrained(
    model_name,
    load_in_4bit=True,
    device_map="auto"
)

dataset = load_dataset(dataset_path, split="train")

def format_example(example):
    user = example["instruction"]
    answer = example["output"]
    prompt = f"User: {user}
Assistant:"
    return {"input_ids": tokenizer(prompt, truncation=True, padding="max_length", max_length=512)["input_ids"],
            "labels":    tokenizer(answer, truncation=True, padding="max_length", max_length=512)["input_ids"]}

tokenized = dataset.map(format_example, remove_columns=dataset.column_names)

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

model = get_peft_model(model, lora_config)

training_args = TrainingArguments(
    output_dir="./mistral-finetuned",
    per_device_train_batch_size=2,
    gradient_accumulation_steps=8,
    learning_rate=2e-4,
    num_train_epochs=3,
    fp16=True,
    logging_steps=10,
    save_steps=500,
    save_total_limit=2,
)

trainer = Trainer(
    model=model,
    args=training_args,
    train_dataset=tokenized
)

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

यह एक सरलीकृत संदर्भ है; उत्पादन उपयोग के लिए, देखें:

• हगिंग फेस पीईएफटी डॉक्स
• हगिंग फेस QLoRA उदाहरण

6. लारवेल एप्लिकेशन के साथ एक फाइन-ट्यून मॉडल को एकीकृत करना

एक बार आपके पास एक फाइन-ट्यून मॉडल हो जाने के बाद, आपको इसे सर्व करने और इसे लारवेल से कॉल करने की आवश्यकता है।

6.1 मॉडल को सर्व करने के तरीके

1. फास्टएपीआई / फ्लास्क माइक्रोसर्विस (पायथन)
   • transformers या vLLM के साथ अनुमान चलाएँ।
   • एक /generate एंडपॉइंट उजागर करें।
2. टेक्स्ट जेनरेशन इन्फ्रेंस (TGI)
   • हगिंग फेस TGI LLM सर्विंग के लिए अनुकूलित है।
3. ओलामा (कुछ मॉडल के लिए)
   • ओलामा macOS/Linux पर चलता है और एक सरल HTTP API प्रदान करता है।

6.2 बेसिक इन्फ्रेंस एंडपॉइंट (पायथन + फास्टएपीआई उदाहरण)

from fastapi import FastAPI
from pydantic import BaseModel
from transformers import AutoModelForCausalLM, AutoTokenizer
import torch

app = FastAPI()

model_name = "./mistral-finetuned-lora"
tokenizer = AutoTokenizer.from_pretrained(model_name)
model = AutoModelForCausalLM.from_pretrained(
    model_name,
    torch_dtype=torch.float16,
    device_map="auto"
)

class GenerateRequest(BaseModel):
    prompt: str
    max_new_tokens: int = 256
    temperature: float = 0.7

@app.post("/generate")
def generate(req: GenerateRequest):
    inputs = tokenizer(req.prompt, return_tensors="pt").to(model.device)
    output = model.generate(
        **inputs,
        max_new_tokens=req.max_new_tokens,
        temperature=req.temperature,
        do_sample=True,
        pad_token_id=tokenizer.eos_token_id
    )
    text = tokenizer.decode(output[0], skip_special_tokens=True)
    return {"result": text}

इसे GPU वाली मशीन पर चलाएँ।

6.3 लारवेल से मॉडल को कॉल करना

लारवेल में, पायथन सेवा से बात करने के लिए Http::post() (from Illuminate\Support\Facades\Http) का उपयोग करें:

use Illuminate\Support\Facades\Http;

$response = Http::post('http://your-python-host:8000/generate', [
    'prompt' => 'बताएं कि फाइन-ट्यूनिंग क्या है।',
    'max_new_tokens' => 256,
    'temperature' => 0.7,
]);

$result = $response->json()['result'] ?? null;

आप इसे एक सेवा वर्ग (जैसे App\Services\AIClient) में लपेट सकते हैं और इसे अपने नियंत्रकों से कॉल कर सकते हैं।

7. बेहतर फाइन-ट्यूनिंग परिणामों के लिए सुझाव

1. छोटे से शुरू करें: एक 7B मॉडल और एक छोटे डेटासेट (1k–10k उदाहरण) के साथ शुरुआत करें।
2. प्रॉम्प्ट को सुसंगत रखें: उसी संरचना का उपयोग करें जिसका आप अनुमान समय पर उपयोग करेंगे।
3. अक्सर मूल्यांकन करें:
   • मूल्यांकन प्रश्नों का एक छोटा सेट बनाएँ।
   • प्रत्येक प्रशिक्षण रन पर प्रतिक्रियाओं की जाँच करें।
4. ओवरफिटिंग से बचें:
   • एक सत्यापन सेट का उपयोग करें।
   • देखें कि मॉडल याद करना शुरू करता है या नहीं।
5. अपनी सेटिंग्स को दस्तावेज़ित करें:
   • लोरा रैंक, लर्निंग रेट, युग, डेटासेट संस्करण।
   • यह अच्छे रन को पुन: पेश करने में मदद करता है।

8. तलाशने के लिए लोकप्रिय उपकरण और ढांचे

• हगिंग फेस इकोसिस्टम
  • ट्रांसफॉर्मर
  • डेटासेट
  • पीईएफटी
  • TRL (सुदृढीकरण सीखना / SFT पुस्तकालय)
• vLLM – उच्च-थ्रूपुट सर्विंग: https://github.com/vllm-project/vllm
• एक्सोलोटल – LLM फाइन-ट्यूनिंग टूलकिट: https://github.com/OpenAccess-AI-Collective/axolotl
• बड़े पैमाने पर प्रशिक्षण के लिए डीपस्पीड / FSDP: DeepSpeed

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

कभी-कभी आप जो चाहते हैं वह आपको मिल सकता है:

• प्रॉम्प्ट इंजीनियरिंग (बेहतर निर्देश और उदाहरण)
• RAG (पुनर्प्राप्ति-संवर्धित पीढ़ी) – क्वेरी समय पर बाहरी दस्तावेज़ों को खिलाना, भार को बदले बिना
  • हेस्टैक, LlamaIndex, या LangChain का उपयोग करें

RAG पूर्ण फाइन-ट्यूनिंग की तुलना में बनाए रखने और अपडेट करने में अक्सर आसान होता है, खासकर तेजी से बदलते ज्ञान के लिए।

10. अगले कदम

यदि आप अभी शुरुआत कर रहे हैं:

1. हगिंग फेस से एक निर्देश मॉडल चुनें।
2. अपने स्वयं के डोमेन से एक छोटा निर्देश डेटासेट बनाएँ।
3. एक छोटा फाइन-ट्यून चलाने के लिए QLoRA + PEFT का उपयोग करें।
4. एक छोटे पायथन API के माध्यम से अपने मॉडल को सर्व करें।
5. Http::post() के साथ लारवेल से इसे कॉल करें और अपना इंटरफ़ेस बनाएँ।

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

• आपके पास क्या उपयोग का मामला है (चैटबॉट, कोड सहायक, आंतरिक उपकरण, आदि)
• आप किस हार्डवेयर (GPU / RAM) तक पहुँच सकते हैं

मैं आपके सटीक सेटअप के अनुरूप एक चरण-दर-चरण फाइन-ट्यूनिंग योजना की रूपरेखा दे सकता हूं।