अंतिम समीक्षा: जून 2026
NCA-GENL परीक्षा द्वारा परखे जाने वाले architectural patterns का स्कैन-योग्य संदर्भ। ऊपर से नीचे पढ़ें या किसी section पर जाएं।
ट्रांसफ़ॉर्मर को अगले टोकन को जनरेट करते समय दूर के टोकन का वज़न करने की अनुमति क्या देता है, समझाएं।
सेल्फ-अटेंशन। प्रत्येक टोकन क्वेरी/की/वैल्यू प्रोजेक्शन के माध्यम से हर दूसरे टोकन पर ध्यान देता है, जिससे संदर्भ-भारित प्रतिनिधित्व उत्पन्न होता है।
क्यों: अटेंशन, न कि रिकरेंस, ट्रांसफ़ॉर्मर को लंबी दूरी का संदर्भ और समानांतर प्रशिक्षण देता है।
LLM में नया ज्ञान या व्यवहार कैसे डालें, यह चुनें।
अक्सर बदलने वाले नए तथ्य → RAG। नया कार्य व्यवहार/शैली → फ़ाइन-ट्यून। बड़े पैमाने पर नई आधार क्षमता/शब्दावली → निरंतर प्री-ट्रेनिंग।
क्यों: RAG डेटा को बाहरी और अपडेट करने योग्य रखता है; फ़ाइन-ट्यूनिंग व्यवहार को वज़न में डालता है; प्री-ट्रेनिंग सबसे महंगा लीवर है।
परिभाषित करें कि किसी मॉडल को फाउंडेशन मॉडल क्या बनाता है।
एक बड़ा मॉडल जो व्यापक, अधिकतर अचिह्नित डेटा पर प्री-ट्रेन किया गया है और प्रॉम्प्टिंग, RAG या फ़ाइन-ट्यूनिंग के माध्यम से कई डाउनस्ट्रीम कार्यों के लिए अनुकूलनीय है।
अनुमान लगाएं कि टेक्स्ट मॉडल इनपुट इकाइयों में कैसे मैप होता है और लागत को क्या बढ़ाता है।
टेक्स्ट को एक टोकेनाइज़र (जैसे BPE) द्वारा उप-शब्द टोकन में विभाजित किया जाता है। लागत और संदर्भ सीमाएं टोकन में मापी जाती हैं, न कि वर्णों या शब्दों में।
क्यों: दुर्लभ या गैर-अंग्रेजी शब्द अधिक टोकन में विभाजित होते हैं, जिससे संदर्भ उपयोग और अनुमान लागत बढ़ जाती है।
एक लंबा दस्तावेज़ एक ही प्रॉम्प्ट में फिट नहीं होता है।
इनपुट मॉडल की कॉन्टेक्स्ट विंडो (इनपुट + आउटपुट के लिए अधिकतम टोकन) से अधिक है। RAG के लिए दस्तावेज़ को चंक करें या लंबी-कॉन्टेक्स्ट वाला मॉडल चुनें।
क्यों: कॉन्टेक्स्ट विंडो एक कठिन सीमा है; इसके आगे सब कुछ काट दिया जाता है और चुपचाप खो जाता है।
टेक्स्ट पर semantic search या RAG retrieval को शक्ति दें।
टेक्स्ट को सघन वैक्टर में बदलने के लिए एक embedding model का उपयोग करें, फिर एक vector store से कोसाइन/डॉट-प्रोडक्ट समानता द्वारा retrieve करें।
क्यों: Embeddings अर्थपूर्ण रूप से समान टेक्स्ट को एक-दूसरे के पास रखती हैं, जिससे कीवर्ड retrieval के बजाय अर्थ-आधारित retrieval सक्षम होता है।
आउटपुट व्यवहार चुनें: नियतात्मक बनाम रचनात्मक।
कम तापमान (~0.0-0.3) → केंद्रित, दोहराने योग्य। उच्च तापमान (~0.7-1.0) → विविध, रचनात्मक। वर्गीकरण या extraction के लिए लगभग-0 का उपयोग करें।
क्यों: तापमान सैंपलिंग से पहले संभावना वितरण को स्केल करता है; कम मान शीर्ष टोकन पर द्रव्यमान केंद्रित करते हैं।
तापमान से परे उम्मीदवार टोकन पूल को सीमित करें।
Top-k सबसे संभावित k टोकन रखता है; top-p (न्यूक्लियस) सबसे छोटा सेट रखता है जिसकी संचयी संभावना p तक पहुँचती है।
क्यों: Top-p उम्मीदवार सेट को वितरण आकार के अनुकूल बनाता है; top-k आत्मविश्वास की परवाह किए बिना निश्चित-चौड़ाई वाला होता है।
पहचानें कि LLM बिना लेबल वाले टेक्स्ट से कैसे सीखते हैं।
सेल्फ-सुपरवाइज़्ड लर्निंग — अगला-टोकन (कॉज़ल) या मास्क्ड-टोकन प्रेडिक्शन टेक्स्ट से ही लेबल बनाता है, कोई मानवीय एनोटेशन नहीं।
क्यों: यह वह है जो LLM को इंटरनेट-स्केल कॉर्पोरा पर बिना मैनुअल लेबलिंग के प्रशिक्षित होने देता है।
वास्तुकला को कार्य परिवार से मिलाएं।
जनरेशन → decoder-only (GPT-style)। समझ/वर्गीकरण → encoder-only (BERT-style)। Seq-to-seq अनुवाद/सारांश → encoder-decoder (T5-style)।
क्यों: Decoder-only मॉडल बाएं से दाएं भविष्यवाणी करते हैं; एन्कोडर द्विदिशात्मक संदर्भ देखते हैं, जो प्रतिनिधित्व कार्यों के लिए बेहतर है।
एक बेस मॉडल को निर्देशों का पालन करने और सहायक, सुरक्षित उत्तरों को प्राथमिकता देने के लिए बनाएं।
Instruction tuning जिसके बाद RLHF जैसे अलाइनमेंट — मानवीय प्राथमिकता रैंकिंग से reinforcement learning।
क्यों: एक कच्चा प्री-ट्रेन्ड मॉडल टेक्स्ट की भविष्यवाणी करता है; अलाइनमेंट इसे इच्छित assistant व्यवहार की ओर निर्देशित करता है।
मॉडल आत्मविश्वास से भरे लेकिन मनगढ़ंत तथ्य बताता है।
मतिभ्रम। RAG के साथ ग्राउंडिंग करके, तापमान कम करके, स्रोतों का हवाला देकर, और guardrails के साथ-साथ उच्च-दांव वाले आउटपुट के लिए मानवीय समीक्षा जोड़कर इसे कम करें।
क्यों: LLM प्रशंसनीय टोकन की भविष्यवाणी करते हैं, न कि सत्यापित तथ्यों की; ग्राउंडिंग गुम हुए सबूत प्रदान करती है।
मॉडल के आकार को प्रशिक्षण डेटा के आकार से अलग करें।
पैरामीटर = सीखे गए वज़न (मॉडल क्षमता)। टोकन = प्रशिक्षण टेक्स्ट की मात्रा। दोनों स्केलिंग नियमों के तहत क्षमता को स्केल करते हैं।
क्यों: बहुत कम टोकन पर अंडर-ट्रेन किया गया एक बड़ा मॉडल एक छोटे, अच्छी तरह से प्रशिक्षित मॉडल से खराब प्रदर्शन करता है (चिंचिला अंतर्दृष्टि)।
एक LLM जीवनचक्र के दो GPU-भारी चरणों को अलग करें।
प्रशिक्षण डेटा से वज़न अपडेट करता है (एक-बार, बैच)। अनुमान आउटपुट उत्पन्न करने के लिए जमे हुए मॉडल को चलाता है (चल रहा, लेटेंसी-संवेदनशील)।
क्यों: अनुकूलन उपकरण भिन्न होते हैं: प्रशिक्षण parallelism frameworks का उपयोग करता है; अनुमान TensorRT-LLM और Triton का उपयोग करता है।
एक फ़ाइन-ट्यून्ड मॉडल प्रशिक्षण उदाहरणों को याद कर लेता है और नए इनपुट पर विफल हो जाता है।
ओवरफिटिंग। इसे अधिक/विविध डेटा, अर्ली स्टॉपिंग, कम लर्निंग रेट, कम इपॉक्स, या dropout जैसे regularization से कम करें।
क्यों: एक बड़ा ट्रेन-बनाम-वैलिडेशन अंतर का मतलब है कि मॉडल ने सामान्यीकरण योग्य पैटर्न के बजाय नॉइज़ को फिट किया।
एक OpenAI-संगत API के साथ एक अनुकूलित LLM को एक प्रोडक्शन microservice के रूप में तेज़ी से डिप्लॉय करें।
एक NVIDIA NIM microservice का उपयोग करें — एक prebuilt, containerized, TensorRT-LLM-optimized model endpoint।
क्यों: NIM मॉडल, रनटाइम और अनुकूलित इंजन को पैक करता है ताकि आप मैन्युअल TensorRT-LLM और Triton वायरिंग को छोड़ सकें।
एक inference server के पीछे batching, concurrency, और कई backends के साथ कई मॉडल सर्व करें।
NVIDIA Triton Inference Server। यह dynamic batching, model ensembles, और TensorRT/PyTorch/ONNX backends का समर्थन करता है।
क्यों: Triton एक साथ मॉडल निष्पादन और dynamic batching के माध्यम से GPU उपयोग को अधिकतम करता है।
सर्विंग से पहले NVIDIA GPUs पर LLM inference latency कम करें।
मॉडल को TensorRT-LLM के साथ कंपाइल करें — kernel fusion, quantization, in-flight batching, और KV-cache optimization।
क्यों: TensorRT-LLM कच्चे framework model को चलाने की तुलना में कहीं अधिक तेज़ी से एक अनुकूलित इंजन तैयार करता है।
NVIDIA GPUs पर बड़े पैमाने पर LLM को प्रशिक्षित करें, अनुकूलित करें या fine-tune करें।
NVIDIA NeMo framework — generative AI model बनाने, अनुकूलित करने और deploy करने के लिए end-to-end toolkit।
क्यों: NeMo data curation, training, PEFT, और alignment को एक ही stack में कवर करता है जिसे multi-GPU scaling के लिए डिज़ाइन किया गया है।
एक ऐसा ऐप बनाएं जो उन निजी दस्तावेज़ों से उत्तर देता है जिन्हें बेस मॉडल ने कभी नहीं देखा।
RAG pipeline: chunk + embed documents into a vector store, retrieve top-k by similarity at query time, and inject them into the prompt।
क्यों: Retrieval मॉडल को फिर से प्रशिक्षित किए बिना उत्तरों को वर्तमान, स्वामित्व वाले डेटा में आधार प्रदान करता है।
एक पूरी बातचीत में assistant के लहजे, भूमिका और नियमों को सीमित करें।
उपयोगकर्ता के टर्न से पहले भूमिका, बाधाओं और प्रारूप को परिभाषित करने वाला एक system prompt/message सेट करें।
क्यों: सिस्टम मैसेज टर्न भर में बना रहता है और प्रति-टर्न निर्देशों की तुलना में व्यवहार को अधिक मज़बूती से निर्देशित करता है।
बिना किसी प्रशिक्षण के एक संरचित कार्य पर सटीकता में सुधार करें।
Few-shot prompting — वास्तविक इनपुट से पहले प्रॉम्प्ट में 2-5 इनपुट/आउटपुट उदाहरण embed करें।
क्यों: In-context learning मॉडल को बिना किसी वज़न अपडेट के उदाहरणों के खिलाफ pattern-match करने देती है।
मॉडल multi-step reasoning या गणित की समस्याओं को गलत करता है।
Chain-of-thought prompting — इसे अंतिम उत्तर देने से पहले चरण-दर-चरण तर्क करने का निर्देश दें।
क्यों: मध्यवर्ती चरणों को निकालना compositional tasks पर reasoning accuracy में सुधार करता है।
LLM को बाहरी API, databases, या tools को मज़बूती से ट्रिगर करने दें।
Function/tool calling का उपयोग करें — tool schemas को परिभाषित करें; मॉडल structured arguments उत्सर्जित करता है जिसे आपका कोड निष्पादित करता है।
क्यों: Structured tool calls free-text parsing से बेहतर होते हैं, और वे agentic flows के लिए मॉडल को live systems में आधार प्रदान करते हैं।
डाउनस्ट्रीम कोड को मॉडल से सख्त JSON की आवश्यकता है।
प्रॉम्प्ट में JSON schema का अनुरोध करें और constrained/guided decoding का उपयोग करें; उपयोग करने से पहले आउटपुट को मान्य करें।
क्यों: Schema-guided decoding गलत स्वरूपित JSON को रोकता है जो parsing को तोड़ देगा।
एक chat UI को टोकन को पूर्ण होने के बाद दिखाने के बजाय जैसे ही वे उत्पन्न होते हैं, दिखाना चाहिए।
सर्विंग एंडपॉइंट से streaming (token-by-token) inference का उपयोग करें।
क्यों: Streaming कथित latency को कम करती है; NIM और Triton दोनों ही streamed responses का समर्थन करते हैं।
Retrieval, prompting, और tool चरणों को एक ही application pipeline में संयोजित करें।
Retrievers, prompts, models, और tools को जोड़ने के लिए LangChain या LlamaIndex जैसे orchestration framework का उपयोग करें।
क्यों: ये frameworks NIM/NeMo endpoints पर पुन: प्रयोज्य RAG और agent abstractions प्रदान करते हैं।
एक packaged microservice और एक हाथ से बनाए गए serving stack के बीच निर्णय लें।
तेज़ मानकीकृत deployment → NIM। डीप कस्टम backend/model logic → सीधे Triton + TensorRT-LLM।
क्यों: NIM गति के लिए configurability का त्याग करता है; कच्चा Triton serving graph का पूर्ण नियंत्रण देता है।
सीमित GPU memory पर सभी weights को छुए बिना एक बड़े मॉडल को fine-tune करें।
LoRA / PEFT — बेस weights को freeze करते हुए छोटे low-rank adapter matrices को प्रशिक्षित करें।
क्यों: LoRA trainable parameters को परिमाण के क्रम से कम करता है, इसलिए fine-tuning मामूली GPUs पर फिट बैठती है।
सबसे सीमित संभव memory budget के साथ एक बहुत बड़े मॉडल को fine-tune करें।
QLoRA — frozen base model को 4-bit तक quantize करें और उसके ऊपर LoRA adapters को प्रशिक्षित करें।
क्यों: बेस को quantize करने से LoRA अकेले की तुलना में memory और कम हो जाती है, जिससे एक GPU पर बड़े मॉडल सक्षम होते हैं।
सबसे सस्ता customization चुनें जो गुणवत्ता मानदंड को पूरा करता है।
क्रम में बढ़ाएं: prompt engineering → few-shot → RAG → LoRA fine-tuning → full fine-tuning।
क्यों: प्रत्येक चरण पर लागत और प्रयास बढ़ता है; लक्ष्य पर पहुंचने वाले पहले चरण पर रुकें।
Supervised fine-tuning के लिए सही training data shape की आवश्यकता होती है।
Instruction/response (prompt-completion) जोड़े प्रदान करें, आमतौर पर JSONL में।
क्यों: SFT मॉडल को input को desired output से map करना सिखाता है; जोड़े उस mapping को परिभाषित करते हैं।
Fine-tuning loss diverge होता है या मॉडल पिछली क्षमताओं को भूल जाता है।
Learning rate कम करें और/या epochs कम करें; catastrophic forgetting के लिए validation loss देखें।
क्यों: बहुत अधिक LR प्रशिक्षण को अस्थिर करता है और pre-trained knowledge को overwrite कर देता है।
मापें कि क्या fine-tune या prompt change ने वास्तव में मदद की।
एक validation/test set को अलग रखें जिस पर मॉडल ने कभी प्रशिक्षित नहीं किया और पहले बनाम बाद में metrics की तुलना करें।
क्यों: प्रशिक्षण डेटा पर मूल्यांकन गुणवत्ता को बढ़ा-चढ़ा कर बताता है; केवल अलग रखा गया डेटा generalization को दर्शाता है।
विभिन्न hyperparameters और डेटा के साथ कई fine-tuning run की तुलना करें।
एक experiment tracker (जैसे MLflow, Weights & Biases, TensorBoard) के साथ run, config, और metrics को लॉग करें।
क्यों: Reproducibility के लिए यह रिकॉर्ड करना आवश्यक है कि किस config ने कौन सा परिणाम उत्पन्न किया; memory scale नहीं होती है।
स्वचालित रूप से उत्पन्न-टेक्स्ट गुणवत्ता को स्कोर करें।
सारांश → ROUGE। अनुवाद → BLEU। Semantic match → BERTScore। Open-ended quality → LLM-as-judge या human eval।
क्यों: Lexical-overlap metrics अर्थ को याद करते हैं; सूक्ष्म गुणवत्ता के लिए, मानवीय या model-judge evaluation की आवश्यकता होती है।
RAG irrelevant या बहुत कम context retrieve करता है।
Chunk size/overlap, top-k, embedding model को tune करें, और re-ranking जोड़ें; generation से अलग retrieval quality को सत्यापित करें।
क्यों: अधिकांश RAG विफलताएं retrieval विफलताएं होती हैं; generator को दोषी ठहराने से पहले retrieval को ठीक करें।
तय करें कि दो prompt variants में से कौन सा बेहतर प्रदर्शन करता है।
एक निश्चित evaluation set के खिलाफ दोनों को चलाएं और metrics की तुलना करें; केवल मॉडल पर नहीं, बल्कि डेटा और prompt पर भी पुनरावृति करें।
क्यों: समान input पर नियंत्रित तुलना prompt change के प्रभाव को अलग करती है।
एक संकीर्ण कार्य पर fine-tuning के बाद मॉडल सामान्य क्षमता खो देता है।
Catastrophic forgetting। PEFT/LoRA, कम LR, कम epochs, या fine-tune set में सामान्य डेटा मिलाकर इसे कम करें।
क्यों: Adapter-based tuning बेस weights को संरक्षित करती है, जिससे मूल क्षमताओं से drift सीमित होता है।
GPU scale पर LLM training के लिए एक बड़े वेब/टेक्स्ट corpus को curate करें।
NVIDIA NeMo Curator — प्रशिक्षण डेटा के लिए GPU-त्वरित cleaning, dedup, quality filtering, और PII handling।
क्यों: डेटा गुणवत्ता मॉडल गुणवत्ता को बढ़ाती है; Curator curation को scale करता है जो CPU पर असंभव होगा।
प्रशिक्षण corpus में कई near-duplicate documents होते हैं।
Training से पहले deduplicate (exact और fuzzy/near-dup) हटाएँ।
क्यों: Duplicates compute बर्बाद करते हैं, मॉडल को दोहराए गए सामग्री की ओर पक्षपाती करते हैं, और memorization/leakage का जोखिम बढ़ाते हैं।
RAG retrieval के लिए documents को विभाजित करें।
मामूली overlap के साथ semantically coherent passages में chunk करें; embedding model और context budget के अनुसार आकार दें।
क्यों: Oversized chunks relevance को कम करते हैं; tiny chunks context खो देते हैं। Overlap boundary meaning को संरक्षित करता है।
कच्चा scraped text शोरगुल वाला होता है, जिसमें boilerplate, toxic, या low-quality content होती है।
कम-मूल्य वाले documents को हटाने के लिए quality और toxicity filters, language ID, और heuristics लागू करें।
क्यों: कचरा मॉडल को खराब करता है; filtering कच्चे volume जोड़ने की तुलना में downstream quality में सुधार करती है।
Semantic retrieval के लिए एक document collection तैयार करें।
एक सुसंगत embedding model के साथ प्रत्येक chunk के लिए embeddings उत्पन्न करें और उन्हें एक vector index में संग्रहीत करें।
क्यों: Query और document embeddings तुलनीय होने के लिए एक ही मॉडल से आनी चाहिए।
जांचें कि क्या कोई training set समूहों या विषयों को कम प्रतिनिधित्व करता है।
Classes, sources, और demographics में distribution का विश्लेषण करें; training से पहले अंतराल को फिर से संतुलित करें या बढ़ाएं।
क्यों: Skewed training data skewed model behavior उत्पन्न करता है; समाधान डेटा परत पर होना चाहिए।
Training या RAG डेटा में personal information हो सकती है।
डेटा तैयारी के दौरान PII का पता लगाएं और उसे redact/mask करें, इससे पहले कि वह model weights या index तक पहुँचे।
क्यों: Weights में निहित knowledge को inference पर मज़बूती से mask नहीं किया जा सकता है; PII को upstream हटाएँ।
एक LLM app को विषय पर रखें, unsafe content को ब्लॉक करें और jailbreaks को रोकें।
NVIDIA NeMo Guardrails — topic control, safety filtering, और dialog flow के लिए programmable rails।
क्यों: Guardrails अंतर्निहित मॉडल से स्वतंत्र input और output पर policy लागू करते हैं।
एक deployed assistant में confident-but-wrong answers को कम करें।
RAG के साथ responses को आधार प्रदान करें, citations की आवश्यकता करें, fact-checking rails जोड़ें, और high-stakes output के लिए humans को loop में रखें।
क्यों: Grounding सत्यापन योग्य evidence प्रदान करती है जिसे मॉडल अन्यथा आविष्कार करेगा।
User input system prompt को override करने या data को exfiltrate करने की कोशिश करता है।
गहराई में बचाव: guardrails, input/output filtering, instruction isolation, और agents के लिए least-privilege tool permissions।
क्यों: कोई एक control injection को नहीं रोकता; सीमित capabilities के साथ filtering को संयोजित करें।
एक deployed model कुछ समूहों के लिए skewed या unfair output उत्पन्न करता है।
Bias के लिए output का audit करें, training data को rebalance/augment करें, और evaluation में fairness checks जोड़ें।
क्यों: Bias आमतौर पर डेटा में उत्पन्न होता है; deployment से पहले और बाद में इसे मापें और ठीक करें।
Prompts और responses संगठन के control से बाहर नहीं जानी चाहिए।
अपने स्वामित्व वाले infrastructure पर NIM/Triton के साथ self-host करें, डेटा encrypt करें, और sensitive content को third-party APIs पर भेजने से बचें।
क्यों: On-prem या VPC deployment confidential data को trust boundary के भीतर रखता है।