BroadRouter

फ़ाइन-ट्यूनिंग से पहले: हल करने वाली समस्या तय करें

BroadNet Inference टीम · 7 मिनट में पढ़ें · प्रकाशित · अपडेट किया गया

फ़ाइन-ट्यून तभी करें जब evaluation में कोई बार-बार होने वाली विफलता दिखे जिसे बेहतर प्रॉम्प्ट, उदाहरण, retrieval और validation ठीक न कर पाए हों। ग़ायब जानकारी के लिए आम तौर पर retrieval चाहिए, और फ़ॉर्मैट की ग़लतियों के लिए structured output और जाँच। कस्टम मॉडल माँगने से पहले ऐसे लेबल किए उदाहरण जुटाएँ जिन्हें आप क़ानूनी रूप से इस्तेमाल कर सकें, एक टेस्ट सेट अलग रखें, और हराने वाला स्कोर दर्ज करें।

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

आप कौन-सी समस्या हल करना चाहते हैं?

इलाज का नाम लेने से पहले विफलता का नाम लें। LLM की ज़्यादातर विफलताएँ कुछ पैटर्न में आती हैं, और हर एक का एक सस्ता पहला क़दम है:

लक्षण पहले आज़माएँ फ़ाइन-ट्यूनिंग तब मदद करती है जब
ग़लत या पुराने तथ्य आपके दस्तावेज़ों पर Retrieval (RAG) शायद ही कभी; बदलते तथ्यों को वैसे भी retrieval चाहिए
ग़लत फ़ॉर्मैट, टूटा JSON Structured output, schema चेक, एक retry फ़ॉर्मैट असामान्य हो और प्रॉम्प्ट में उदाहरण काफ़ी न हों
असंगत लेबल या श्रेणियाँ साफ़ परिभाषाएँ और few-shot उदाहरण लेबल सेट बड़ा या बारीक हो और उदाहरण प्रॉम्प्ट में न समाएँ
ग़लत लहजा या शैली सिस्टम प्रॉम्प्ट में उदाहरणों के साथ स्टाइल गाइड हज़ारों आउटपुट में एक हाउस स्टाइल बनी रहनी चाहिए
डोमेन शब्द ग़लत सुने या ग़लत लिखे गए प्रॉम्प्ट में शब्दावली की सूची, कोड में बाद का सुधार स्पीच मॉडल वही नाम, कोड या नंबर बार-बार ग़लत सुनते हैं
बड़े पैमाने पर बहुत धीमा या महँगा छोटा मॉडल, prompt caching, छोटे प्रॉम्प्ट एक छोटा फ़ाइन-ट्यून मॉडल किसी संकरे टास्क पर बड़े मॉडल की बराबरी कर सके
ग़लत भाषा या बोली सही भाषा में निर्देश; अरबी prompt engineering देखें मॉडल समझता है लेकिन आपकी ज़रूरत वाली बोली में नहीं लिखता

OpenAI की अपनी गाइड यही क्रम बताती है: पहले evals लिखें, फिर प्रॉम्प्ट पर दोहराव करें, और कुछ use cases के लिए फ़ाइन-ट्यून करें। वह कहती है कि prompt engineering की प्रक्रिया “may be all you need in order to get great results.” (अनुवाद: शानदार नतीजे पाने के लिए शायद इतना ही काफ़ी हो।) वह गिनाती है कि फ़ाइन-ट्यूनिंग प्रॉम्प्टिंग पर क्या जोड़ती है: एक प्रॉम्प्ट में समाने से ज़्यादा उदाहरण, टोकन बचाने वाले छोटे प्रॉम्प्ट, ऐसे डेटा पर ट्रेनिंग जिसे आप हर अनुरोध में नहीं भेजना चाहते, और एक छोटे मॉडल को किसी एक टास्क में अच्छा बनाना।

कैसे साबित करें कि विफलता बार-बार होती है?

eval set से। ज्ञात सही आउटपुट वाले 100 से 200 असली इनपुट जुटाएँ, जैसा मॉडल बदलने से पहले LLM का मूल्यांकन में है। अपने मौजूदा प्रॉम्प्ट को स्कोर करें। फिर हर विफलता को एक छोटी श्रेणी से लेबल करें: wrong_label, missing_field, dialect, hallucinated_fact, वग़ैरह।

कोई पैटर्न फ़ाइन-ट्यूनिंग का उम्मीदवार तभी है जब तीनों बातें सच हों:

  1. वह बार-बार होता है। विफलताओं में उसका ठीक-ठाक हिस्सा है, सिर्फ़ एक-दो अजीब मामले नहीं।
  2. वह सस्ते इलाजों के बाद भी बचा रहता है। आपने साफ़ निर्देश, उदाहरण, retrieval और validation आज़माए, और श्रेणी फिर भी मौजूद है।
  3. वह एकरूप है। लोग सही जवाब पर सहमत हैं। अगर आपके अपने दो रिव्यूअर एक ही मामले को अलग-अलग लेबल करते हैं, तो उनके लेबल पर ट्रेन हुआ मॉडल उनकी असहमति सीख लेगा।

नतीजे को एक छोटे वाक्य में लिखें, जैसे यह काल्पनिक उदाहरण: “हमारे 200 मामलों वाले अरबी सपोर्ट सेट पर सबसे अच्छा प्रॉम्प्ट 18% बिलिंग टिकटों को डिलीवरी लेबल कर देता है; few-shot उदाहरणों से यह 15% हुआ।” यही वाक्य फ़ाइन-ट्यून का ब्रीफ़ है, और यही हराने वाली संख्या।

पहले कौन-से सरल बदलाव टेस्ट करें?

उन्हें लागत के क्रम में चलाएँ, और हर एक के बाद दोबारा स्कोर करें:

  1. निर्देश। हर लेबल या फ़ील्ड की परिभाषा दें। बताएँ कि अनिश्चित होने पर क्या करना है।
  2. उदाहरण। तीन से दस असली उदाहरण जोड़ें, कठिन मामलों समेत।
  3. Retrieval। अगर जवाबों के लिए तथ्य चाहिए, तो संबंधित अंश retrieve करें। विकल्प अरबी RAG search और लंबा कॉन्टेक्स्ट बनाम RAG में हैं।
  4. बंधन। जहाँ मॉडल सपोर्ट करे, structured output इस्तेमाल करें, और आउटपुट को कोड में जाँचें। एरर के साथ एक बार दोबारा पूछें।
  5. दूसरा मॉडल। हो सकता है कोई दूसरा बेस मॉडल पहले से वह करता हो जो आपको चाहिए। वही eval set आपको एक घंटे में बता देगा।

हर क़दम में हफ़्ते नहीं, घंटे लगते हैं, और हर क़दम आपको एक बेहतर baseline देता है, जिसे अगर फिर भी ज़रूरत पड़े तो फ़ाइन-ट्यून को हराना होगा।

कौन-सा डेटा चाहिए, और क्या आपके पास उसे इस्तेमाल करने का अधिकार है?

क्वालिटी से पहले अधिकार जाँचें। ट्रेनिंग डेटा अक्सर ग्राहकों की बातचीत, दस्तावेज़ों या कॉल रिकॉर्डिंग से आता है। आपको एक क़ानूनी आधार चाहिए और अक्सर सहमति, या ऐसी कॉन्ट्रैक्ट शर्त जो ट्रेनिंग को कवर करे। अपना प्राइवेसी नोटिस और ग्राहक कॉन्ट्रैक्ट जाँचें, और जो निजी डेटा ज़रूरी नहीं, उसे हटा दें। यह न मानें कि आपका API प्रोवाइडर आपके लिए इसे जुटा रहा है: उदाहरण के लिए, BroadNet का प्राइवेसी स्टेटमेंट कहता है कि वह inference कंटेंट नहीं रखता और inference डेटा का इस्तेमाल मॉडलों की ट्रेनिंग, फ़ाइन-ट्यूनिंग या मूल्यांकन में नहीं करता।

फिर क्वालिटी जाँचें। यह स्क्रिप्ट आम chat JSONL फ़ॉर्मैट (हर पंक्ति में एक {"messages": [...]}, assistant के जवाब पर ख़त्म) में एक ट्रेनिंग फ़ाइल और एक eval फ़ाइल पढ़ती है और वे समस्याएँ बताती है जो चुपचाप फ़ाइन-ट्यून बिगाड़ देती हैं: टूटी पंक्तियाँ, duplicates, एक ही इनपुट के अलग-अलग जवाब, ट्रेनिंग में लीक हुए eval आइटम, लेबल का संतुलन और संभावित निजी डेटा।

import json, re, sys
from collections import Counter

DIAC = re.compile(r"[ً-ٰٟـ]")          # tashkeel, dagger alef, tatweel
PII = {"email": re.compile(r"[\w.+-]+@[\w-]+\.[\w.]+"),
       "phone": re.compile(r"(?:\+|00)\d[\d\s-]{7,}\d")}

def norm(s: str) -> str:
    s = DIAC.sub("", s.lower())
    s = re.sub("[إأآٱ]", "ا", s).replace("ى", "ي")
    return " ".join(s.split())

def load(path):
    rows, errors = [], []
    for i, line in enumerate(open(path, encoding="utf-8"), 1):
        try:
            ex = json.loads(line)
            roles = [m["role"] for m in ex["messages"]]
            if roles[-1] != "assistant" or "user" not in roles:
                raise ValueError(f"roles {roles}")
            rows.append(ex)
        except (ValueError, KeyError, IndexError, TypeError) as e:
            errors.append(f"line {i}: {e}")
    return rows, errors

def key(ex):     # the input side, normalised: what the model sees
    return norm(" ".join(m["content"] for m in ex["messages"] if m["role"] != "assistant"))

def check(train_path, eval_path):
    train, errs = load(train_path)
    evals, eval_errs = load(eval_path)
    keys = Counter(key(e) for e in train)
    labels = Counter(e["messages"][-1]["content"].strip() for e in train)
    leaked = {key(e) for e in evals} & set(keys)
    pii = Counter(k for e in train for m in e["messages"] for k, rx in PII.items() if rx.search(m["content"]))
    conflicts = Counter()
    seen = {}
    for e in train:
        k, a = key(e), e["messages"][-1]["content"].strip()
        if k in seen and seen[k] != a:
            conflicts[k] += 1
        seen.setdefault(k, a)
    return {"train_examples": len(train), "parse_errors": errs + eval_errs,
            "duplicate_inputs": sum(n - 1 for n in keys.values() if n > 1),
            "same_input_different_answer": len(conflicts),
            "eval_items_also_in_train": len(leaked),
            "answer_distribution": labels.most_common(5),
            "examples_with_possible_pii": dict(pii)}

if __name__ == "__main__":
    print(json.dumps(check(sys.argv[1], sys.argv[2]), ensure_ascii=False, indent=1))

हमने इसे अरबी, अंग्रेज़ी और स्पेनिश सपोर्ट टिकटों वाली सात पंक्तियों की एक toy फ़ाइल पर चलाया। इसे एक पंक्ति बिना assistant जवाब के मिली, दो duplicate इनपुट (एक में फ़र्क़ सिर्फ़ एक डायक्रिटिक का था, जिसे normaliser हटा देता है, जैसा अरबी टेक्स्ट normalization में है), एक इनपुट जो billing और other दोनों लेबल वाला था, एक eval आइटम जो ट्रेनिंग में भी था, और एक फ़ोन नंबर। इनमें से हर एक फ़ाइन-ट्यून को असल से बेहतर या बदतर दिखाता।

अरबी के लिए normalisation ज़रूरी है। इसके बिना “متأخر” और “متأخِّر” अलग इनपुट गिने जाते हैं, और किसी टेस्ट आइटम की लगभग-नक़ल ट्रेनिंग में घुस सकती है।

फ़ाइन-ट्यून का निष्पक्ष मूल्यांकन कैसे करें?

वही अलग रखा टेस्ट सेट इस्तेमाल करें जो baseline के लिए किया था, और उसे ट्रेनिंग से बाहर रखें। फिर तुलना करें:

  • सबसे अच्छे प्रॉम्प्ट से, पहले वाले से नहीं। कमज़ोर प्रॉम्प्ट को हराने वाला फ़ाइन-ट्यून कुछ साबित नहीं करता।
  • हर श्रेणी और हर भाषा के हिसाब से। कुल फ़ायदा अंग्रेज़ी के सुधरने के बीच अरबी की गिरावट छिपा सकता है। हर एक की रिपोर्ट दें।
  • सामान्य व्यवहार पर। 20 से 50 ऐसे साधारण अनुरोध जोड़ें जिन्हें मॉडल पहले अच्छी तरह संभालता था। संकरी ट्रेनिंग टास्क के बाहर का व्यवहार बिगाड़ सकती है।
  • लागत और latency पर। फ़ाइन-ट्यून अक्सर इस आधार पर सही ठहरता है कि एक छोटा मॉडल काम कर दे। हर अनुरोध के टोकन और समय भी मापें।

संख्याएँ देखने से पहले पास होने का नियम तय करें, जैसा eval वाली पोस्ट में है: उदाहरण के लिए, “बिलिंग लेबल पर कम से कम 5 अंक बेहतर, कोई श्रेणी 2 अंक से ज़्यादा बदतर नहीं, अरबी और अंग्रेज़ी दोनों पास।”

जब आप होस्टेड मॉडल फ़ाइन-ट्यून नहीं कर सकते, तो क्या बदलता है?

जितना आप सोचते हैं, उससे कम होस्टेड API self-serve फ़ाइन-ट्यूनिंग देते हैं। OpenAI का deprecations पेज उसके self-serve फ़ाइन-ट्यूनिंग प्लेटफ़ॉर्म पर एक अपडेट दर्ज करता है: 7 मई 2026 से जिन संगठनों ने फ़ाइन-ट्यूनिंग नहीं चलाई थी, वे अब jobs नहीं बना सकते; 2 जुलाई 2026 से वे संगठन भी नहीं, जिन्होंने पिछले 60 दिनों में किसी फ़ाइन-ट्यून मॉडल पर inference नहीं चलाया था; और 6 जनवरी 2027 से सक्रिय मौजूदा ग्राहक भी नई फ़ाइन-ट्यूनिंग jobs नहीं बना सकेंगे। मौजूदा फ़ाइन-ट्यून मॉडल inference के लिए तब तक उपलब्ध रहेंगे जब तक उनके बेस मॉडल deprecate नहीं होते।

आम विकल्प एक open-weight मॉडल है, जिसे LoRA जैसी parameter-efficient विधि से ट्रेन किया जाए। LoRA पेपर (Hu et al.) बताता है कि Adam के साथ GPT-3 175B की पूरी फ़ाइन-ट्यूनिंग के मुक़ाबले LoRA ट्रेन होने वाले पैरामीटर 10,000 गुना और GPU मेमोरी की ज़रूरत 3 गुना घटा सकता है। फिर आपको नतीजे को सर्व करने की जगह चाहिए, या तो आपका अपना हार्डवेयर या कोई प्रोवाइडर जो कस्टम weights होस्ट करे। यह समझौता open-weight बनाम closed मॉडल में है।

BroadNet Inference कहाँ फ़िट होता है

BroadRouter, BroadNet की अपनी साइट है। BroadNet Inference के self-serve API में कोई फ़ाइन-ट्यूनिंग endpoint नहीं है: उसका API रेफ़रंस सिर्फ़ chat completions और ऑडियो ट्रांसक्रिप्शन डॉक्यूमेंट करता है। वही पेज कहता है: “private endpoints, our Arabic fine-tunes and other models on request are reached with a private ID issued with the endpoint.” (अनुवाद: प्राइवेट एंडपॉइंट, हमारे अरबी फ़ाइन-ट्यून और अनुरोध पर मिलने वाले अन्य मॉडल, एंडपॉइंट के साथ जारी प्राइवेट ID से इस्तेमाल होते हैं।) BroadNet के मॉडल पेज शोर वाले ऑडियो में नंबरों, तारीख़ों और नामों के लिए Cohere Transcribe Arabic के एक BroadNet फ़ाइन-ट्यून को अनुरोध पर उपलब्ध बताते हैं, हर ग्राहक के लिए प्राइवेट मॉडल ID के साथ, और कहते हैं कि Gemma 4 VL 26B प्राइवेट एंडपॉइंट पर “including our Arabic fine-tunes” (अनुवाद: हमारे अरबी फ़ाइन-ट्यून समेत) उपलब्ध है। ये contact पेज के ज़रिए पूछताछ हैं, ऐसी चीज़ नहीं जिसे आप ख़ुद ख़रीद या ट्रेन कर सकें; क्या भेजना है, यह प्राइवेट एंडपॉइंट की योजना में है।

उस क़दम से पहले की हर चीज़ के लिए, यानी अपना eval set और baseline बनाने के लिए, सार्वजनिक मॉडल काफ़ी हैं: Qwen3.8 27B और GLM 5.3 structured output डॉक्यूमेंट करते हैं, Gemma 4 VL 26B $5 के शुरुआती क्रेडिट पर चलता है, और BroadNet Transcribe Arabic $0.0042 प्रति मिनट पर स्पीच संभालता है। inference कंटेंट नहीं रखा जाता; ज़रूरी अकाउंट, बिलिंग और सिक्योरिटी मेटाडेटा BroadNet के प्राइवेसी स्टेटमेंट में बताए अनुसार रखा जाता है।

अक्सर पूछे जाने वाले सवाल

मुझे फ़ाइन-ट्यून करना चाहिए या RAG इस्तेमाल करना चाहिए?

जब मॉडल के पास तथ्य न हों, ख़ासकर बदलते तथ्य (दस्तावेज़, कीमतें, नीतियाँ), तो retrieval इस्तेमाल करें। फ़ाइन-ट्यूनिंग पर तब विचार करें जब मॉडल के पास जानकारी हो लेकिन वह लगातार एक ही तरह ग़लत व्यवहार करे, जैसे फ़ॉर्मैट, लहजा, लेबल या डोमेन शब्दावली, और उदाहरणों वाले प्रॉम्प्ट से वह ठीक न हुआ हो।

कैसे पता करूँ कि prompt engineering काफ़ी है?

मापें। असली इनपुट से eval set बनाएँ, मौजूदा प्रॉम्प्ट को स्कोर करें, फिर साफ़ निर्देश, few-shot उदाहरण, structured output और validation आज़माएँ। अगर स्कोर आपके लक्ष्य तक पहुँच जाए, तो रुक जाएँ। अगर इन बदलावों के बाद भी कोई एक तरह की विफलता बनी रहे, तो वह फ़ाइन-ट्यूनिंग का उम्मीदवार है।

फ़ाइन-ट्यून करने के लिए कितना डेटा चाहिए?

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

क्या मैं BroadNet Inference पर मॉडल फ़ाइन-ट्यून कर सकता हूँ?

self-serve रूप में नहीं। BroadNet का API रेफ़रंस chat completions और ऑडियो ट्रांसक्रिप्शन डॉक्यूमेंट करता है, कोई ट्रेनिंग endpoint नहीं। BroadNet अरबी फ़ाइन-ट्यून, जैसे ट्यून किया गया Cohere Transcribe Arabic, अनुरोध पर मिलने वाले मॉडल के रूप में सूचीबद्ध करता है, जो प्राइवेट एंडपॉइंट पर प्राइवेट मॉडल ID के साथ सर्व होते हैं।

क्या BroadNet मेरे API ट्रैफ़िक पर ट्रेनिंग करता है?

BroadNet का प्राइवेसी स्टेटमेंट कहता है कि वह inference डेटा का इस्तेमाल मॉडलों की ट्रेनिंग, फ़ाइन-ट्यूनिंग या मूल्यांकन में नहीं करता, और inference कंटेंट नहीं रखता। अगर आप अपने ट्रैफ़िक पर फ़ाइन-ट्यून करना चाहते हैं, तो वह डेटा आपको ख़ुद जुटाना और स्टोर करना होगा, उसे इस्तेमाल करने के अधिकार के साथ।

Markdown में पढ़ेंChatGPT से पूछेंClaude से पूछेंPerplexity से पूछें

स्रोत