---
title: "क्या LLM को फ़ाइन-ट्यून करना ज़रूरी है? तैयारी की चेकलिस्ट"
description: "कब प्रॉम्प्टिंग, RAG या evaluation समस्या हल कर देते हैं और फ़ाइन-ट्यूनिंग ज़रूरी नहीं, कैसा ट्रेनिंग डेटा चाहिए, और फ़ाइन-ट्यून माँगने से पहले उसे कैसे जाँचें।"
url: https://broadrouter.com/hi/blog/fine-tuning-readiness/
lang: hi
updated: 2026-11-15
publisher: BroadRouter (a BroadNet site); API by BroadNet Inference, https://inference.broadnet.ai
---

यह पेज अंग्रेज़ी से AI की मदद से अनुवाद किया गया है। [अंग्रेज़ी मूल पढ़ें](https://broadrouter.com/blog/fine-tuning-readiness/) (2026-11-16 को अपडेट किया गया).

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

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

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

## मुख्य बातें

-   eval set से शुरू करें। baseline स्कोर के बिना आप नहीं बता सकते कि फ़ाइन-ट्यून से मदद मिली या नहीं।
-   ग़ायब या बदलते तथ्य retrieval की समस्या हैं। फ़ाइन-ट्यूनिंग बदलते तथ्यों के मुक़ाबले व्यवहार और शैली ज़्यादा भरोसे से सिखाती है।
-   OpenAI की अपनी गाइड evals और prompt engineering को फ़ाइन-ट्यूनिंग से पहले रखती है, और कहती है कि प्रॉम्प्टिंग "may be all you need" (अनुवाद: शायद इतना ही काफ़ी हो)।
-   ट्रेनिंग डेटा को अधिकार, एकरूपता और एक अलग रखा टेस्ट सेट चाहिए जो कभी ट्रेनिंग में न आए। एक छोटी स्क्रिप्ट duplicates, विरोधाभास और leaks पकड़ लेती है।
-   BroadNet के self-serve API में कोई फ़ाइन-ट्यूनिंग endpoint नहीं है। उसके अरबी फ़ाइन-ट्यून अनुरोध पर, प्राइवेट एंडपॉइंट पर प्राइवेट मॉडल ID के साथ मिलते हैं।

**इस पेज पर**

1.  आप कौन-सी समस्या हल करना चाहते हैं?
2.  कैसे साबित करें कि विफलता बार-बार होती है?
3.  पहले कौन-से सरल बदलाव टेस्ट करें?
4.  कौन-सा डेटा चाहिए, और क्या आपके पास उसे इस्तेमाल करने का अधिकार है?
5.  फ़ाइन-ट्यून का निष्पक्ष मूल्यांकन कैसे करें?
6.  जब आप होस्टेड मॉडल फ़ाइन-ट्यून नहीं कर सकते, तो क्या बदलता है?
7.  BroadNet Inference कहाँ फ़िट होता है

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

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

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

| लक्षण | पहले आज़माएँ | फ़ाइन-ट्यूनिंग तब मदद करती है जब |
| --- | --- | --- |
| ग़लत या पुराने तथ्य | आपके दस्तावेज़ों पर [Retrieval (RAG)](https://broadrouter.com/hi/glossary/rag/) | शायद ही कभी; बदलते तथ्यों को वैसे भी retrieval चाहिए |
| ग़लत फ़ॉर्मैट, टूटा JSON | [Structured output](https://broadrouter.com/hi/glossary/structured-output/), schema चेक, एक retry | फ़ॉर्मैट असामान्य हो और प्रॉम्प्ट में उदाहरण काफ़ी न हों |
| असंगत लेबल या श्रेणियाँ | साफ़ परिभाषाएँ और [few-shot उदाहरण](https://broadrouter.com/hi/glossary/few-shot-prompting/) | लेबल सेट बड़ा या बारीक हो और उदाहरण प्रॉम्प्ट में न समाएँ |
| ग़लत लहजा या शैली | [सिस्टम प्रॉम्प्ट](https://broadrouter.com/hi/glossary/system-prompt/) में उदाहरणों के साथ स्टाइल गाइड | हज़ारों आउटपुट में एक हाउस स्टाइल बनी रहनी चाहिए |
| डोमेन शब्द ग़लत सुने या ग़लत लिखे गए | प्रॉम्प्ट में शब्दावली की सूची, कोड में बाद का सुधार | स्पीच मॉडल वही नाम, कोड या नंबर बार-बार ग़लत सुनते हैं |
| बड़े पैमाने पर बहुत धीमा या महँगा | छोटा मॉडल, [prompt caching](https://broadrouter.com/hi/blog/prompt-structure-for-caching/), छोटे प्रॉम्प्ट | एक छोटा फ़ाइन-ट्यून मॉडल किसी संकरे टास्क पर बड़े मॉडल की बराबरी कर सके |
| ग़लत भाषा या बोली | सही भाषा में निर्देश; [अरबी prompt engineering](https://broadrouter.com/hi/blog/arabic-prompt-engineering/) देखें | मॉडल समझता है लेकिन आपकी ज़रूरत वाली बोली में नहीं लिखता |

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

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

eval set से। ज्ञात सही आउटपुट वाले 100 से 200 असली इनपुट जुटाएँ, जैसा [मॉडल बदलने से पहले LLM का मूल्यांकन](https://broadrouter.com/hi/blog/evaluate-llm-before-switching/) में है। अपने मौजूदा प्रॉम्प्ट को स्कोर करें। फिर हर विफलता को एक छोटी श्रेणी से लेबल करें: `wrong_label`, `missing_field`, `dialect`, `hallucinated_fact`, वग़ैरह।

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

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

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

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

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

1.  **निर्देश।** हर लेबल या फ़ील्ड की परिभाषा दें। बताएँ कि अनिश्चित होने पर क्या करना है।
2.  **उदाहरण।** तीन से दस असली उदाहरण जोड़ें, कठिन मामलों समेत।
3.  **Retrieval।** अगर जवाबों के लिए तथ्य चाहिए, तो संबंधित अंश retrieve करें। विकल्प [अरबी RAG search](https://broadrouter.com/hi/blog/arabic-rag-search/) और [लंबा कॉन्टेक्स्ट बनाम RAG](https://broadrouter.com/hi/blog/long-context-vs-rag/) में हैं।
4.  **बंधन।** जहाँ मॉडल सपोर्ट करे, structured output इस्तेमाल करें, और आउटपुट को कोड में जाँचें। एरर के साथ एक बार दोबारा पूछें।
5.  **दूसरा मॉडल।** हो सकता है कोई दूसरा बेस मॉडल पहले से वह करता हो जो आपको चाहिए। वही eval set आपको एक घंटे में बता देगा।

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

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

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

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

```python
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](https://broadrouter.com/hi/blog/arabic-text-normalization-search/) में है), एक इनपुट जो `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 मॉडल](https://broadrouter.com/hi/glossary/open-weight-model/) है, जिसे [LoRA](https://broadrouter.com/hi/glossary/lora/) जैसी parameter-efficient विधि से ट्रेन किया जाए। LoRA पेपर (Hu et al.) बताता है कि Adam के साथ GPT-3 175B की पूरी फ़ाइन-ट्यूनिंग के मुक़ाबले LoRA ट्रेन होने वाले पैरामीटर 10,000 गुना और GPU मेमोरी की ज़रूरत 3 गुना घटा सकता है। फिर आपको नतीजे को सर्व करने की जगह चाहिए, या तो आपका अपना हार्डवेयर या कोई प्रोवाइडर जो कस्टम weights होस्ट करे। यह समझौता [open-weight बनाम closed मॉडल](https://broadrouter.com/hi/blog/open-weight-vs-closed-models/) में है।

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

BroadRouter, BroadNet की अपनी साइट है। BroadNet Inference के self-serve API में कोई फ़ाइन-ट्यूनिंग endpoint नहीं है: उसका [API रेफ़रंस](https://inference.broadnet.ai/docs?utm_source=broadrouter&utm_medium=referral&utm_campaign=hi-blog-fine-tuning-readiness&utm_content=body) सिर्फ़ 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 पेज](https://broadrouter.com/hi/contact/#private) के ज़रिए पूछताछ हैं, ऐसी चीज़ नहीं जिसे आप ख़ुद ख़रीद या ट्रेन कर सकें; क्या भेजना है, यह [प्राइवेट एंडपॉइंट की योजना](https://broadrouter.com/hi/blog/private-endpoint-planning/) में है।

उस क़दम से पहले की हर चीज़ के लिए, यानी अपना eval set और baseline बनाने के लिए, सार्वजनिक मॉडल काफ़ी हैं: [Qwen3.8 27B](https://broadrouter.com/hi/models/qwen3.8-27b/) और [GLM 5.3](https://broadrouter.com/hi/models/glm-5.3/) structured output डॉक्यूमेंट करते हैं, [Gemma 4 VL 26B](https://broadrouter.com/hi/models/gemma-4-vl-26b/) $5 के शुरुआती क्रेडिट पर चलता है, और [BroadNet Transcribe Arabic](https://broadrouter.com/hi/models/cohere-transcribe-arabic/) $0.0042 प्रति मिनट पर स्पीच संभालता है। inference कंटेंट नहीं रखा जाता; ज़रूरी अकाउंट, बिलिंग और सिक्योरिटी मेटाडेटा BroadNet के प्राइवेसी स्टेटमेंट में बताए अनुसार रखा जाता है।

इस विषय के मुफ़्त टूल (अंग्रेज़ी में)

-   [OpenAI to BroadNet migration helper](https://broadrouter.com/tools/openai-to-broadnet-migration/) Paste OpenAI SDK code; get base URL, key and model edits, a diff and the checks that remain.
-   [max\_tokens calculator for reasoning models](https://broadrouter.com/tools/reasoning-token-budget/) Answer length + reasoning budget + margin = a max\_tokens that does not cut the answer off.
-   [JSON schema generator for LLM structured output](https://broadrouter.com/tools/json-schema-generator/) Sample JSON to strict schema, Pydantic, Zod and a ready request.
-   [LLM JSON output validator](https://broadrouter.com/tools/llm-json-output-validator/) Parse errors by line and column, safe repairs, cut-off detection and JSON Schema checks for model output.

[मुफ़्त टूल (अंग्रेज़ी में)](https://broadrouter.com/tools/)

## इस लेख के शब्द

[Eval (LLM इवैल्यूएशन)](https://broadrouter.com/hi/glossary/eval/)

Eval (evaluation का छोटा रूप) किसी लैंग्वेज मॉडल या प्रॉम्प्ट का दोहराने लायक़ टेस्ट है: इनपुट का एक तय सेट, अच्छे आउटपुट का वर्णन, और एक ग्रेडर (कोड, इंसान या दूसरा मॉडल) जो हर आउटपुट को स्कोर करता है, ताकि अलग-अलग वर्ज़न की तुलना हो सके।

[फ़ाइन-ट्यूनिंग (fine-tuning)](https://broadrouter.com/hi/glossary/fine-tuning/)

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

[स्ट्रक्चर्ड आउटपुट (structured output)](https://broadrouter.com/hi/glossary/structured-output/)

स्ट्रक्चर्ड आउटपुट LLM API का एक फ़ीचर है जो मॉडल के जवाब को डेवलपर के तय फ़ॉर्मैट, आम तौर पर JSON Schema, तक सीमित करता है, ताकि कोड उसे भरोसे से पार्स कर सके। यह JSON mode से सख़्त है, जो मान्य JSON की गारंटी देता है, लेकिन किसी ख़ास ढाँचे की नहीं।

[प्रॉम्प्ट इंजीनियरिंग (prompt engineering)](https://broadrouter.com/hi/glossary/prompt-engineering/)

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

[LoRA (low-rank adaptation)](https://broadrouter.com/hi/glossary/lora/)

LoRA (low-rank adaptation) एक पैरामीटर-कुशल fine-tuning तरीक़ा है जो पहले से ट्रेन हुए मॉडल के weights को जमा (freeze) देता है और चुनी हुई layers के लिए छोटी low-rank मैट्रिक्स की एक जोड़ी ट्रेन करता है। सीखा गया बदलाव छोटे adapter के रूप में रखा जा सकता है या weights में मिलाया जा सकता है, बिना इन्फ़रेंस latency बढ़ाए।

[RAG (retrieval-augmented generation)](https://broadrouter.com/hi/glossary/rag/)

RAG (retrieval-augmented generation) एक पैटर्न है जिसमें ऐप्लिकेशन पहले किसी बाहरी स्टोर, जैसे सर्च या वेक्टर इंडेक्स, से सवाल से जुड़े हिस्से निकालता है, और फिर उन्हें प्रॉम्प्ट में जोड़ता है, ताकि लैंग्वेज मॉडल सिर्फ़ अपनी याददाश्त के बजाय उस टेक्स्ट से जवाब दे सके।

[टोकन (token)](https://broadrouter.com/hi/glossary/token/)

टोकन टेक्स्ट की वह इकाई है जिसे लैंग्वेज मॉडल पढ़ता और लिखता है: कोई शब्द, शब्द का हिस्सा, विराम चिह्न या बाइट का क्रम, जो मॉडल का टोकनाइज़र बनाता है। LLM API इस्तेमाल को टोकन में गिनते हैं, उसी में लिमिट लगाते हैं और आम तौर पर बिल भी बनाते हैं।

[लेटेंसी (latency)](https://broadrouter.com/hi/glossary/latency/)

लैंग्वेज मॉडल API के लिए लेटेंसी वह समय है जो किसी अनुरोध के भेजे जाने से अंतिम आउटपुट टोकन मिलने तक लगता है। यह पहले टोकन तक के समय और जनरेशन टाइम का जोड़ है, और आम तौर पर औसत के बजाय p50 और p95 जैसे परसेंटाइल में बताई जाती है।

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

### मुझे फ़ाइन-ट्यून करना चाहिए या 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 कंटेंट नहीं रखता। अगर आप अपने ट्रैफ़िक पर फ़ाइन-ट्यून करना चाहते हैं, तो वह डेटा आपको ख़ुद जुटाना और स्टोर करना होगा, उसे इस्तेमाल करने के अधिकार के साथ।

## आगे पढ़ें

-   [प्रोवाइडर बदलने से पहले LLM का मूल्यांकन कैसे करें](https://broadrouter.com/hi/blog/evaluate-llm-before-switching/)
-   [अरबी प्रॉम्प्ट इंजीनियरिंग: register, RTL, अंक और मिला-जुला टेक्स्ट](https://broadrouter.com/hi/blog/arabic-prompt-engineering/)
-   [अरबी RAG: normalisation, chunking और retrieval जो सच में काम करे](https://broadrouter.com/hi/blog/arabic-rag-search/)
-   [लॉन्ग कॉन्टेक्स्ट बनाम RAG: कब 1M टोकन वेक्टर DB की जगह लेते हैं](https://broadrouter.com/hi/blog/long-context-vs-rag/)
-   [JSON mode बनाम json\_schema: भरोसेमंद स्ट्रक्चर्ड आउटपुट](https://broadrouter.com/hi/blog/structured-output-json-schema/)
-   [बिज़नेस के लिए open-weight बनाम closed AI मॉडल: लागत, नियंत्रण, जोखिम](https://broadrouter.com/hi/blog/open-weight-vs-closed-models/)
-   [प्राइवेट एंडपॉइंट की शुरुआत साफ़ वर्कलोड से होती है](https://broadrouter.com/hi/blog/private-endpoint-planning/)
-   [BroadNet का GPU हार्डवेयर और सर्विंग का तरीक़ा, BroadNet के शब्दों में](https://broadrouter.com/hi/blog/broadnet-gpu-fleet-and-serving/)
-   [LLM API रिस्पॉन्स कैश करके लागत घटाएँ: Python में एक्ज़ैक्ट-मैच कैश](https://broadrouter.com/hi/blog/cache-llm-responses-cut-cost/)
-   [गाइड: अरबी speech-to-text API, स्टेप बाय स्टेप](https://broadrouter.com/hi/guides/arabic-speech-to-text-api/)
-   [गाइड: BroadNet Inference के साथ OpenAI Python SDK इस्तेमाल करें](https://broadrouter.com/hi/guides/openai-python-sdk/)

इसे अपने असली वर्कलोड पर आज़माएँ। नए अकाउंट Gemma और ट्रांसक्रिप्शन के लिए US$5 के क्रेडिट से शुरू होते हैं। DeepSeek, GLM, और Qwen3.8 के लिए टॉप-अप ज़रूरी है।

[शुरू करें](https://inference.broadnet.ai/account/?utm_source=broadrouter&utm_medium=referral&utm_campaign=hi-blog-fine-tuning-readiness&utm_content=page-cta) ·

**स्रोत**

-   [OpenAI, Model optimization गाइड: evals, prompt engineering और फ़ाइन-ट्यूनिंग (2026-11-15 को जाँचा गया)](https://platform.openai.com/docs/guides/fine-tuning)
-   [OpenAI, Deprecations: self-serve फ़ाइन-ट्यूनिंग पर अपडेट, दिनांक 7 मई 2026, 2 जुलाई 2026 और 6 जनवरी 2027 (2026-11-15 को जाँचा गया)](https://platform.openai.com/docs/deprecations)
-   [Hu et al., LoRA: Low-Rank Adaptation of Large Language Models, arXiv 2106.09685 (2026-11-15 को जाँचा गया)](https://arxiv.org/abs/2106.09685)
-   [BroadNet Inference API रेफ़रंस: endpoints, और प्राइवेट ID से मिलने वाले "our Arabic fine-tunes" (2026-11-15 को जाँचा गया) (अंग्रेज़ी में)](https://inference.broadnet.ai/docs?utm_source=broadrouter&utm_medium=referral&utm_campaign=hi-blog-fine-tuning-readiness&utm_content=sources)
-   [BroadNet मॉडल पेज, Cohere Transcribe Arabic BroadNet फ़ाइन-ट्यून: अनुरोध पर, हर ग्राहक के लिए प्राइवेट ID (2026-11-15 को जाँचा गया) (अंग्रेज़ी में)](https://www.broadnet.ai/inference/models/cohere-transcribe-arabic-broadnet)
-   [BroadNet मॉडल पेज, Gemma 4 VL 26B: प्राइवेट एंडपॉइंट "including our Arabic fine-tunes" (2026-11-15 को जाँचा गया) (अंग्रेज़ी में)](https://www.broadnet.ai/inference/models/gemma-4-vl-26b)
-   [BroadNet Inference प्राइवेसी स्टेटमेंट: inference डेटा का इस्तेमाल मॉडलों की ट्रेनिंग, फ़ाइन-ट्यूनिंग या मूल्यांकन में नहीं (2026-11-15 को जाँचा गया) (अंग्रेज़ी में)](https://www.broadnet.ai/inference-privacy)
