LLM on kenji.blog

TinyLLaMA को ऑन-प्रिमाइसेस वातावरण में सबसे तेज़ी से ट्यून करने का तरीका

Fri, 11 Sep 2026 16:00:00 +0900

1. परिचय: अभी TinyLLaMA और ऑन-प्रिमाइसेस क्यों?

लार्ज लैंग्वेज मॉडल (LLM) का विकास अविश्वसनीय गति से आगे बढ़ रहा है, और इसके साथ, मॉडल के मापदंडों की संख्या सैकड़ों अरबों तक फैल रही है। GPT-4 और Claude 3 जैसे विशाल मॉडल बेजोड़ प्रदर्शन का दावा करते हैं, लेकिन अनुमान और प्रशिक्षण से जुड़ी गणना लागत, साथ ही बाहरी API का उपयोग करते समय सुरक्षा और डेटा गोपनीयता की चिंताएँ कंपनियों के लिए बड़ी बाधाएँ बन गई हैं। विशेष रूप से, अत्यधिक गोपनीय आंतरिक डेटा या व्यक्तिगत जानकारी से जुड़े कार्यों में, अनुपालन (जैसे GDPR और APPI) के दृष्टिकोण से सार्वजनिक क्लाउड LLM API में डेटा भेजना अक्सर अस्वीकार्य होता है।

यहीं पर स्मॉल लैंग्वेज मॉडल (SLM) और ऑन-प्रिमाइसेस वातावरण में स्थानीय संचालन सुर्खियों में आ रहे हैं। इनमें से “TinyLLaMA”, केवल 1.1B (1.1 बिलियन) मापदंडों के अपने कॉम्पैक्ट आकार के बावजूद, लगभग 3 ट्रिलियन टोकन के विशाल डेटासेट पर पूर्व-प्रशिक्षित किया गया है, और अपने वर्ग के अन्य मॉडलों की तुलना में आश्चर्यजनक प्रदर्शन प्रदान करता है।

इस लेख में, हम आपकी कंपनी के विशिष्ट कार्यों के लिए ऑन-प्रिमाइसेस वातावरण (स्थानीय सर्वर या वर्कस्टेशन) में इस TinyLLaMA को “सबसे तेज़ और अत्यधिक कुशल” तरीके से फाइन-ट्यून करने के लिए एक संपूर्ण मार्गदर्शिका प्रदान करते हैं। हम गणितीय पृष्ठभूमि, नवीनतम अनुकूलन तकनीकों और विशिष्ट PyTorch कार्यान्वयन कोड को व्यापक रूप से कवर करेंगे।

2. TinyLLaMA का आर्किटेक्चर और विशेषताएं

TinyLLaMA, Meta द्वारा विकसित LLaMA (Large Language Model Meta AI) आर्किटेक्चर का अनुसरण करता है। मापदंडों की संख्या को 1.1B तक कम करते हुए, यह LLaMA 2 के समान प्रौद्योगिकी स्टैक का उपयोग करता है, जिससे इसका इकोसिस्टम अत्यधिक संगत हो जाता है।

प्रमुख आर्किटेक्चर घटक

RMSNorm (Root Mean Square Normalization): यह एक सामान्यीकरण विधि है जो पारंपरिक LayerNorm गणनाओं से माध्य घटाव को हटा देती है, जिससे कम्प्यूटेशनल दक्षता में सुधार होता है। यह प्रशिक्षण स्थिरता बनाए रखते हुए थ्रूपुट को बढ़ाता है।
SwiGLU एक्टिवेशन फंक्शन: Feed Forward Network (FFN) में, पारंपरिक ReLU या GELU के बजाय SwiGLU को अपनाया गया है। इसे गणितीय रूप से इस प्रकार दर्शाया गया है: $$ \text{SwiGLU}(x, W, V) = \text{Swish}(xW) \otimes (xV) $$ यहां, $\otimes$ तत्व-वार गुणन (Hadamard उत्पाद) को दर्शाता है, और Swish फ़ंक्शन $\text{Swish}(z) = z \cdot \sigma(\beta z)$ है। इससे अभिव्यक्ति की क्षमता में काफी सुधार होता है।
RoPE (Rotary Position Embedding): यह एक ऐसी तकनीक है जो पूर्ण (absolute) और सापेक्ष (relative) पोजीशन एन्कोडिंग के लाभों को जोड़ती है। अनुक्रम (sequence) की लंबाई बढ़ने पर भी यह उच्च सामान्यीकरण (generalization) प्रदर्शन बनाए रखती है।
Grouped Query Attention (GQA): यह Multi-Head Attention (MHA) और Multi-Query Attention (MQA) के बीच का एक मध्यवर्ती दृष्टिकोण है, जो कुंजियों (keys) और मूल्यों (values) के हेड्स को समूहित करके मेमोरी बैंडविड्थ को बचाता है और अनुमान की गति में नाटकीय रूप से सुधार करता है।

नीचे दिया गया Mermaid आरेख TinyLLaMA के समग्र डेटा प्रवाह और Transformer ब्लॉक की संरचना को दर्शाता है।

graph TD A["इनपुट टेक्स्ट"] --> B["टोकनाइज़र (BPE)"] B --> C["एम्बेडिंग लेयर"] C --> D["ट्रांसफॉर्मर ब्लॉक्स (TinyLLaMA के लिए 22 लेयर्स)"] D --> E["RMSNorm (अंतिम)"] E --> F["लीनियर प्रोजेक्शन (वोकैब का आकार)"] F --> G["आउटपुट संभावनाएं (Softmax)"] subgraph "ट्रांसफॉर्मर ब्लॉक एनाटॉमी" D1["इनपुट हिडन स्टेट"] --> D2["RMSNorm"] D2 --> D3["ग्रुप्ड क्वेरी अटेंशन (GQA)"] D3 --> D4["रेसिडुअल ऐड"] D4 --> D5["RMSNorm"] D5 --> D6["SwiGLU FFN"] D6 --> D7["रेसिडुअल ऐड"] D7 --> D8["अगली लेयर के लिए आउटपुट"] D1 -.-> D4 D4 -.-> D7 end

3. फाइन-ट्यूनिंग में सफलता: LoRA और QLoRA

ऑन-प्रिमाइसेस वातावरण में पूर्ण-पैरामीटर फाइन-ट्यूनिंग करने के लिए, यहां तक कि 1.1B मॉडल के साथ भी, ऑप्टिमाइज़र की स्थिति और ग्रेडिएंट को बनाए रखने के लिए दसियों गीगाबाइट VRAM (वीडियो मेमोरी) की खपत होती है। सीमित संसाधनों के साथ कुशलतापूर्वक प्रशिक्षण के लिए आवश्यक PEFT (Parameter-Efficient Fine-Tuning) तकनीक “LoRA” और इसका क्वांटाइज़ेशन एक्सटेंशन “QLoRA” है।

3.1 LoRA (Low-Rank Adaptation) की गणितीय पृष्ठभूमि

LoRA एक ऐसी तकनीक है जो पूर्व-प्रशिक्षित वज़न मैट्रिक्स को स्थिर (फ़्रीज़) कर देती है और उसके वज़न अपडेट ($\Delta W$) का अनुमान दो छोटे लो-रैंक मैट्रिक्स के गुणनफल के रूप में लगाती है।

मान लें कि पूर्व-प्रशिक्षित वज़न $W_0 \in \mathbb{R}^{d \times k}$ है। पूर्ण फाइन-ट्यूनिंग में, $W_0$ को स्वयं अपडेट करके $W_0 + \Delta W$ किया जाता है, लेकिन LoRA में, अपडेट मैट्रिक्स $\Delta W$ को इस प्रकार विघटित किया जाता है:

$$ \Delta W = B \times A $$

यहां, $B \in \mathbb{R}^{d \times r}$ और $A \in \mathbb{R}^{r \times k}$, जहां $r$ एक हाइपरपैरामीटर है जिसे रैंक कहा जाता है, जो एक बहुत छोटा मान है (आमतौर पर 8, 16, 32, आदि) और $r \ll \min(d, k)$ को संतुष्ट करता है।

फॉरवर्ड पास की गणना इस प्रकार है:

$$ h = W_0 x + \Delta W x = W_0 x + B A x $$

प्रारंभिक अवस्था में, मैट्रिक्स $A$ को सामान्य वितरण (गॉसियन वितरण) का उपयोग करके यादृच्छिक रूप से प्रारंभ (initialize) किया जाता है, और मैट्रिक्स $B$ को शून्य मैट्रिक्स के साथ प्रारंभ किया जाता है। इससे यह सुनिश्चित होता है कि प्रशिक्षण की शुरुआत में $\Delta W$ शून्य है, जिससे बेस मॉडल के आउटपुट को पूरी तरह से सुरक्षित रखते हुए प्रशिक्षण शुरू किया जा सकता है।

graph LR X["इनपुट वेक्टर x"] --> W0["स्थिर पूर्व-प्रशिक्षित वज़न (W_0)"] X --> A["प्रशिक्षित करने योग्य LoRA मैट्रिक्स A (r x k)"] A --> B["प्रशिक्षित करने योग्य LoRA मैट्रिक्स B (d x r)"] W0 --> Add["वेक्टर संयोजन"] B --> Add Add --> Y["आउटपुट वेक्टर h"]

3.2 QLoRA (Quantized LoRA) का नवाचार

QLoRA LoRA के दृष्टिकोण को और आगे ले जाता है, जिसमें बेस मॉडल $W_0$ को मेमोरी में लोड करने से पहले 4-बिट परिशुद्धता (NormalFloat 4, NF4) में क्वांटाइज़ किया जाता है। इससे VRAM की खपत में काफी कमी आती है।

QLoRA में तीन महत्वपूर्ण तकनीकें शामिल हैं:

4-बिट NormalFloat (NF4) क्वांटाइज़ेशन: सामान्य वितरण का पालन करने वाले वज़न के लिए अनुकूलित एक सैद्धांतिक रूप से इष्टतम डेटा प्रकार।
डबल क्वांटाइज़ेशन: क्वांटाइज़ेशन स्थिरांक (स्केलिंग फैक्टर) को स्वयं क्वांटाइज़ करके मेमोरी की और अधिक बचत।
पेज्ड ऑप्टिमाइज़र: NVIDIA के यूनिफाइड मेमोरी फ़ीचर का उपयोग करके, VRAM कम होने पर ऑप्टिमाइज़र की स्थिति को अस्थायी रूप से CPU RAM में ले जाने का एक तंत्र।

इसके परिणामस्वरूप, फाइन-ट्यूनिंग जिसके लिए आम तौर पर 16GB से 24GB VRAM की आवश्यकता होती है, आसानी से उपभोक्ता श्रेणी के GPU (जैसे RTX 3060 12GB या RTX 4070) पर निष्पादित की जा सकती है।

4. ऑन-प्रिमाइसेस वातावरण के लिए हार्डवेयर आवश्यकताएं और सेटअप

जब QLoRA के साथ TinyLLaMA (1.1B) को ट्यून किया जाता है, तो हार्डवेयर आवश्यकताएं बहुत कम रखी जा सकती हैं।

अनुशंसित हार्डवेयर विनिर्देश

GPU: NVIDIA RTX 3060 (12GB), RTX 3090/4090 (24GB), या NVIDIA A10G/A100 आदि। यह कम से कम 8GB VRAM के साथ चलेगा, लेकिन बड़े बैच आकार को संभालने के लिए 12GB या अधिक की अनुशंसा की जाती है।
CPU: 8 या अधिक कोर वाला आधुनिक CPU (Intel Core i7/i9, AMD Ryzen 7/9)।
RAM: 32GB या अधिक (पेज्ड ऑप्टिमाइज़र का उपयोग करते समय VRAM से डेटा निकालने के लिए महत्वपूर्ण)।
स्टोरेज: NVMe SSD (डेटासेट लोड करने और मॉडल को तेज़ी से सहेजने के लिए)।

सॉफ्टवेयर वातावरण सेटअप

यहां Ubuntu 22.04 LTS वातावरण के लिए सेटअप प्रक्रिया दी गई है। यह Python 3.10 या बाद के संस्करण का उपयोग करता है।

1
2
3
4
5
6
7
8
9


# वर्चुअल एनवायरनमेंट बनाना और सक्रिय करना
python3 -m venv tinyllama_env
source tinyllama_env/bin/activate

# PyTorch इंस्टॉल करना (CUDA 12.1 के लिए)
pip install torch torchvision torchaudio --index-url https://download.pytorch.org/whl/cu121

# ट्रांसफार्मर से संबंधित लाइब्रेरी इंस्टॉल करना
pip install transformers datasets peft trl accelerate bitsandbytes

5. सबसे तेज़ ट्यूनिंग के लिए अनुकूलन तकनीकें

सिर्फ स्क्रिप्ट चलाने के अलावा, “सबसे तेज़” ट्यूनिंग पूरी करने के लिए निम्नलिखित अनुकूलन विधियों को संयोजित करना आवश्यक है।

5.1 Flash Attention 2

मानक अटेंशन तंत्र की समय और स्थान जटिलता अनुक्रम (sequence) लंबाई $N$ के लिए $O(N^2)$ होती है। Flash Attention 2 GPU के SRAM और HBM (High Bandwidth Memory) के बीच मेमोरी एक्सेस को अनुकूलित करता है, गणना की मात्रा को कम किए बिना IO अड़चनों को दूर करता है, प्रशिक्षण गति को कई गुना बढ़ाता है, और मेमोरी खपत को काफी कम करता है।

5.2 Gradient Checkpointing (ग्रेडिएंट चेकपॉइंटिंग)

यह एक ऐसी तकनीक है जहां फॉरवर्ड पास के दौरान गणना किए गए सभी मध्यवर्ती एक्टिवेशन को VRAM में सहेजने के बजाय, केवल कुछ को ही सहेजा जाता है और जब बैकवर्ड पास के दौरान आवश्यकता होती है तो उनकी पुनर्गणना की जाती है। गणना समय लगभग 20% बढ़ जाता है, लेकिन मेमोरी खपत नाटकीय रूप से कम हो जाती है, जिससे बड़े बैच आकार सेट किए जा सकते हैं और समग्र थ्रूपुट में सुधार होता है।

5.3 Mixed Precision Training (मिश्रित सटीक प्रशिक्षण) और Bfloat16

GPU के Tensor Cores का पूरा लाभ उठाने के लिए, प्रशिक्षण के दौरान गणना bfloat16 (Brain Floating Point) में की जाती है। float16 की तुलना में, घातांक (exponent) की बिट लंबाई float32 के समान है, इसलिए ओवरफ्लो और अंडरफ्लो का जोखिम बेहद कम है, जिससे स्थिर प्रशिक्षण सुनिश्चित होता है।

6. अभ्यास: TinyLLaMA के लिए QLoRA फाइन-ट्यूनिंग कोड

अब, आइए सबसे तेज़ ट्यूनिंग के लिए एक PyTorch स्क्रिप्ट देखें जिसमें उपरोक्त सभी अनुकूलन शामिल हैं। यहाँ, हम Hugging Face की trl (Transformer Reinforcement Learning) लाइब्रेरी से SFTTrainer का उपयोग करेंगे।

6.1 डेटासेट तैयार करना और मॉडल लोड करना

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35


import torch
from datasets import load_dataset
from transformers import (
 AutoModelForCausalLM,
 AutoTokenizer,
 BitsAndBytesConfig,
 TrainingArguments
)
from peft import LoraConfig, get_peft_model, prepare_model_for_kbit_training
from trl import SFTTrainer

# 1. मॉडल और टोकनाइज़र निर्दिष्ट करना
model_id = "TinyLlama/TinyLlama-1.1B-Chat-v1.0"

# 2. QLoRA के लिए 4-बिट क्वांटाइज़ेशन कॉन्फ़िगरेशन
bnb_config = BitsAndBytesConfig(
 load_in_4bit=True,
 bnb_4bit_use_double_quant=True,
 bnb_4bit_quant_type="nf4",
 bnb_4bit_compute_dtype=torch.bfloat16 # गणना bfloat16 में की जाती है
)

# 3. मॉडल लोड करना (Flash Attention 2 सक्षम करना)
print("मॉडल लोड हो रहा है...")
model = AutoModelForCausalLM.from_pretrained(
 model_id,
 quantization_config=bnb_config,
 device_map="auto",
 use_flash_attention_2=True # सबसे तेज़ गति की कुंजी
)

# 4. टोकनाइज़र लोड करना
tokenizer = AutoTokenizer.from_pretrained(model_id, trust_remote_code=True)
tokenizer.pad_token = tokenizer.eos_token
tokenizer.padding_side = "right" # fp16/bf16 प्रशिक्षण के दौरान बग से बचने के लिए "right" पर सेट करें

6.2 LoRA अडैप्टर लागू करना और डेटासेट को फ़ॉर्मेट करना

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33


# 5. k-बिट प्रशिक्षण की तैयारी करना और ग्रेडिएंट चेकपॉइंटिंग सक्षम करना
model.gradient_checkpointing_enable()
model = prepare_model_for_kbit_training(model)

# 6. LoRA सेटिंग्स
peft_config = LoraConfig(
 r=16, # रैंक
 lora_alpha=32, # स्केलिंग फैक्टर
 lora_dropout=0.05,
 bias="none",
 task_type="CAUSAL_LM",
 target_modules=["q_proj", "k_proj", "v_proj", "o_proj", "gate_proj", "up_proj", "down_proj"] # सभी लीनियर लेयर्स को लक्षित करने से प्रदर्शन में सुधार होता है
)

model = get_peft_model(model, peft_config)
model.print_trainable_parameters()
# आउटपुट उदाहरण: trainable params: 14,286,848 || all params: 1,114,335,232 || trainable%: 1.282%

# 7. डेटासेट लोड करना (यहां हम उदाहरण के रूप में जापानी निर्देश डेटासेट का उपयोग कर रहे हैं)
# वास्तव में, आप ऑन-प्रिमाइसेस निजी JSONL फ़ाइलें आदि लोड करेंगे
dataset = load_dataset("kunishou/databricks-dolly-15k-ja", split="train")

def format_instruction(sample):
 """
 स्ट्रिंग को ChatML फॉर्मेट या प्रॉम्ट टेम्प्लेट में फ़ॉर्मेट करें
 """
 prompt = f"<|im_start|>user\n{sample['instruction']}"
 if sample.get("input", "") != "":
 prompt += f"\n{sample['input']}"
 prompt += f"<|im_end|>\n<|im_start|>assistant\n{sample['output']}<|im_end|>"
 return {"text": prompt}

dataset = dataset.map(format_instruction)

6.3 प्रशिक्षण निष्पादित करना

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36


# 8. प्रशिक्षण तर्क (arguments) सेट करना
training_args = TrainingArguments(
 output_dir="./tinyllama-lora-output",
 per_device_train_batch_size=8, # यदि VRAM की अनुमति हो तो बढ़ाएं
 gradient_accumulation_steps=2, # प्रभावी बैच आकार = 8 * 2 = 16
 optim="paged_adamw_32bit", # पेज्ड ऑप्टिमाइज़र के साथ VRAM की बचत
 save_steps=100,
 logging_steps=10,
 learning_rate=2e-4,
 fp16=False,
 bf16=True, # मिश्रित सटीक प्रशिक्षण (bfloat16)
 max_grad_norm=0.3,
 max_steps=500, # परीक्षण के लिए 500 कदम। उत्पादन में इपोक (epochs) की संख्या निर्दिष्ट करें
 warmup_ratio=0.03,
 group_by_length=True,
 lr_scheduler_type="cosine",
)

# 9. SFTTrainer का उपयोग करके प्रशिक्षण शुरू करना
trainer = SFTTrainer(
 model=model,
 train_dataset=dataset,
 peft_config=peft_config,
 dataset_text_field="text",
 max_seq_length=1024, # अपेक्षित इनपुट लंबाई के अनुसार समायोजित करें
 tokenizer=tokenizer,
 args=training_args,
)

print("प्रशिक्षण शुरू हो रहा है...")
trainer.train()

# 10. LoRA अडैप्टर को सहेजना
trainer.model.save_pretrained("./tinyllama-lora-final")
tokenizer.save_pretrained("./tinyllama-lora-final")
print("प्रशिक्षण पूरा हुआ और मॉडल सहेज लिया गया।")

7. प्रदर्शन मूल्यांकन और समस्या निवारण

ऑन-प्रिमाइसेस वातावरण में प्रशिक्षण चलाते समय आने वाली सामान्य समस्याएं और उनके समाधान।

OOM (Out Of Memory) होता है:
- per_device_train_batch_size को 1 पर कम करें।
- प्रभावी बैच आकार को बनाए रखने के लिए gradient_accumulation_steps बढ़ाएं।
- max_seq_length को 2048 से 1024 या 512 तक कम करें।
Loss कम नहीं हो रहा है या डाइवर्ज हो रहा है:
- लर्निंग रेट (learning_rate) बहुत अधिक हो सकता है। इसे 2e-4 से घटाकर लगभग 5e-5 करने का प्रयास करें।
- यदि Bfloat16 के बजाय Float16 का उपयोग किया जा रहा है, तो ग्रेडिएंट अंडरफ्लो हो सकता है। सुनिश्चित करें कि bf16=True सेट है।
अनुमान के दौरान रहस्यमय स्ट्रिंग्स उत्पन्न होती हैं:
- सुनिश्चित करें कि padding_side="right" सही ढंग से सेट है। साथ ही, जांचें कि डेटासेट फ़ॉर्मेट (जैसे <|im_start|> विशेष टोकन) बेस मॉडल के पूर्व-प्रशिक्षण के साथ संगत है या नहीं।

8. ट्यूनिंग के बाद मॉडल की तैनाती (Deployment)

ट्यूनिंग पूरी होने के बाद, जो सहेजा जाता है वह “संपूर्ण बेस मॉडल” नहीं है, बल्कि केवल कुछ MB से दसियों MB का “LoRA अडैप्टर (अंतर वज़न)” है। अनुमान को तेज़ी से निष्पादित करने के लिए, आपको इस LoRA वज़न को मूल बेस मॉडल के साथ मर्ज (एकीकृत) करना होगा और इसे एकल मॉडल के रूप में निर्यात करना होगा।

मॉडल मर्जिंग स्क्रिप्ट

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19


import torch
from peft import AutoPeftModelForCausalLM
from transformers import AutoTokenizer

output_dir = "./tinyllama-lora-final"

# FP16/BF16 में मॉडल और अडैप्टर लोड करें
model = AutoPeftModelForCausalLM.from_pretrained(
 output_dir,
 device_map="auto",
 torch_dtype=torch.bfloat16
)
tokenizer = AutoTokenizer.from_pretrained(output_dir)

# वज़न मर्ज करें और सहेजें
merged_model = model.merge_and_unload()
merged_model.save_pretrained("./tinyllama-merged", safe_serialization=True)
tokenizer.save_pretrained("./tinyllama-merged")
print("मॉडल को सफलतापूर्वक मर्ज और सहेजा गया!")

vLLM के साथ अति-तीव्र अनुमान सर्वर शुरू करना

ऑन-प्रिमाइसेस डिप्लॉयमेंट में अनुमान गति (टोकन प्रति सेकंड) को अधिकतम करने के लिए, हम Hugging Face की मानक pipeline के बजाय vLLM या TGI (Text Generation Inference) का उपयोग करने की दृढ़ता से अनुशंसा करते हैं। vLLM GPU मेमोरी विखंडन को रोकने के लिए PagedAttention तकनीक का उपयोग करता है और समवर्ती अनुरोध प्रसंस्करण क्षमता में नाटकीय रूप से सुधार करता है।

नीचे दिया गया Mermaid आरेख प्रशिक्षण से लेकर अनुमान सर्वर परिनियोजन तक की पाइपलाइन को दर्शाता है।

graph TD A["कच्चा निजी डेटा"] --> B["प्रीप्रोसेसिंग और फ़ॉर्मेटिंग (JSONL)"] B --> C["QLoRA फाइन-ट्यूनिंग (SFTTrainer)"] C --> D["LoRA अडैप्टर वज़न (.safetensors)"] D --> E["बेस TinyLLaMA 1.1B के साथ मर्ज करें"] E --> F["मर्ज किया गया मॉडल"] F --> G["vLLM सर्वर के माध्यम से डिप्लॉय करें"] G --> H["API एंडपॉइंट / UI (उदा. चैटबॉट)"]

vLLM का उपयोग करके API सर्वर शुरू करना निम्नलिखित एकल कमांड के साथ पूरा किया जा सकता है:

1
2
3
4
5
6


python -m vllm.entrypoints.openai.api_server \
 --model ./tinyllama-merged \
 --host 0.0.0.0 \
 --port 8000 \
 --max-model-len 2048 \
 --dtype bfloat16

इसके साथ, आपके ऑन-प्रिमाइसेस वातावरण में एक OpenAI API-संगत एंडपॉइंट बनाया जाता है, जिससे आप सुरक्षित और तेज़ी से स्थानीय AI का उपयोग कर सकते हैं।

9. निष्कर्ष

इस लेख में, हमने बताया है कि ऑन-प्रिमाइसेस वातावरण में सबसे तेज़ और मेमोरी-कुशल तरीके से “TinyLLaMA” को कैसे फाइन-ट्यून किया जाए, जो कि 1.1B मापदंडों के साथ एक हल्का लेकिन उच्च प्रदर्शन करने वाला मॉडल है।

LoRA / QLoRA उपभोक्ता-ग्रेड GPU पर भी पूर्ण विकसित LLM ट्यूनिंग को सक्षम बनाता है।
Flash Attention 2 और Gradient Checkpointing का पूरा उपयोग करके, प्रशिक्षण समय और VRAM खपत को सीमा तक अनुकूलित किया जाता है।
vLLM का उपयोग करके डिप्लॉयमेंट उत्पादन वातावरण में भी उच्च थ्रूपुट प्राप्त करता है।

ऑन-प्रिमाइसेस स्थानीय LLM का संचालन न केवल डेटा गोपनीयता की रक्षा करता है, बल्कि कम लागत पर विशिष्ट डोमेन (कानूनी, चिकित्सा, आंतरिक कंपनी नियम, आदि) के अनुरूप विशेष AI बनाने के लिए सबसे मजबूत हथियार बन जाता है। कृपया इस मार्गदर्शिका को संदर्भ के रूप में उपयोग करें और अपना स्वयं का समर्पित TinyLLaMA विकसित करने का प्रयास करें।

C++ के साथ छोटे AI मॉडल (जैसे TinyLLaMA) विकसित करने की प्रक्रिया

Fri, 11 Sep 2026 14:00:00 +0900

C++ के साथ छोटे AI मॉडल (जैसे TinyLLaMA) विकसित करने की प्रक्रिया

हाल के वर्षों में, स्थानीय वातावरण में बड़े भाषा मॉडल (LLM) चलाने में रुचि तेजी से बढ़ी है। विशेष रूप से, TinyLLaMA (1.1B पैरामीटर) जैसे छोटे मॉडल सीमित संसाधनों वाले एज डिवाइस और सामान्य लैपटॉप (Windows वातावरण सहित) पर भी व्यावहारिक गति से अनुमान लगाने में सक्षम हैं। जहाँ Python और PyTorch का उपयोग करके विकास मुख्यधारा है, वहीं जब अंतिम प्रदर्शन और मेमोरी दक्षता की बात आती है, तो C++ और C-आधारित टेंसर लाइब्रेरी “ggml” का संयोजन वास्तविक मानक बन गया है।

इस लेख में, हम C++ का उपयोग करके TinyLLaMA को लोड करने और पाठ निर्माण के लिए एक अनुमान इंजन को शून्य से बनाने (या मौजूदा llama.cpp की आंतरिक संरचना को गहराई से समझने) के लिए एक बहुत ही विस्तृत विकास प्रक्रिया की व्याख्या करेंगे।

1. C++ और ggml ही क्यों?

AI के प्रशिक्षण चरण में, Python अपने लचीलेपन और समृद्ध इकोसिस्टम के कारण अत्यधिक लाभप्रद है। हालाँकि, परिनियोजन (डिप्लॉयमेंट) या “अनुमान (Inference)” के चरण में, निम्नलिखित कारणों से C++ एक शक्तिशाली विकल्प बन जाता है:

ओवरहेड में कमी: Python के ग्लोबल इंटरप्रेटर लॉक (GIL) और रनटाइम ओवरहेड को पूरी तरह से समाप्त किया जा सकता है।
मेमोरी दक्षता और एरिना एलोकेशन: चूँकि मेमोरी के आवंटन और मुक्ति को मैन्युअल रूप से नियंत्रित किया जा सकता है, इसलिए गार्बेज कलेक्शन के कारण होने वाले अप्रत्याशित स्पाइक्स को रोका जा सकता है।
हार्डवेयर तक सीधी पहुँच: AVX-512, AVX2, और ARM NEON जैसे SIMD इंट्रिंसिक्स (Intrinsics) को सीधे कॉल किया जा सकता है, जिससे CPU की गणना क्षमता को अधिकतम किया जा सकता है।
निर्भरता का उन्मूलन: ggml शून्य-निर्भरता (Zero dependencies) वाली एक C/C++ लाइब्रेरी है, और इसे केवल एक कंपाइलर के साथ Windows पर MSVC वातावरण में भी आसानी से बनाया (बिल्ड किया) जा सकता है।

2. वास्तुकला का समग्र चित्र (आर्किटेक्चर ओवरव्यू)

संपूर्ण अनुमान पाइपलाइन का प्रवाह नीचे दिए गए Mermaid आरेख में दिखाया गया है। यह उपयोगकर्ता के इनपुट पाठ से शुरू होकर अंततः अगले टोकन के उत्पन्न होने तक की एक श्रृंखला है।

graph TD A["उपयोगकर्ता इनपुट पाठ"] --> B["BPE टोकनाइज़र"] B --> C["टोकन आईडी एरे"] C --> D["एम्बेडिंग लेयर लुकअप"] D --> E["ट्रांसफॉर्मर ब्लॉक्स"] E --> F["RMSNorm"] F --> G["LM हेड लेयर"] G --> H["लॉजिट्स एरे"] H --> I["सैंपलर मॉड्यूल"] I --> J["अगला टोकन आईडी"] J --> K["डिटोकनाइज़र"] K --> L["आउटपुट टेक्स्ट चंक"] J -.-> |"संदर्भ में जोड़ें"| C

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

3. मॉडल प्रारूप और मेमोरी मैपिंग (mmap)

विशाल न्यूरल नेटवर्क के वेट्स (weights) को संभालने में सबसे बड़ी बाधा डिस्क I/O और मेमोरी की खपत है। C++ कार्यान्वयन में इसे मेमोरी मैपिंग (mmap) से हल किया जाता है।

3.1 मेमोरी मैपिंग का तंत्र और Windows में कार्यान्वयन

mmap का उपयोग करने से, फ़ाइल की सामग्री को सीधे प्रक्रिया के वर्चुअल मेमोरी स्पेस में मैप किया जा सकता है।

ज़ीरो-कॉपी (Zero-copy): डेटा सीधे डिस्क से कर्नेल के पेज कैश में पढ़ा जाता है, जिससे यूज़र स्पेस में कोई अतिरिक्त कॉपी नहीं होती।
ऑन-डिमांड लोड (Page Fault): जब CPU वास्तव में उस मेमोरी एड्रेस तक पहुँचता है, तभी एक पेज फॉल्ट होता है, और केवल आवश्यक चंक (आमतौर पर 4KB) भौतिक मेमोरी में लोड होता है।

Windows वातावरण में, POSIX के mmap के बजाय Win32 API के CreateFileMapping और MapViewOfFile का उपयोग किया जाता है।

sequenceDiagram participant OS["Windows OS"] participant RAM["भौतिक मेमोरी"] participant App["C++ एप्लिकेशन"] App->>OS: "CreateFileMapping / MapViewOfFile" OS-->>App: "वर्चुअल मेमोरी एड्रेस पॉइंटर" App->>App: "पॉइंटर पर टेंसर डेटा पढ़ें" OS->>RAM: "पेज फॉल्ट / डिस्क से पेज लोड करें" RAM-->>App: "SIMD गणना के लिए डेटा तैयार है"

3.2 GGUF प्रारूप की बाइनरी संरचना

Hugging Face जैसे प्लेटफार्मों से .safetensors प्रारूप से परिवर्तित GGUF (GPT-Generated Unified Format) अनुमान के लिए अंतिम प्रारूप है। इसका एक सख्त बाइनरी लेआउट है जैसा कि नीचे दिया गया है:

मैजिक बाइट्स (Magic Bytes): 0x46554747 (GGUF)।
संस्करण (Version): प्रारूप का संस्करण क्रमांक।
टेंसर गणना और मेटाडेटा गणना: टेंसर की संख्या और मेटाडेटा के की-वैल्यू पेयर की संख्या।
मेटाडेटा (Key-Value Pairs): स्ट्रिंग लेंथ प्रीफिक्स के साथ की (Key), और टाइप की गई वैल्यू।
टेंसर इन्फो (Tensor Info): प्रत्येक टेंसर का नाम, आयामों की संख्या, डेटा प्रकार (FP16, Q4_K आदि), और फ़ाइल के भीतर ऑफ़सेट स्थिति।
पैडिंग (Padding): पैडिंग डाली जाती है ताकि टेंसर डेटा एक विशिष्ट सीमा (आमतौर पर 32 बाइट्स या 64 बाइट्स) पर संरेखित (aligned) हो। यह SIMD निर्देशों (विशेष रूप से AVX) में उच्च गति मेमोरी एक्सेस के लिए आवश्यक है।
टेंसर डेटा: संरेखित वास्तविक वेट (weight) डेटा एरे।

4. TinyLLaMA का गणितीय आधार और C++ एल्गोरिदम

TinyLLaMA दक्षता के लिए कई उन्नत आर्किटेक्चरल तकनीकों को शामिल करता है। C++ में इन्हें सही ढंग से लागू करने के लिए हम गणितीय अभिव्यक्तियों की व्याख्या करेंगे।

4.1 RMSNorm (Root Mean Square Normalization)

LayerNorm से माध्य (mean) की सेंटरिंग को हटाकर और केवल वेरिएंस स्केलिंग करके गणना लागत को कम किया जाता है।

$$ \text{RMSNorm}(x) = \frac{x}{\sqrt{\frac{1}{d}\sum_{i=1}^{d} x_i^2 + \epsilon}} \odot \gamma $$

$d$ आयामों की संख्या है, $\gamma$ सीखा हुआ स्केलिंग टेंसर है। C++ में इसे लागू करते समय, एरे के वर्ग का योग पहले AVX2 के _mm256_fmadd_ps आदि के साथ उच्च गति से गणना किया जाता है, और फिर व्युत्क्रम वर्गमूल (जैसे _mm256_rsqrt_ps निर्देश) से गुणा करके इसे अनुकूलित किया जाता है।

4.2 RoPE (Rotary Position Embedding)

यह एक ऐसी तकनीक है जो टेंसर स्पेस में रोटेशन (Rotate) के रूप में टोकन की स्थितिगत जानकारी लागू करती है। इसे जटिल संख्या तल (complex plane) पर रोटेशन माना जा सकता है, और वेक्टर $x$ के आसन्न आयाम जोड़े $(x_1, x_2)$ पर निम्नलिखित रोटेशन लागू किया जाता है।

$$ \text{RoPE}(x, m) = \begin{pmatrix} x_{1} \cos(m\theta) - x_{2} \sin(m\theta) \\ x_{1} \sin(m\theta) + x_{2} \cos(m\theta) \end{pmatrix} $$

यहाँ, $m$ टोकन का पूर्ण स्थिति सूचकांक है, और $\theta$ पूर्व-गणना की गई मूल आवृत्ति है। ggml में, अनुमान ग्राफ के निर्माण के दौरान ggml_rope ऑपरेटर जोड़ने से यह समानांतर रूप से निष्पादित होता है।

4.3 Grouped-Query Attention (GQA)

सामान्य Multi-Head Attention (MHA) में, Query, Key और Value प्रत्येक के लिए समान संख्या में हेड्स होते हैं। हालाँकि, TinyLLaMA मेमोरी बैंडविड्थ और KV कैश खपत को भारी मात्रा में कम करने के लिए Grouped-Query Attention (GQA) का उपयोग करता है।

$$ \text{Attention}(Q, K, V) = \text{softmax}\left(\frac{Q K^T}{\sqrt{d_k}}\right) V $$

GQA में, कई Query हेड्स एक ही Key/Value हेड साझा shared करते हैं। C++ कार्यान्वयन में, मैट्रिक्स गुणा ggml_mul_mat निष्पादित करने से पहले, Query की संख्या से मेल खाने के लिए KV टेंसर को ब्रॉडकास्ट करने की आवश्यकता होती है।

4.4 SwiGLU एक्टिवेशन फ़ंक्शन

Feed-Forward Network (FFN) लेयर में, GELU के बजाय SwiGLU का उपयोग किया जाता है।

$$ \text{SwiGLU}(x) = \text{Swish}(x W_{\text{gate}}) \otimes (x W_{\text{up}}) $$ $$ \text{Swish}(z) = z \cdot \sigma(z) = z \cdot \frac{1}{1 + e^{-z}} $$

कम्प्यूटेशन ग्राफ में, इसे ggml_silu ऑपरेटर और ggml_mul के संयोजन से दर्शाया जाता है।

5. ggml के साथ कम्प्यूटेशन ग्राफ का निर्माण और मेमोरी प्रबंधन

ggml “Define-and-Run” दृष्टिकोण अपनाता है, जहाँ यह अनुमान के लिए एक स्थिर कम्प्यूटेशन ग्राफ बनाता है और बाद में उसका मूल्यांकन (evaluate) करता है।

5.1 ggml_context और एरिना एलोकेटर

ggml की सबसे अनूठी विशेषता “एरिना एलोकेशन” है, जो अनुमान लूप के भीतर कोई डायनामिक मेमोरी आवंटन (malloc या new) नहीं करता है। प्रारंभिकरण के दौरान, एक विशाल निरंतर मेमोरी क्षेत्र (एरिना) सुरक्षित किया जाता है, और जब भी ggml_new_tensor आदि को कॉल किया जाता है, तो इस क्षेत्र का पॉइंटर बढ़ा (increment) दिया जाता है। एक अनुमान चरण के पूरा होने के बाद, आवंटन पॉइंटर को प्रारंभिक स्थिति में रीसेट करने से, अगले अनुमान चरण के लिए मेमोरी आवंटन तुरंत पूरा हो जाता है।

5.2 ग्राफ निर्माण का विशिष्ट उदाहरण

प्रत्येक अनुमान चरण के लिए, मेमोरी में निम्नलिखित कम्प्यूटेशन ग्राफ बनाया जाता है।

graph TD A["टोकन इनपुट आईडी"] --> B["एम्बेड लुकअप"] B --> C["ggml_rms_norm"] C --> D["Q / K / V प्रोजेक्शन्स"] D --> E["ggml_rope पोजीशनल"] E --> F["KV कैश स्टोर"] E --> G["KV कैश लोड"] G --> H["सेल्फ अटेंशन"] H --> I["स्केल और सॉफ्टमैक्स"] I --> J["अटेंशन आउटपुट"] J --> K["आउट प्रोजेक्शन"] K --> L["अवशिष्ट जोड़ें (Add Residual)"]

6. क्वांटाइज़ेशन (Quantization) और Windows / SIMD ऑप्टिमाइज़ेशन

TinyLLaMA (1.1B) को FP16 में सँभालने के लिए लगभग 2.2GB मेमोरी की आवश्यकता होती है, लेकिन 4-बिट क्वांटाइज़ेशन (जैसे Q4_K) के साथ इसे नाटकीय रूप से लगभग 600MB तक संपीड़ित किया जा सकता है।

6.1 ब्लॉक क्वांटाइज़ेशन आर्किटेक्चर

ggml पूरे टेंसर को एक साथ क्वांटाइज़ करने के बजाय इसे “ब्लॉक” के आधार पर करता है। Q4_0 प्रारूप में, 32 FP16 मानों को एक ब्लॉक में समूहीकृत किया जाता है।

स्केल फैक्टर: 1 FP16 मान (2 बाइट्स)
क्वांटाइज़्ड डेटा: 32 4-बिट मान (16 बाइट्स) यह स्थानीय आउटलायर्स के प्रभाव को कम करता है।

6.2 AVX2 के साथ डॉट उत्पाद का त्वरण

Windows वातावरण में नवीनतम x86 CPU के लिए बिल्ड करते समय, /arch:AVX2 जैसे कंपाइलर फ्लैग्स का उपयोग करके SIMD प्रोसेसिंग निम्नलिखित प्रवाह में की जाती है:

लोड: मेमोरी से 4-बिट क्वांटाइज़्ड डेटा को 256-बिट AVX रजिस्टर में लोड करना।
विस्तार और अनपैक: बिट मास्क और शिफ्ट ऑपरेशंस का उपयोग करके 4-बिट मानों को Int8 या Int16 में विस्तारित करना।
डीक्वांटाइज़ेशन: फ्लोटिंग पॉइंट में बदलने के लिए स्केल फैक्टर से गुणा करना।
FMA ऑपरेशंस: एक्टिवेशन मानों और _mm256_fmadd_ps (Fused Multiply-Add) के साथ समानांतर में मल्टीप्लाई-ऐड (multiply-add) ऑपरेशंस निष्पादित करना।

7. KV कैश कार्यान्वयन का विवरण

ऑटो-रिग्रेसिव जनरेशन में, पिछले टोकनों के Key और Value की गणना को छोड़ने के लिए “KV कैश” एक आवश्यक विशेषता है।

C++ में इसे लागू करते समय मुख्य बिंदु इस प्रकार हैं:

टेंसर का पूर्व-आवंटन: KV कैश के लिए अधिकतम संदर्भ लंबाई (उदा: 2048 टोकन) के लिए एक विशाल टेंसर को इनिशियलाइज़ किया जाता है (FP16 अनुशंसित है)।
ऑफ़सेट कॉपी: जब टोकन स्थिति $N$ के लिए गणना की जाती है, तो उस चरण पर प्राप्त K और V वेक्टर्स को ggml_cpy आदि का उपयोग करके KV कैश टेंसर की $N$-वीं पंक्ति में स्टोर किया जाता है।
अटेंशन के दौरान व्यू बनाना: अटेंशन की गणना करते समय, एक “व्यू (view)” बनाया जाता है जो केवल 0 से $N$वें टोकन भाग को इंगित करता है और उसे मैट्रिक्स गुणन में पास किया जाता है।

8. BPE टोकनाइज़र और डिकोडिंग

इनपुट स्ट्रिंग को UTF-8 बाइट्स के अनुक्रम के रूप में माना जाता है और पूर्वनिर्धारित शब्दावली के विरुद्ध मिलान किया जाता है। C++ में, शब्दावली खोज को तेज करने के लिए ट्राई ट्री (प्रिफिक्स ट्री) या प्राथमिकता कतारों (priority queues) का उपयोग करने वाले एल्गोरिदम लागू किए जाते हैं।

LM Head से आउटपुट लॉजिट्स (logits) से, संभावितताओं को Temperature पैरामीटर का उपयोग करके स्केल किया जाता है, उम्मीदवारों को Top-K निष्कर्षण या Top-P (न्यूक्लियस सैंपलिंग) विधियों का उपयोग करके कम किया जाता है, और यादृच्छिक संख्याओं का उपयोग करके अंतिम अगला टोकन निर्धारित किया जाता है।

9. C++ प्रोजेक्ट सेट अप करना (Windows / PowerShell वातावरण)

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18


cmake_minimum_required(VERSION 3.14)
project(TinyLLaMACpp)

set(CMAKE_CXX_STANDARD 17)

# Windows (MSVC) के लिए ऑप्टिमाइज़ेशन और AVX2 फ्लैग की सेटिंग
if(MSVC)
 add_compile_options(/O2 /arch:AVX2 /fp:fast)
 add_link_options(/STACK:8388608)
else()
 add_compile_options(-O3 -march=native -ffast-math)
endif()

add_library(ggml OBJECT ggml/ggml.c ggml/ggml-alloc.c)
target_compile_definitions(ggml PRIVATE GGML_USE_AVX2 GGML_USE_F16C GGML_USE_FMA)

add_executable(main main.cpp)
target_link_libraries(main ggml)

PowerShell में बिल्ड कमांड का उदाहरण:

1
2
3
4


mkdir build
cd build
cmake .. -G "Visual Studio 17 2022" -A x64
cmake --build . --config Release

10. निष्कर्ष

C++ और ggml का उपयोग करके TinyLLaMA जैसे छोटे AI मॉडल के लिए शून्य से एक अनुमान इंजन लागू करना डीप लर्निंग के ब्लैक बॉक्स को खोलने और निम्न-स्तरीय हार्डवेयर नियंत्रण की सुंदरता सीखने का एक उत्कृष्ट अवसर है। मेमोरी मैपिंग का उपयोग करके ज़ीरो-कॉपी लोडिंग, SIMD ऑप्टिमाइज़ेशन और KV कैश के निर्माण जैसी सिस्टम प्रोग्रामिंग के सार का आनंद लेते हुए, आइए एज AI के भविष्य का मार्ग प्रशस्त करें।

【RAG इम्प्लीमेंटेशन गाइड】 लोकल AI को अपने दस्तावेज़ कैसे पढ़ाएं

Fri, 11 Sep 2026 13:00:00 +0900

परिचय

हाल के वर्षों में, लार्ज लैंग्वेज मॉडल (LLM) का विकास उल्लेखनीय रहा है, और ChatGPT और Claude जैसी कई AI हमारी जिंदगी और काम का अहम हिस्सा बन गई हैं। हालाँकि, सामान्य LLMs की एक स्पष्ट कमजोरी होती है। वह यह है कि वे केवल “ट्रेनिंग के समय उपलब्ध सार्वजनिक जानकारी” ही जानते हैं। स्वाभाविक रूप से, वे कंपनी के नियमों, व्यक्तिगत नोट्स, और अप्रकाशित प्रोजेक्ट दस्तावेज़ों जैसे “निजी दस्तावेज़ों” के बारे में सवालों का जवाब नहीं दे सकते। यदि आप उन्हें जबरदस्ती जवाब देने के लिए कहते हैं, तो इस बात का बहुत अधिक जोखिम होता है कि वे मनगढ़ंत और झूठी जानकारी (हैलुसिनेशन) उत्पन्न कर दें।

इसलिए, वर्तमान में दुनिया भर में RAG (Retrieval-Augmented Generation: रिट्रीवल-ऑगमेंटेड जनरेशन) नामक एक तकनीकी आर्किटेक्चर तेजी से लोकप्रिय हो रहा है। RAG का उपयोग करके, बाहरी डेटाबेस से LLM को गतिशील रूप से अपना खुद का ज्ञान प्रदान करना और इसके आधार पर सटीक और प्रामाणिक उत्तर उत्पन्न करना संभव है।

इसके अलावा, जब एंटरप्राइज़ क्षेत्र या व्यक्तिगत गोपनीय जानकारी से निपटते हैं, तो सुरक्षा नीतियों के कारण OpenAI जैसे क्लाउड-आधारित API में डेटा भेजना अक्सर अस्वीकार्य होता है। ऐसी स्थिति में, एक लोकल AI (एक LLM जो आपके अपने PC या ऑन-प्रिमाइस सर्वर पर पूरी तरह से चलता है) के साथ संयुक्त “लोकल RAG” का निर्माण आवश्यक हो जाता है।

इस लेख में, हम RAG के बुनियादी सिद्धांत से लेकर, Python का उपयोग करके लोकल RAG के विशिष्ट इम्प्लीमेंटेशन, इसके गणितीय आधार (वेक्टर सर्च कैसे काम करता है), और सिस्टम को उत्पादन (प्रोडक्शन) में चलाने की उन्नत तकनीकों तक सब कुछ विस्तार से समझाएंगे।

1. RAG का समग्र आर्किटेक्चर

RAG कोई एक AI मॉडल नहीं है, बल्कि एक सिस्टम आर्किटेक्चर है जहां कई कंपोनेंट्स एक साथ काम करते हैं। इसे मुख्य रूप से दो चरणों में बांटा जा सकता है: “इंजेस्ट (डेटा इनपुट) चरण” और “रिट्रीवल और जनरेशन (सर्च और जनरेशन) चरण”।

नीचे दिया गया Mermaid आरेख RAG सिस्टम का समग्र दृश्य दिखाता है।

graph TD subgraph "इंजेस्ट चरण (पूर्व तैयारी)" Doc["स्वयं के दस्तावेज़ (PDF, TXT, आदि)"] --> Loader["दस्तावेज़ लोडर"] Loader --> Splitter["टेक्स्ट विभाजन (चंकिंग)"] Splitter --> EmbedModel1["एम्बेडिंग मॉडल (Embedding)"] EmbedModel1 --> VectorDB["वेक्टर डेटाबेस"] end subgraph "इन्फ्रेंस चरण (उपयोगकर्ता की क्वेरी के समय)" User["उपयोगकर्ता के प्रश्न (क्वेरी)"] --> EmbedModel2["एम्बेडिंग मॉडल (Embedding)"] EmbedModel2 --> QueryVector["क्वेरी वेक्टर"] QueryVector --> Search["समानता सर्च (वेक्टर सर्च)"] VectorDB --> Search Search --> Context["संबंधित चंक एक्सट्रैक्शन (संदर्भ)"] User --> PromptBuilder["प्रॉम्प्ट निर्माण"] Context --> PromptBuilder PromptBuilder --> LocalLLM["लोकल LLM"] LocalLLM --> Answer["अंतिम उत्तर जनरेशन"] end

इंजेस्ट चरण (पूर्व तैयारी)

दस्तावेज़ों को पढ़ना: PDF, Word, और टेक्स्ट फ़ाइलों जैसे अनस्ट्रक्चर्ड डेटा को लोड किया जाता है।
चंकिंग (टेक्स्ट विभाजन): LLM की इनपुट सीमा (संदर्भ विंडो) के भीतर फिट होने और सर्च सटीकता में सुधार करने के लिए, लंबे टेक्स्ट को अर्थपूर्ण भागों (चंक्स) में विभाजित किया जाता है।
एम्बेडिंग (वेक्टराइजेशन): विभाजित चंक्स को एक एम्बेडिंग मॉडल (Embedding Model) में इनपुट किया जाता है और सैकड़ों से हजारों आयामों वाले संख्याओं की एक ऐरे (वेक्टर) में बदल दिया जाता है।
डेटाबेस में सेव करना: परिवर्तित वेक्टर्स और मूल टेक्स्ट डेटा को एक साथ जोड़ा जाता है और एक वेक्टर डेटाबेस (Vector DB) में सेव किया जाता है।

इन्फ्रेंस चरण (रनटाइम)

क्वेरी का वेक्टराइजेशन: पूर्व तैयारी के समान एम्बेडिंग मॉडल का उपयोग करके उपयोगकर्ता के प्रश्न को एक वेक्टर में बदल दिया जाता है।
समानता सर्च (Similarity Search): डेटाबेस में क्वेरी वेक्टर और दस्तावेज़ वेक्टर्स के बीच समानता की गणना की जाती है, और अर्थपूर्ण रूप से निकटतम (अत्यधिक प्रासंगिक) टेक्स्ट चंक्स में से शीर्ष कुछ को प्राप्त किया जाता है।
प्रॉम्प्ट का निर्माण: प्राप्त संबंधित टेक्स्ट को उपयोगकर्ता के प्रश्न के साथ “संदर्भ (पृष्ठभूमि ज्ञान)” के रूप में जोड़ा जाता है ताकि LLM के लिए एक इनपुट प्रॉम्प्ट बनाया जा सके।
उत्तर का जनरेशन: विस्तारित प्रॉम्प्ट प्राप्त करने वाला LLM प्रदान की गई संदर्भ जानकारी के आधार पर एक उत्तर उत्पन्न करता है।

2. वेक्टर सर्च और एम्बेडिंग (Embeddings) की गहरी समझ

RAG का मूल “वेक्टर सर्च (सिमेंटिक सर्च)” है। पारंपरिक कीवर्ड सर्च (जैसे BM25) के विपरीत, जो सटीक शब्द मिलान या आवृत्ति पर आधारित होता है, वेक्टर सर्च “अर्थ की समानता” पर आधारित होता है। उदाहरण के लिए, भले ही शब्द भिन्न हों जैसे “कुत्ता” और “पिल्ला”, या “PC” और “कंप्यूटर”, वे सर्च में दिखाई देंगे यदि उनके अर्थ करीब हैं।

एम्बेडिंग मॉडल (Embedding Model) क्या है?

एक एम्बेडिंग मॉडल एक न्यूरल नेटवर्क है जो प्राकृतिक भाषा के टेक्स्ट को इनपुट के रूप में लेता है और एक फिक्स्ड-लेंथ डेंस वेक्टर (Dense Vector) आउटपुट करता है। सामान्य मॉडल (जैसे text-embedding-3-small या ओपन-सोर्स multilingual-e5-large) टेक्स्ट को 384-आयामी या 1024-आयामी वास्तविक संख्या वेक्टर में मैप करते हैं।

इस बहुआयामी स्पेस (लेटेंट स्पेस) में, मॉडल को इस तरह से प्रशिक्षित किया जाता है कि समान अर्थ वाले वाक्यों की कोआर्डिनेट स्पेस में दूरी कम हो।

समानता गणना की गणितीय पृष्ठभूमि: कोसाइन समानता (Cosine Similarity)

जब एक वेक्टर डेटाबेस संबंधित दस्तावेज़ों को खोजता है, तो सबसे अधिक इस्तेमाल किया जाने वाला दूरी मीट्रिक कोसाइन समानता (Cosine Similarity) है। यूक्लिडियन दूरी (पूर्ण स्थानिक दूरी) के विपरीत, कोसाइन समानता “दो वेक्टर्स के बीच के कोण” पर केंद्रित होती है। क्योंकि यह वाक्यों की लंबाई (वेक्टर नॉर्म) से कम प्रभावित होती है, यह टेक्स्ट समानता की गणना के लिए बहुत उपयुक्त है।

गणितीय रूप से व्यक्त किया गया, वेक्टर $\mathbf{A}$ और $\mathbf{B}$ की कोसाइन समानता इस प्रकार है:

$$ \text{Cosine Similarity}(\mathbf{A}, \mathbf{B}) = \cos(\theta) = \frac{\mathbf{A} \cdot \mathbf{B}}{\|\mathbf{A}\| \|\mathbf{B}\|} = \frac{\sum_{i=1}^{n} A_i B_i}{\sqrt{\sum_{i=1}^{n} A_i^2} \sqrt{\sum_{i=1}^{n} B_i^2}} $$

$\mathbf{A} \cdot \mathbf{B}$ डॉट प्रोडक्ट (Dot Product) को दर्शाता है।
$\|\mathbf{A}\|$ वेक्टर $\mathbf{A}$ के L2 नॉर्म (लंबाई) को दर्शाता है।
$n$ वेक्टर के आयामों की संख्या है।

कोसाइन समानता का मान -1 से 1 के बीच होता है:

1 के करीब: दो वेक्टर्स की दिशा लगभग समान होती है (अर्थ बहुत समान हैं)।
0 के करीब: दो वेक्टर्स एक-दूसरे के समकोण पर हैं (असंबंधित)।
-1 के करीब: दो वेक्टर्स विपरीत दिशाओं में हैं (अर्थ विपरीत हैं)।

नवीनतम वेक्टर DBs (Chroma, FAISS, Qdrant, आदि) HNSW (Hierarchical Navigable Small World) नामक एक अनुमानित निकटतम पड़ोसी (Approximate Nearest Neighbor - ANN) एल्गोरिदम का उपयोग करते हैं, जो लाखों वेक्टर डेटा से मिलीसेकंड में उच्च कोसाइन समानता वाले दस्तावेज़ों को खोजने के लिए अनुकूलित है।

3. लोकल RAG के निर्माण के लिए तकनीकी स्टैक

क्लाउड से स्वतंत्र पूरी तरह से लोकल RAG बनाने के लिए, हम ओपन-सोर्स इकोसिस्टम का लाभ उठाते हैं। नीचे अनुशंसित तकनीकी स्टैक दिया गया है:

लैंग्वेज मॉडल (LLM)
- टूल्स: Ollama या Llama.cpp
- मॉडल: Llama-3-8B-Instruct, Gemma-2-9B-It, Qwen2-7B-Instruct जैसे हल्के और उच्च-प्रदर्शन वाले ओपन मॉडल। जापानी कार्यों के लिए, जापानी-ट्यून किए गए Llama-3-ELYZA-JP-8B आदि उपयुक्त हैं।
एम्बेडिंग मॉडल (Embedding)
- मॉडल: intfloat/multilingual-e5-large या BAAI/bge-m3। जब इसे लोकली चलाया जाता है, तो आमतौर पर इसे Hugging Face से डाउनलोड किया जाता है और Sentence-Transformers के साथ निष्पादित किया जाता है।
वेक्टर डेटाबेस (Vector DB)
- ChromaDB: Python-आधारित और सेट अप करने में बेहद आसान। लोकल डेवलपमेंट के लिए आदर्श।
- FAISS: Meta द्वारा विकसित एक तेज़ वेक्टर सर्च लाइब्रेरी।
- Qdrant / Milvus: बड़े पैमाने और उत्पादन (प्रोडक्शन) वातावरण के लिए अधिक उपयुक्त।
ऑर्केस्ट्रेशन फ्रेमवर्क
- LangChain: कंपोनेंट्स को जोड़ने (Chain) के लिए वास्तविक मानक (de facto standard)।
- LlamaIndex: विशेष रूप से RAG के लिए एक डेटा कनेक्शन फ्रेमवर्क।

इस बार, हम LangChain + ChromaDB + Ollama + HuggingFaceEmbeddings के संयोजन का उपयोग करके इसे लागू करेंगे, जिसे इंस्टॉल करना सबसे आसान है।

4. इम्प्लीमेंटेशन ट्यूटोरियल: Python का उपयोग करके पूर्ण लोकल RAG का निर्माण

यहाँ से, हम वास्तव में Python कोड लिखते हुए एक लोकल RAG बनाएंगे। कृपया सुनिश्चित करें कि Ollama आपके PC पर स्थापित है और पहले से ही बैकग्राउंड में चल रहा है। इसके अलावा, Ollama पर मॉडल को पुल करें (उदाहरण के लिए: ollama run llama3)।

चरण 1: आवश्यक लाइब्रेरीज़ इंस्टॉल करना

1
2


pip install langchain langchain-community langchain-huggingface
pip install chromadb sentence-transformers pypdf

चरण 2: सम्पूर्ण इम्प्लीमेंटेशन कोड

नीचे एक पूर्ण Python स्क्रिप्ट दी गई है जो PDF फ़ाइलों को पढ़ती है, उन्हें वेक्टराइज करती है, और एक लोकल LLM को प्रश्नों का उत्तर देने की अनुमति देती है।

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93


import os
from langchain_community.document_loaders import PyPDFLoader
from langchain_text_splitters import RecursiveCharacterTextSplitter
from langchain_huggingface import HuggingFaceEmbeddings
from langchain_community.vectorstores import Chroma
from langchain_community.llms import Ollama
from langchain_core.prompts import PromptTemplate
from langchain.chains import RetrievalQA

def main():
 # 1. दस्तावेज़ लोड करना
 print("दस्तावेज़ लोड हो रहा है...")
 # आप जिस PDF को पढ़ना चाहते हैं उसका पाथ निर्दिष्ट करें
 file_path = "sample_company_policy.pdf"
 loader = PyPDFLoader(file_path)
 documents = loader.load()

 # 2. चंक विभाजन (Text Splitting)
 # वाक्यों के अर्थ को नष्ट किए बिना उन्हें उचित आकार में विभाजित करें
 text_splitter = RecursiveCharacterTextSplitter(
 chunk_size=500, # प्रति चंक अधिकतम कैरेक्टर्स
 chunk_overlap=50, # आसन्न चंक्स में ओवरलैपिंग कैरेक्टर्स (संदर्भ के टूटने को रोकने के लिए)
 separators=["\n\n", "\n", "।", "、", " ", ""]
 )
 chunks = text_splitter.split_documents(documents)
 print(f"{len(chunks)} चंक्स में विभाजित किया गया।")

 # 3. एम्बेडिंग मॉडल का इनिशियलाइज़ेशन (Local HuggingFace Model)
 # मजबूत बहुभाषी मॉडल का उपयोग करें
 print("एम्बेडिंग मॉडल लोड हो रहा है...")
 embeddings = HuggingFaceEmbeddings(
 model_name="intfloat/multilingual-e5-large",
 model_kwargs={'device': 'cpu'} # अगर GPU है तो 'cuda' या 'mps'
 )

 # 4. वेक्टर डेटाबेस का निर्माण (Chroma)
 print("वेक्टर डेटाबेस का निर्माण हो रहा है...")
 persist_directory = "./chroma_db"
 vectorstore = Chroma.from_documents(
 documents=chunks,
 embedding=embeddings,
 persist_directory=persist_directory
 )
 # रिट्रीवर (Retriever) बनाना। शीर्ष 3 प्रासंगिक दस्तावेज़ प्राप्त करने के लिए सेट किया गया
 retriever = vectorstore.as_retriever(search_kwargs={"k": 3})

 # 5. लोकल LLM का इनिशियलाइज़ेशन (Ollama)
 print("लोकल LLM से कनेक्ट हो रहा है...")
 # 'ollama pull llama3' आदि के साथ पहले से मॉडल प्राप्त करना सुनिश्चित करें
 llm = Ollama(model="llama3")

 # 6. प्रॉम्प्ट टेम्पलेट की परिभाषा
 prompt_template = """आप एक बेहतरीन सहायक हैं जो कंपनी के नियमों और आंतरिक जानकारी से अच्छी तरह वाकिफ हैं।
कृपया उपयोगकर्ता के प्रश्न का हिंदी में विस्तार से उत्तर देने के लिए केवल निम्नलिखित संदर्भ (पृष्ठभूमि जानकारी) का उपयोग करें।
यदि आपको संदर्भ में उत्तर नहीं मिल रहा है, तो कृपया अनुमान न लगाएं और ईमानदारी से कहें, "प्रदान की गई जानकारी से मैं उत्तर नहीं दे सकता।"

【संदर्भ】
{context}

【प्रश्न】
{question}

【उत्तर】:
"""
 PROMPT = PromptTemplate(
 template=prompt_template,
 input_variables=["context", "question"]
 )

 # 7. RAG चेन का निर्माण
 qa_chain = RetrievalQA.from_chain_type(
 llm=llm,
 chain_type="stuff",
 retriever=retriever,
 return_source_documents=True, # क्या स्रोत दस्तावेज़ वापस करने हैं, यह सेट करें
 chain_type_kwargs={"prompt": PROMPT}
 )

 # 8. प्रश्न का निष्पादन
 query = "रिमोट वर्क के लिए परिवहन खर्च के भत्ते की शर्तों के बारे में बताएं।"
 print(f"\nप्रश्न: {query}\n")

 result = qa_chain.invoke({"query": query})

 print("【उत्तर】")
 print(result['result'])
 print("\n---")
 print("【संदर्भित स्रोत】")
 for doc in result['source_documents']:
 print(f"- पृष्ठ {doc.metadata.get('page', 'अज्ञात')}: {doc.page_content[:50]}...")

if __name__ == "__main__":
 main()

कोड के मुख्य बिंदुओं की व्याख्या

RecursiveCharacterTextSplitter: यह प्राकृतिक भाषा को विभाजित करने के लिए सबसे अधिक अनुशंसित स्प्लिटर है। यह पैराग्राफ (\n\n), लाइन्स (\n), और पूर्ण विराम (。 या ।) के क्रम में विभाजित करने का प्रयास करता है, और अर्थ को यथासंभव संरक्षित रखते हुए निर्दिष्ट chunk_size में फिट होने के लिए विभाजित करता है। chunk_overlap सेट करके, यह संदर्भ की सीमाओं को टूटने और जानकारी के नुकसान को रोकता है।
HuggingFaceEmbeddings: intfloat/multilingual-e5-large एक बहुत शक्तिशाली ओपन-सोर्स एम्बेडिंग मॉडल है जो कई भाषाओं का समर्थन करता है। क्लाउड API (जैसे OpenAI का text-embedding-ada-002) का उपयोग किए बिना, आप टेक्स्ट को ऑफलाइन अपनी लोकल मेमोरी में वेक्टराइज़ कर सकते हैं।
ChromaDB: चूंकि यह इन-मेमोरी या लोकल स्टोरेज (SQLite पर आधारित) में काम करता है, इसलिए किसी जटिल डेटाबेस सर्वर को स्थापित करने की आवश्यकता नहीं है। persist_directory को निर्दिष्ट करके, आप फिर से निष्पादित करते समय वेक्टराइजेशन प्रक्रिया को छोड़ सकते हैं और डेटाबेस को डिस्क से लोड कर सकते हैं।

5. उन्नत RAG तकनीकें (Advanced RAG Techniques)

उपरोक्त ट्यूटोरियल में बनाया गया बुनियादी RAG सिस्टम (Naive RAG) काम करेगा, लेकिन यदि उत्पादन वातावरण में उच्च उत्तर सटीकता की आवश्यकता है, तो आपको निम्नलिखित उन्नत तकनीकों को पेश करने की आवश्यकता होगी:

5.1 हाइब्रिड सर्च (Hybrid Search)

वेक्टर सर्च “अर्थ” को पकड़ने में अच्छा है, लेकिन यह सटीक कीवर्ड खोजों जैसे “विशिष्ट उचित संज्ञा (proper nouns)”, “उत्पाद मॉडल संख्या”, या “कर्मचारी ID” के साथ संघर्ष कर सकता है। इसलिए, वेक्टर सर्च के माध्यम से सिमेंटिक सर्च और BM25 एल्गोरिदम आदि का उपयोग करके कीवर्ड सर्च समानांतर में करके, और दोनों परिणामों को स्कोरिंग और एकीकृत करके (रेसिप्रोकल रैंक फ्यूजन; RRF जैसी तकनीकों का उपयोग करके), आप छूटे हुए सर्च परिणामों को काफी कम कर सकते हैं।

5.2 री-रैंकिंग (Re-ranking)

वेक्टर सर्च तेज है, लेकिन यह हमेशा संदर्भ की सटीक प्रासंगिकता का आकलन नहीं करता है। सर्च सटीकता में सुधार के लिए एक सामान्य पाइपलाइन इस प्रकार है:

प्रारंभिक सर्च (First-stage Retrieval): वेक्टर DB से मोटे तौर पर और सतही तौर पर लगभग 20-30 संबंधित चंक्स प्राप्त किए जाते हैं।
पुनर्मूल्यांकन (Re-ranking): एक अन्य भारी मशीन लर्निंग मॉडल जिसे Cross-Encoder कहा जाता है (उदाहरण के लिए: bge-reranker आदि) का उपयोग करके, उपयोगकर्ता की क्वेरी और प्राप्त चंक्स की जोड़ी को इनपुट किया जाता है, और सिमेंटिक प्रासंगिकता स्कोर की पुनर्गणना की जाती है।
चयन: केवल उच्चतम स्कोर वाले शीर्ष 3-5 चंक्स को अंतिम संदर्भ के रूप में LLM के प्रॉम्प्ट में पास किया जाता है।

यह तकनीक अप्रासंगिक नॉइज़ जानकारी को LLM तक पहुंचने से रोकती है और उत्तर की सटीकता (Precision) में काफी सुधार करती है।

graph LR Query["क्वेरी"] --> VSearch["वेक्टर सर्च (शीर्ष 20)"] VSearch --> Reranker["री-रैंकर मॉडल (Cross-Encoder)"] Query --> Reranker Reranker --> TopK["उच्च सटीकता वाले शीर्ष 3"] TopK --> LLM["LLM जनरेशन"]

5.3 सिमेंटिक चंकिंग और पेरेंट दस्तावेज़ सर्च

वाक्यों को उनकी निश्चित लंबाई के आधार पर यंत्रवत विभाजित करने के बजाय, “सिमेंटिक चंकिंग (Semantic Chunking)” नामक एक तकनीक है जो वाक्यों के अर्थ में परिवर्तन का पता लगाने और तदनुसार उन्हें विभाजित करने के लिए AI का उपयोग करती है। इसके अलावा, “पेरेंट डॉक्यूमेंट रिट्रीवर (Parent Document Retriever)” तकनीक में, सटीक सर्च प्राप्त करने के लिए सर्च के उद्देश्य से वेक्टरकरण बहुत छोटी इकाइयों (जैसे वाक्यों) में किया जाता है, लेकिन जब इसे LLM को पास किया जाता है, तो “मूल बड़ा पैराग्राफ (पेरेंट दस्तावेज़)” जिसमें वह वाक्य शामिल होता है, LLM को पर्याप्त संदर्भ प्रदान करने के लिए पास किया जाता है।

6. लोकल RAG को संचालित करते समय चुनौतियां और समाधान

जब लोकल वातावरण में RAG के निर्माण और संचालन की बात आती है, तो कुछ विशिष्ट बाधाएं होती हैं।

VRAM (वीडियो मेमोरी) की कमी: व्यावहारिक गति (दसियों टोकन प्रति सेकंड) पर एक लोकल LLM चलाने के लिए, मॉडल को GPU के VRAM में लोड करने की आवश्यकता होती है। एक 8B क्लास मॉडल को fp16 (16-बिट फ्लोटिंग पॉइंट) में चलाने के लिए लगभग 16GB VRAM की आवश्यकता होती है, लेकिन क्वांटाइजेशन (Quantization) तकनीक (GGUF या AWQ प्रारूप जैसे इसे 4-बिट या 8-बिट में संपीड़ित करने की तकनीक) का उपयोग करके, इसे 8GB VRAM (जैसे सामान्य गेमिंग PC) के साथ भी काफी तेज गति से चलाना संभव है। Llama.cpp और Ollama मानक रूप से इन क्वांटाइजेशन प्रारूपों का समर्थन करते हैं।
संदर्भ विंडो (Context Window) की सीमाएं: यदि सर्च के माध्यम से प्राप्त संदर्भ की मात्रा बहुत अधिक है, तो यह LLM की इनपुट सीमा (टोकन सीमा) को पार कर सकती है, या मॉडल जानकारी के मध्य भाग को भूल सकता है (Lost in the middle की घटना)। निकाले गए चंक्स की संख्या को समायोजित करना और पहले बताई गई री-रैंकिंग तकनीक के माध्यम से उन्हें सावधानीपूर्वक चुनना आवश्यक है।
डेटा की ताजगी (Data Freshness) का प्रबंधन: जब स्रोत दस्तावेज़ अपडेट किया जाता है, तो वेक्टर डेटाबेस में संबंधित दस्तावेज़ के वेक्टर को भी अपडेट या हटाया (CRUD ऑपरेशन) जाना चाहिए। चूंकि ChromaDB दस्तावेज़ ID के आधार पर अपडेट करने का समर्थन करता है, इसलिए फ़ाइल के हैश मान को प्रबंधित करना और केवल अंतर (differences) को सिंक्रनाइज़ करने के लिए एक बैच प्रक्रिया (batch process) सेट अप करना व्यावहारिक है।

निष्कर्ष

RAG (रिट्रीवल-ऑगमेंटेड जनरेशन) एक शक्तिशाली प्रतिमान (paradigm) है जो AI को एक सामान्य-उद्देश्य सहायक से “आपके अपने विशेष विशेषज्ञ” या “कंपनी के संचालन में एक विशेषज्ञ” के रूप में विकसित करता है।

हमने सीखा कि यहां तक कि अत्यधिक गोपनीय आवश्यकताओं के लिए भी जहां क्लाउड सेवाओं का उपयोग नहीं किया जा सकता है, Ollama, LangChain, और ChromaDB जैसे ओपन-सोर्स इकोसिस्टम को मिलाकर पूरी तरह से “लोकल RAG” वातावरण बनाना अपेक्षाकृत आसान है।

इस लेख में समझाए गए वेक्टर स्पेस की गणितीय समझ, और टेक्स्ट विभाजन (text splitting) और री-रैंकिंग (re-ranking) जैसे उन्नत दृष्टिकोणों के आधार पर, कृपया अपने स्वयं के डेटा का उपयोग करके अपना मूल AI सिस्टम विकसित करने का प्रयास करें। लोकल AI के विकास की गति चौंका देने वाली है, और जो सिस्टम आप आज बनाते हैं उसे कल आने वाले एक और भी अधिक स्मार्ट और हल्के मॉडल के साथ बदलकर तुरंत अपडेट किया जा सकता है।

यह ब्लॉग AI तकनीक और RAG पर गहन लेख प्रकाशित करता रहेगा। यदि आपके कोई प्रश्न या प्रतिक्रिया (feedback) है, तो कृपया उन्हें टिप्पणी अनुभाग (comments section) में छोड़ें।

ChatGPT・Gemini・Claude के API की विस्तृत तुलना! आपको कौन सा चुनना चाहिए?

Fri, 11 Sep 2026 12:00:00 +0900

ChatGPT・Gemini・Claude के API की विस्तृत तुलना! आपको कौन सा चुनना चाहिए?

AI तकनीक का विकास उल्लेखनीय है, और विशेष रूप से बड़े भाषा मॉडल (LLM: Large Language Model) के क्षेत्र में, OpenAI के ChatGPT (GPT श्रृंखला), Google के Gemini, और Anthropic के Claude एक-दूसरे के साथ वर्चस्व की भयंकर त्रिकोणीय लड़ाई लड़ रहे हैं। 2026 तक, ये कंपनियाँ महीनों या यहाँ तक कि हफ्तों में नए मॉडल और API सुविधाएँ जारी कर रही हैं। डेवलपर्स और एंटरप्राइज़ IT आर्किटेक्ट्स के लिए, “हमें अपने उत्पाद में किस API को एकीकृत करना चाहिए?” यह प्रश्न एक अत्यंत महत्वपूर्ण निर्णय बन गया है जो किसी परियोजना की सफलता या विफलता को निर्धारित करता है।

इस लेख में, हम केवल विशिष्टताओं को सूचीबद्ध करने से आगे बढ़ेंगे और इन 3 प्रमुख AI प्रदाताओं के API की पूरी तरह से तुलना और व्याख्या करेंगे - आर्किटेक्चर डिज़ाइन, विस्तृत मूल्य निर्धारण संरचना, विलंबता (latency) का गणितीय विश्लेषण, Python और Node.js का उपयोग करके ठोस कार्यान्वयन उदाहरणों से लेकर, प्रॉम्प्ट कैशिंग (prompt caching) जैसी नवीनतम लागत अनुकूलन तकनीकों तक, वह भी एक डेवलपर के दृष्टिकोण से।

हमारा उद्देश्य है कि यह पाठकों के लिए एक संपूर्ण मार्गदर्शिका बने जिससे वे अपने उपयोग के मामलों के लिए सर्वश्रेष्ठ LLM API का चयन कर सकें और स्केलेबल तथा लागत-प्रभावी AI एप्लिकेशन का निर्माण कर सकें।

1. प्रत्येक LLM API का दर्शन और डिज़ाइन विचारधारा

तकनीक के चयन में, सबसे पहले यह समझना बहुत महत्वपूर्ण है कि प्रत्येक कंपनी किस विचारधारा के साथ अपने मॉडल और API का निर्माण कर रही है।

1.1 OpenAI (ChatGPT)

OpenAI का मिशन “कृत्रिम सामान्य बुद्धिमत्ता (AGI) की प्राप्ति” है, और यह हमेशा उद्योग में वास्तविक मानक (de facto standard) का नेतृत्व करता है। यह विभिन्न उपयोग मामलों के अनुकूल कई मॉडल प्रदान करता है, जैसे कि GPT-4o, GPT-4o-mini, और तर्क-विशिष्ट o1 मॉडल। इसका इकोसिस्टम सबसे परिपक्व है, और आधिकारिक या अनौपचारिक रूप से इसके पास सबसे प्रचुर पुस्तकालय (libraries) और दस्तावेज़ीकरण हैं।

1.2 Google (Gemini)

Google ने “AI First” को अपनाया है, और इसके बुनियादी ढांचे (TPU नेटवर्क) का अधिकतम उपयोग करने वाली स्केलेबिलिटी इसकी प्रमुख ताकत है। Gemini 1.5 Pro/Flash की सबसे बड़ी विशेषता इसकी 2 मिलियन टोकन की विशाल कॉन्टेक्स्ट विंडो (context window) है, जो लंबे दस्तावेज़ों और कई घंटों के वीडियो और ऑडियो को एक साथ संसाधित करने की अनुमति देती है। Google Cloud (Vertex AI) के साथ इसका मजबूत एकीकरण भी उद्यमों के लिए आकर्षक है।

1.3 Anthropic (Claude)

Anthropic की स्थापना OpenAI के पूर्व सदस्यों द्वारा की गई थी और यह “Constitutional AI” (संवैधानिक AI) नामक एक अद्वितीय सुरक्षा दृष्टिकोण अपनाता है। Claude 3.5 Sonnet और Opus अपनी उच्च तर्क क्षमता, कोड जनरेशन क्षमता, और सबसे महत्वपूर्ण, “मानव जैसी प्राकृतिक बातचीत” और कम “मतिभ्रम (Hallucination)” के लिए कई डेवलपर्स से उत्साही समर्थन प्राप्त कर रहे हैं।

2. मॉडल परिवारों के विनिर्देशों की विस्तृत तुलना

हम 2026 तक मुख्य मॉडलों के विनिर्देशों की तुलना कर रहे हैं।

प्रदाता	मुख्य मॉडल	अधिकतम कॉन्टेक्स्ट लंबाई	प्रमुख ताकत	अनुशंसित उपयोग के मामले
OpenAI	GPT-4o	128K	गति, दृश्य पहचान, ऑडियो समर्थन	इंटरएक्टिव ऐप्स, सामान्य कार्य
OpenAI	o1-preview	128K	उन्नत तार्किक तर्क, गणित, कोडिंग	जटिल एल्गोरिदम निर्माण, अनुसंधान उपयोग
Google	Gemini 1.5 Pro	2,000K	अति-लंबे पाठ प्रसंस्करण, मल्टीमॉडल (वीडियो/ऑडियो)	विशाल कोडबेस विश्लेषण, वीडियो सारांश
Google	Gemini 1.5 Flash	2,000K	कम विलंबता, उच्च थ्रूपुट, अत्यधिक कम लागत	रियल-टाइम प्रसंस्करण, बड़े डेटा का बैच प्रसंस्करण
Anthropic	Claude 3.5 Sonnet	200K	कोडिंग क्षमता, प्राकृतिक पाठ निर्माण	सॉफ़्टवेयर विकास सहायता, उन्नत ग्राहक सहायता
Anthropic	Claude 3.5 Haiku	200K	अति-तेज प्रतिक्रिया, लागत प्रदर्शन	एज (Edge) AI, रियल-टाइम चैटबॉट

3. आर्किटेक्चर में गहराई से जाना: API अनुरोधों के पीछे

जब आप LLM API को कॉल करते हैं, तो बैकएंड में किस तरह की प्रक्रिया होती है? प्रदर्शन को अनुकूलित करने के लिए इस आर्किटेक्चर को समझना आवश्यक है।

नीचे दिया गया Mermaid आरेख API अनुरोध को क्लाइंट से भेजने से लेकर टोकन को स्ट्रीमिंग में वापस करने तक की पूरी तस्वीर दिखाता है।

graph TD A["क्लाइंट एप्लिकेशन"] -->|HTTP/REST or gRPC| B["API गेटवे"] B --> C["लोड बैलेंसर"] C --> D["अनुमान क्लस्टर"] D --> E["टोकेनाइज़र (BPE / SentencePiece)"] E --> F["KV कैश और अटेंशन मैकेनिज्म"] F --> G["ट्रांसफॉर्मर ब्लॉक्स (फॉरवर्ड पास)"] G --> H["आउटपुट लेयर (लॉजिट्स)"] H --> I["सैंपलर (Temperature, Top-p, Top-k)"] I --> J["डिटोकेनाइज़र"] J -->|Streaming Response (Chunk)| A

3.1 Tokenization (टोकनाइजेशन) एल्गोरिदम

API में इनपुट किया गया टेक्स्ट आंतरिक रूप से “टोकन (token)” नामक इकाइयों में विभाजित हो जाता है।

OpenAI (tiktoken): Byte-Pair Encoding (BPE) का उपयोग करता है। विशेष रूप से अंग्रेजी में यह अत्यंत कुशलता से संपीड़ित होता है, लेकिन जापानी और हिंदी जैसी गैर-वर्णमाला भाषाओं में टोकन की संख्या बढ़ने की प्रवृत्ति होती है।
Google (Gemini): SentencePiece (Unigram Language Model) को अपनाता है। यह बहुभाषी (multilingual) समर्थन में मजबूत है, और जापानी व हिंदी जैसे टेक्स्ट को अपेक्षाकृत कम टोकन के साथ व्यक्त करने की प्रवृत्ति रखता है।
Anthropic (Claude): BPE के एक अनुकूलित संस्करण का उपयोग करता है। बहुभाषी समर्थन को मजबूत किया गया है, और Claude 3 के बाद से गैर-अंग्रेजी भाषाओं (जैसे जापानी) की टोकन दक्षता में काफी सुधार हुआ है।

4. विलंबता (Latency) और प्रदर्शन का गणितीय विश्लेषण

रियल-टाइम एप्लिकेशन में, विलंबता सीधे उपयोगकर्ता अनुभव (UX) को प्रभावित करती है। LLM API की विलंबता $T_{total}$ को गणितीय रूप से निम्न प्रकार मॉडल किया जा सकता है:

$$ T_{total} = T_{network} + T_{TTFT} + (N \times T_{TPOT}) $$

यहाँ, प्रत्येक चर (variable) का अर्थ निम्नलिखित है:

$T_{network}$: नेटवर्क का राउंड ट्रिप टाइम (RTT)।
$T_{TTFT}$ (Time To First Token): पहला अक्षर उत्पन्न होने में लगने वाला समय। यह काफी हद तक अटेंशन (Attention) गणना की लागत पर निर्भर करता है, जो प्रॉम्प्ट की लंबाई (इनपुट टोकन की संख्या) के वर्ग (square) के समानुपाती (proportional) होता है।
$N$: आउटपुट टोकन की कुल संख्या।
$T_{TPOT}$ (Time Per Output Token): प्रति टोकन जनरेशन का समय। चूँकि यह एक ऑटो-रिग्रेसिव (auto-regressive) मॉडल है, इसकी गणना पिछले आउटपुट के आधार पर क्रमिक रूप से (in series) की जाती है।

4.1 सेल्फ-अटेंशन (Self-Attention) तंत्र की कम्प्यूटेशनल जटिलता

Transformer आर्किटेक्चर में सेल्फ-अटेंशन की गणना जटिलता इनपुट अनुक्रम की लंबाई $L$ के संबंध में द्विघातीय रूप से (quadratically) बढ़ती है।

$$ \text{Complexity} = O(L^2 \cdot d) $$

जहाँ $d$ एम्बेडिंग वेक्टर का आयाम (dimension) है। इस सीमा के कारण, आमतौर पर जैसे-जैसे प्रॉम्प्ट लंबा होता जाता है, $T_{TTFT}$ तेजी से खराब होता है। हालाँकि, Google का Gemini 1.5 “Ring Attention” और “Block-wise Compute” जैसे अभिनव अनुकूलन आर्किटेक्चर को अपनाता है, जो 2 मिलियन टोकन के लंबे पाठ इनपुट के साथ भी व्यावहारिक समय (कुछ सेकंड से लेकर कई दहाई सेकंड) में पहला टोकन सफलतापूर्वक उत्पन्न कर सकता है।

5. मूल्य निर्धारण प्रणाली और लागत अनुकूलन रणनीतियाँ

API की लागत मूल रूप से इनपुट टोकन और आउटपुट टोकन की संख्या के आधार पर गणना की जाती है।

$$ Cost = (Tokens_{in} \times Rate_{in}) + (Tokens_{out} \times Rate_{out}) $$

हालाँकि, नवीनतम APIs ने लागत को काफी कम करने के लिए नए तंत्र पेश किए हैं।

5.1 प्रॉम्प्ट कैशिंग (Prompt Caching)

विशाल सिस्टम प्रॉम्प्ट या RAG के माध्यम से खोजे गए बड़ी मात्रा में दस्तावेज़ों को हर बार भेजने से भारी लागत आती है। इससे निपटने के लिए, प्रत्येक कंपनी कैशिंग कार्यक्षमता प्रदान कर रही है।

Anthropic (Claude) और Google (Gemini) विशिष्ट टेक्स्ट ब्लॉक को कैश करके इनपुट लागत को काफी कम (90% तक) कर सकते हैं।

कैश का उपयोग करते समय लागत मॉडल कुछ इस प्रकार होता है:

$$ Cost_{cached} = (Tokens_{cache\_write} \times Rate_{cache\_write}) + (Tokens_{cache\_read} \times Rate_{cache\_read}) + (Tokens_{out} \times Rate_{out}) $$

यहाँ $Rate_{cache\_read}$ आम तौर पर नियमित $Rate_{in}$ के 10% से 25% पर सेट होता है। इसके परिणामस्वरूप, पृष्ठभूमि ज्ञान के रूप में कोडबेस की हज़ारों पंक्तियों को बनाए रखते हुए चैटबॉट्स को सस्ते में चलाना संभव हो गया है।

5.2 बैच API (Batch API)

ऐसे कार्यों के लिए जिन्हें रीयल-टाइम प्रोसेसिंग की आवश्यकता नहीं है (लॉग विश्लेषण, भारी डेटा वर्गीकरण, आदि), OpenAI और Anthropic बैच API प्रदान करते हैं। आप 24 घंटे के भीतर परिणाम प्राप्त करने के बदले में, एक ही बार में कई अनुरोध भेज सकते हैं और इसका उपयोग नियमित API शुल्क के आधे (50% की छूट) पर कर सकते हैं। यह एक बहुत शक्तिशाली तंत्र है।

6. डेवलपर अनुभव (DX) और SDK की तुलना

विकास दक्षता के नजरिए से, हम प्रत्येक कंपनी द्वारा प्रदान किए जाने वाले SDK (सॉफ़्टवेयर डेवलपमेंट किट) की तुलना करेंगे।

6.1 OpenAI API

यह सबसे व्यापक रूप से उपयोग किया जाता है, और थर्ड-पार्टी लाइब्रेरी (जैसे LangChain, LlamaIndex) का समर्थन सबसे तेज है। इसके अतिरिक्त, इसकी “Structured Outputs” विशेषता के माध्यम से, यह 100% सटीकता के साथ JSON स्कीमा का पालन करने वाली प्रतिक्रियाएं लौटाने की गारंटी देता है, जिससे सिस्टम एकीकरण बहुत आसान हो जाता है।

6.2 Anthropic API (Claude)

SDK का इंटरफ़ेस बहुत परिष्कृत (refined) है, और TypeScript प्रकार (type definitions) परिभाषाओं को संभालना बहुत आसान माना जाता है। विशेष रूप से, इसका Message API संरचना काफी सहज है, और कई छवियों सहित मल्टीमॉडल अनुरोधों को सरलता से लिखा जा सकता है।

6.3 Google Gemini API

यहाँ पहुँच के दो तरीके हैं: Google Cloud Vertex AI के माध्यम से और AI Studio (Google Gen AI SDK) के माध्यम से, जो शुरुआती लोगों को थोड़ा भ्रमित कर सकता है। हालाँकि, उद्यमों के लिए Vertex AI SDK, GCP के IAM (पहचान और पहुँच प्रबंधन प्रणाली) के साथ पूरी तरह से एकीकृत है और एक सुरक्षित विकास वातावरण बनाने में सक्षम है।

7. अभ्यास! Python का उपयोग करके बहु-API एकीकरण परीक्षण का कार्यान्वयन

यहाँ, हम एक ऐसी स्क्रिप्ट लागू करेंगे जो एक साथ OpenAI, Anthropic और Gemini API को अतुल्यकालिक (asynchronous) रूप से अनुरोध भेजती है और Python का उपयोग करके विलंबता (latency) की तुलना करती है।

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59


import asyncio
import time
import os
from openai import AsyncOpenAI
from anthropic import AsyncAnthropic
import google.generativeai as genai

# क्लाइंट इनिशियलाइज़ेशन
openai_client = AsyncOpenAI(api_key=os.environ.get("OPENAI_API_KEY"))
anthropic_client = AsyncAnthropic(api_key=os.environ.get("ANTHROPIC_API_KEY"))
genai.configure(api_key=os.environ.get("GEMINI_API_KEY"))

prompt = "क्वांटम कंप्यूटिंग के मूल सिद्धांतों और वर्तमान क्रिप्टोग्राफी पर इसके प्रभाव को शुरुआती लोगों के लिए सरल भाषा में समझाएं।"

async def fetch_openai():
 start_time = time.time()
 response = await openai_client.chat.completions.create(
 model="gpt-4o",
 messages=[{"role": "user", "content": prompt}],
 max_tokens=1024
 )
 elapsed = time.time() - start_time
 return "OpenAI (GPT-4o)", elapsed, response.choices[0].message.content

async def fetch_anthropic():
 start_time = time.time()
 response = await anthropic_client.messages.create(
 model="claude-3-5-sonnet-20240620",
 messages=[{"role": "user", "content": prompt}],
 max_tokens=1024
 )
 elapsed = time.time() - start_time
 return "Anthropic (Claude 3.5 Sonnet)", elapsed, response.content[0].text

async def fetch_gemini():
 start_time = time.time()
 model = genai.GenerativeModel('gemini-1.5-pro')
 # Gemini Python SDK के एसिंक्रोनस (asynchronous) मेथड का उपयोग
 response = await model.generate_content_async(prompt)
 elapsed = time.time() - start_time
 return "Google (Gemini 1.5 Pro)", elapsed, response.text

async def main():
 print("प्रत्येक LLM API को अनुरोध भेजे जा रहे हैं...")

 # 3 APIs को समानांतर (parallel) रूप से चलाएं
 results = await asyncio.gather(
 fetch_openai(),
 fetch_anthropic(),
 fetch_gemini()
 )

 for provider, latency, text in results:
 print(f"--- {provider} ---")
 print(f"Latency: {latency:.2f} seconds")
 print(f"Response (Excerpt): {text[:100]}...\n")

if __name__ == "__main__":
 asyncio.run(main())

इस स्क्रिप्ट को चलाकर, आप आसानी से माप सकते हैं कि वास्तविक नेटवर्क वातावरण में कौन सा मॉडल सबसे तेज़ी से ($T_{total}$ को कम करके) प्रतिक्रिया देता है।

8. Node.js के साथ टूल कॉलिंग (Function Calling) का कार्यान्वयन

LLM को केवल एक चैटबॉट के रूप में काम करने के बजाय बाहरी प्रणालियों के साथ जुड़ने वाले “AI एजेंट” के रूप में कार्य करने के लिए, टूल कॉलिंग (या फंक्शन कॉलिंग) आवश्यक है। नीचे Node.js (TypeScript) का उपयोग करके OpenAI API के माध्यम से मौसम API को कॉल करने का एक उदाहरण दिया गया है।

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51


import OpenAI from "openai";

const openai = new OpenAI({
 apiKey: process.env.OPENAI_API_KEY,
});

async function runAgent() {
 const tools = [
 {
 type: "function",
 function: {
 name: "get_weather",
 description: "निर्दिष्ट शहर का वर्तमान मौसम प्राप्त करता है।",
 parameters: {
 type: "object",
 properties: {
 location: {
 type: "string",
 description: "शहर का नाम (उदाहरण: टोक्यो, न्यूयॉर्क)",
 },
 },
 required: ["location"],
 },
 },
 },
 ];

 const response = await openai.chat.completions.create({
 model: "gpt-4o",
 messages: [{ role: "user", "content": "आज टोक्यो का मौसम कैसा है? क्या मुझे छाते की ज़रूरत पड़ेगी?" }],
 tools: tools,
 tool_choice: "auto",
 });

 const message = response.choices[0].message;

 if (message.tool_calls) {
 const toolCall = message.tool_calls[0];
 console.log(`LLM ने टूल कॉल का अनुरोध किया है: फ़ंक्शन का नाम = ${toolCall.function.name}`);

 const args = JSON.parse(toolCall.function.arguments);
 console.log(`आर्गुमेंट: ${args.location}`);

 // यहाँ वास्तविक मौसम API (उदा: OpenWeatherMap) को कॉल करने का लॉजिक लागू करें
 // const weather = await fetchWeatherFromAPI(args.location);

 // अंतिम उत्तर उत्पन्न करने के लिए प्राप्त परिणाम को वापस LLM को दें
 }
}

runAgent().catch(console.error);

Claude 3.5 Sonnet और Gemini 1.5 Pro में भी समतुल्य टूल कॉलिंग कार्यक्षमता है। हालांकि स्कीमा को परिभाषित करने के तरीके में कुछ अंतर हैं, फिर भी बुनियादी प्रवाह (flow) समान है।

9. RAG बनाम लंबी कॉन्टेक्स्ट विंडो: आपको किसे चुनना चाहिए?

वर्तमान में, एंटरप्राइज़ AI आर्किटेक्चर में सबसे बड़ी बहसों में से एक यह है: “बाहरी ज्ञान को शामिल करने के लिए, क्या हमें RAG (Retrieval-Augmented Generation) का उपयोग करना चाहिए, या सब कुछ एक विशाल कॉन्टेक्स्ट विंडो (Long Context) पर छोड़ देना चाहिए?”

RAG (Retrieval-Augmented Generation) के लाभ और चुनौतियाँ

लाभ: यह सस्ता है (क्योंकि केवल आवश्यक चंक्स प्रॉम्प्ट में डाले जाते हैं), और उत्तर के आधार (स्रोत) की पहचान करना आसान है।
चुनौतियाँ: यह सिमेंटिक सर्च की सटीकता पर निर्भर करता है, इसलिए यह उन्नत तर्क कार्यों के लिए उपयुक्त नहीं है जहाँ संदर्भ कई दस्तावेज़ों में फैला हुआ हो (जैसे, “पिछले साल के सभी मीटिंग मिनट्स का विश्लेषण करें और प्रोजेक्ट A के विलंबित होने का मूल कारण कालानुक्रमिक क्रम (chronological order) में निकालें”)।

लंबा कॉन्टेक्स्ट (Long Context, उदाहरण: Gemini 1.5 Pro का 2 मिलियन टोकन)

लाभ: खोज के कारण कोई जानकारी छूटती नहीं है। यहां तक कि “Needle In A Haystack (NIAH)” परीक्षण में भी, Gemini 1.5 Pro और Claude 3.5 Sonnet 99% से अधिक सटीकता के साथ जानकारी निकाल सकते हैं।
चुनौतियाँ: भारी टोकन खपत से लागत बढ़ती है, और विलंबता ($T_{TTFT}$) बढ़ जाती है।

निष्कर्ष: 2026 में सबसे अच्छी रणनीति “हाइब्रिड अप्रोच” है। नियमित Q&A के लिए वेक्टर डेटाबेस का उपयोग करते हुए RAG का उपयोग करना, और विशेष कार्यों के लिए प्रॉम्प्ट कैशिंग का लाभ उठाने वाले लॉन्ग कॉन्टेक्स्ट का उपयोग करना (जहाँ जटिल विश्लेषण या पूरे कोड की समीक्षा की आवश्यकता होती है) मुख्यधारा का डिज़ाइन बन गया है।

10. मल्टीमॉडल प्रोसेसिंग क्षमताओं की तुलना

अगली पीढ़ी के AI एप्लिकेशन को केवल पाठ को ही नहीं, बल्कि छवियों, ऑडियो और वीडियो को सीधे समझने की क्षमता की आवश्यकता होगी।

sequenceDiagram participant User as "उपयोगकर्ता" participant Client as "फ्रंटएंड ऐप" participant API as "LLM API (मल्टीमॉडल)" User->>Client: Upload Video & Text Prompt Client->>API: Send Video Bytes/URI + Text Note over API: Video chunking & Audio separation Note over API: Multimodal Embedding Model API-->>Client: Return Text Summary & Timestamps Client-->>User: Display Insights

OpenAI (GPT-4o): इसमें छवि पहचान की सटीकता बहुत अधिक है, और यह हस्तलिखित रेखाचित्रों (handwritten drawings) और जटिल ग्राफ़ को पढ़ने में उत्कृष्ट है। Realtime API का उपयोग करने वाला इसका अल्ट्रा-लो लेटेंसी (कुछ सौ मिलीसेकंड) नेटिव वॉयस इंटरेक्शन भी काफी शक्तिशाली है।
Google (Gemini 1.5 Pro): वीडियो विश्लेषण में यह बाकियों को पछाड़ देता है। आप 1 घंटे की वीडियो फ़ाइल (फ्रेम + ऑडियो) को सीधे इनपुट कर सकते हैं और बहुत विशिष्ट प्रश्नों का उत्तर पा सकते हैं जैसे, “12 मिनट 45 सेकंड पर स्क्रीन के दाईं ओर दिखाई देने वाले व्यक्ति के पास मौजूद दस्तावेज़ का शीर्षक क्या है?”
Anthropic (Claude 3.5 Sonnet): छवि पहचान (Vision) क्षमता GPT-4o के समान स्तर पर बहुत उत्कृष्ट है। फ्रंट-एंड विकास सहायता में यह बेजोड़ ताकत दिखाता है, जैसे कि UI स्क्रीनशॉट प्रदान करना और यह पूछना, “इस स्क्रीन के लिए React घटक कोड उत्पन्न करें।”

11. एंटरप्राइज़-स्तर की सुरक्षा और अनुपालन (Compliance)

जब कंपनियाँ उत्पादन वातावरण (production environments) में LLM API का उपयोग करती हैं, तो सबसे बड़ी चिंताएँ होती हैं: “क्या हमारे डेटा का उपयोग AI को प्रशिक्षित करने के लिए किया जाएगा?” और “क्या यह अनुपालन आवश्यकताओं को पूरा करता है?”

तीनों कंपनियों ने स्पष्ट रूप से कहा है कि वे मॉडल को प्रशिक्षित करने के लिए API के माध्यम से भेजे गए डेटा (प्रॉम्प्ट और प्रतिक्रियाओं) का उपयोग नहीं (Zero Data Retention / No Training on Customer Data) करती हैं (※ध्यान दें कि मुफ्त उपभोक्ता-सामना (consumer-facing) वेब चैट UI के लिए नियम अलग हैं)।

यदि सुरक्षा के और भी उच्च स्तर की आवश्यकता है:

OpenAI: Azure OpenAI Service के माध्यम से, आप Microsoft के एंटरप्राइज़-ग्रेड सुरक्षा, SLA और Azure Private Link का उपयोग करके एक निजी नेटवर्क कनेक्शन का लाभ उठा सकते हैं।
Google: Google Cloud Vertex AI के माध्यम से, आप VPC सर्विस कंट्रोल्स का उपयोग करके सख्त नेटवर्क अलगाव और CMEK (Customer-Managed Encryption Keys) के साथ डेटा सुरक्षा का उपयोग कर सकते हैं।
Anthropic: AWS Bedrock या Google Cloud Vertex AI के माध्यम से उपयोग करके, आप क्लाउड प्रदाताओं के मजबूत सुरक्षा बुनियादी ढांचे का लाभ उठा सकते हैं।

12. निष्कर्ष: उपयोग के मामले के अनुसार अंतिम चयन मार्गदर्शिका

अब तक हमने कई दृष्टिकोणों से तुलना की है, लेकिन अंततः “हमें कौन सा चुनना चाहिए?” इस प्रश्न का निष्कर्ष आपके उपयोग के मामले (use case) पर निर्भर करता है।

जटिल सॉफ़्टवेयर विकास, कोड जनरेशन, उन्नत तर्क: 👑 विजेता: Claude 3.5 Sonnet (Anthropic) यह वर्तमान में कोड के संदर्भ को समझने, रिफैक्टरिंग और स्वाभाविक, मानव जैसा पाठ लिखने में सर्वश्रेष्ठ प्रदर्शन प्रदान करता है। API की उपयोगिता और प्रॉम्प्ट कैशिंग की लागत दक्षता भी उत्कृष्ट है।
अति-लंबे दस्तावेज़ों का विश्लेषण, वीडियो/ऑडियो का बैच प्रसंस्करण: 👑 विजेता: Gemini 1.5 Pro (Google) इसकी 2 मिलियन टोकन की कॉन्टेक्स्ट विंडो इसका अद्वितीय हथियार है। उन कार्यों के लिए जहाँ आपको पूरे डेटा की समग्र तस्वीर (big picture) को समझने की आवश्यकता होती है, जैसे सैकड़ों पृष्ठों के PDF मैनुअल का विश्लेषण करना या लंबी मीटिंग रिकॉर्डिंग का सारांश देना, Gemini का कोई मुकाबला नहीं है।
बहुमुखी प्रतिभा (Versatility), निष्पादन गति (Execution Speed), और स्थिर संरचित आउटपुट (JSON): 👑 विजेता: GPT-4o / GPT-4o-mini (OpenAI) यह सभी कार्यों को सुचारू रूप से संभालता है और इसमें सबसे अधिक थर्ड-पार्टी टूल समर्थन है। जब आपको Structured Outputs का उपयोग करके विश्वसनीय JSON पार्सिंग या o1 मॉडल का उपयोग करके अति-उन्नत तार्किक तर्क की आवश्यकता होती है, तो OpenAI इकोसिस्टम अनिवार्य है।

मल्टी-मॉडल राउटिंग की सिफारिश

एक ही API (वेंडर लॉक-इन) पर निर्भर रहने के बजाय, भविष्य का रुझान एक “LLM राउटिंग” आर्किटेक्चर है जो कार्य की कठिनाई और महत्व के आधार पर मॉडल को गतिशील रूप से (dynamically) बदलता है। उदाहरण के लिए, उपयोगकर्ताओं के सरल प्रश्नों का उत्तर सस्ते और तेज़ GPT-4o-mini या Gemini 1.5 Flash के साथ देना, और कार्य को केवल तभी Claude 3.5 Sonnet पर वापस भेजना (fallback) जब जटिल प्रसंस्करण की आवश्यकता हो, लागत और प्रदर्शन के इष्टतम संतुलन को प्राप्त कर सकता है।

AI का विकास रुकने वाला नहीं है। कृपया प्रत्येक API की ताकत और कमजोरियों, साथ ही साथ उनकी स्थापत्य विशेषताओं (architectural characteristics) को गहराई से समझें, और लचीले और स्केलेबल AI एप्लिकेशन का निर्माण करें।

llama.cpp का उपयोग और C++ में कस्टमाइज़ेशन: एक परिचय

Fri, 11 Sep 2026 11:00:00 +0900

हाल के वर्षों में, बड़े भाषा मॉडल (Large Language Models या LLM) का विकास उल्लेखनीय रहा है, और उनके अनुप्रयोग का दायरा हर दिन बढ़ता जा रहा है। हालांकि, अरबों और दसियों अरबों मापदंडों (parameters) वाले मॉडल को स्थानीय वातावरण (local environment) में चलाने के लिए आमतौर पर विशाल VRAM वाले हाई-एंड GPU की आवश्यकता होती है। इस “हार्डवेयर बाधा” को तोड़ते हुए सामान्य PC, Mac और यहां तक कि Raspberry Pi जैसे उपकरणों पर LLM का व्यावहारिक अनुमान (inference) संभव बनाने वाला टूल llama.cpp है।

इस लेख में, हम न केवल कमांड लाइन टूल के उपयोग पर चर्चा करेंगे, बल्कि इसकी मूलभूत तकनीक ggml के आर्किटेक्चर, ट्रांसफॉर्मर और क्वांटाइज़ेशन (Quantization) की गणितीय पृष्ठभूमि, और C++ API का उपयोग करके अपने स्वयं के एप्लिकेशन में LLM को शामिल करने और कस्टमाइज़ करने के तरीकों के बारे में इंजीनियरों के लिए अत्यंत विस्तृत व्याख्या करेंगे।

1. llama.cpp और ggml का अवलोकन

llama.cpp Georgi Gerganov द्वारा विकसित C/C++ में लिखा गया एक हल्का LLM अनुमान इंजन (inference engine) है। यह मूल रूप से Meta के LLaMA मॉडल को Apple Silicon (M1/M2 Mac) पर उच्च गति से चलाने के उद्देश्य से बनाया गया था, लेकिन अब यह विभिन्न आर्किटेक्चर और मॉडलों का समर्थन करता है।

इसकी सबसे बड़ी विशेषता यह है कि यह बाहरी निर्भरता के बिना एक शुद्ध C/C++ कार्यान्वयन (implementation) है। चूंकि इसे Python या PyTorch जैसे विशाल इकोसिस्टम की आवश्यकता नहीं है और इसे एकल निष्पादन योग्य फ़ाइल (single executable file) के रूप में संकलित (compile) किया जा सकता है, इसलिए इसे डिप्लॉय करना बहुत आसान है।

इस llama.cpp का हृदय टेंसर गणितीय लाइब्रेरी ggml है। ggml को मशीन लर्निंग में मैट्रिक्स संचालन को CPU (और कुछ GPU) पर अत्यधिक अनुकूलित (optimize) करने के लिए शून्य से डिज़ाइन किया गया है।

1.1 llama.cpp इतना तेज़ क्यों है?

मेमोरी मैपिंग (mmap) का उपयोग: मॉडल के वज़न (weights) को मेमोरी में लोड करते समय, OS के mmap का उपयोग करके RAM में पूरा लोड करने से बचा जाता है, जिससे तेज़ स्टार्टअप और कम मेमोरी की खपत प्राप्त होती है।
SIMD निर्देशों का संपूर्ण अनुकूलन (Optimization): AVX2, AVX-512, ARM NEON, Apple AMX जैसे CPU-विशिष्ट निर्देश सेट का लाभ उठाकर मैट्रिक्स गुणा को अत्यधिक तेज़ किया गया है।
क्वांटाइज़ेशन (Quantization): 16-बिट फ़्लोटिंग-पॉइंट नंबर (FP16) के वज़न को 4-बिट, 5-बिट, और 8-बिट पूर्णांक (integers) में संकुचित करके मेमोरी बैंडविड्थ की बाधा को समाप्त किया गया है (विवरण नीचे दिया गया है)।

2. गणितीय पृष्ठभूमि: ट्रांसफॉर्मर (Transformer) और क्वांटाइज़ेशन (Quantization)

llama.cpp को गहराई से समझने के लिए, यह जानना आवश्यक है कि यह किन गणितीय सूत्रों (formulas) की गणना कर रहा है और यह गणनाओं का अनुमान कैसे लगाता है।

2.1 ट्रांसफॉर्मर अनुमान प्रक्रिया (Inference Process)

LLaMA जैसे मॉडल ऑटो-रिग्रेसिव (Auto-regressive) ट्रांसफॉर्मर डिकोडर आर्किटेक्चर को अपनाते हैं। टेक्स्ट जनरेशन का मूल Self-Attention तंत्र है।

इनपुट के रूप में छिपी हुई स्थिति (hidden state) के मैट्रिक्स $X \in \mathbb{R}^{N \times d}$ के लिए, क्वेरी $Q$, कुंजी $K$, और वैल्यू $V$ की गणना वज़न मैट्रिक्स (weight matrix) के गुणन से की जाती है।

$$ Q = X W_Q, \quad K = X W_K, \quad V = X W_V $$

यहाँ, Attention का आउटपुट इस प्रकार परिभाषित किया गया है:

$$ \text{Attention}(Q, K, V) = \text{softmax}\left(\frac{QK^T}{\sqrt{d_k}}\right)V $$

llama.cpp के अनुमान लूप (inference loop) में, अड़चन (bottleneck) यह विशाल मैट्रिक्स $W_Q, W_K, W_V$ और फीड-फॉरवर्ड नेटवर्क (FFN) के वज़न मैट्रिक्स और वेक्टर $X$ का गुणन है (क्योंकि जनरेशन चरण में प्रति टोकन संसाधित किया जाता है, $N=1$), यानी GEMV (General Matrix-Vector Multiplication)।

2.2 क्वांटाइज़ेशन (Quantization) का गणितीय आधार

मेमोरी एक्सेस बैंडविड्थ अनुमान (inference) में एक बाधा बन जाती है, इसके लिए वज़न मापदंडों (weight parameters) को छोटे बिट नंबरों में दर्शाने वाला क्वांटाइज़ेशन अनिवार्य है। हम llama.cpp में व्यापक रूप से उपयोग किए जाने वाले ब्लॉक-आधारित क्वांटाइज़ेशन (उदाहरण के लिए Q4_K या Q4_0) के मूल सिद्धांत की व्याख्या करेंगे।

मान लीजिए कि FP16 वज़न मैट्रिक्स $W$ का एक हिस्सा ब्लॉक $w = [w_1, w_2, \dots, w_B]$ है, जिसकी लंबाई $B$ (आमतौर पर 32 या 64) है। यह ब्लॉक 4-बिट पूर्णांक $q_i \in [-8, 7]$ और एकल स्केलिंग फैक्टर $\Delta$ (FP16 या FP32) के अनुमानित रूप में होता है।

$$ w_i \approx \Delta \times q_i $$

$\Delta$ का निर्धारण ब्लॉक में अधिकतम पूर्ण मान (absolute value) के आधार पर किया जाता है।

$$ \Delta = \frac{\max_i |w_i|}{7} $$

क्वांटाइज़्ड वज़न का उपयोग करके डॉट गुणनफल (dot product) $y = w \cdot x$ की गणना करते समय, इनपुट वेक्टर $x$ को भी उसी तरह क्वांटाइज़ करके $x_i \approx \Delta_x \times q_{x, i}$ माना जाता है:

$$ y = \sum_{i=1}^{B} w_i x_i \approx \Delta \Delta_x \sum_{i=1}^{B} q_i q_{x, i} $$

यह $\sum q_i q_{x, i}$ भाग शुद्ध पूर्णांक संचालन (pure integer arithmetic) बन जाता है, जिसे SIMD निर्देशों का उपयोग करके बहुत तेज़ी से समानांतर (parallel) रूप में गणना की जा सकती है। यही वह गणितीय रहस्य है जो llama.cpp को CPU पर आश्चर्यजनक गति प्रदान करता है।

3. आर्किटेक्चर और अनुमान प्रवाह (Inference Flow)

llama.cpp के आंतरिक कामकाज को समझने के लिए, नीचे दिया गया Mermaid आरेख (diagram) पूरे सिस्टम के आर्किटेक्चर और डेटा प्रवाह को दर्शाता है।

graph TD A["उपयोगकर्ता इनपुट (स्ट्रिंग)"] --> B["llama.cpp टोकनाइज़र"] B --> C["टोकन IDs (int32 ऐरे)"] C --> D["संदर्भ बफ़र (KV कैश)"] D --> E["ggml गणना ग्राफ"] E --> F["ट्रांसफॉर्मर लेयर्स"] subgraph "ggml इंजन" F --> G["सेल्फ-अटेंशन (RoPE)"] G --> H["फीड फॉरवर्ड नेटवर्क"] H --> F end F --> I["लॉजिट्स (शब्दावली का आकार)"] I --> J["सैम्पलर (टेम्परेचर, Top-K, Top-P)"] J --> K["चयनित टोकन ID"] K --> L["llama.cpp डिटोकनाइज़र"] L --> M["आउटपुट स्ट्रिंग"] K -. "ऑटो-रिग्रेसिव लूप" .-> D

टेक्स्ट जनरेशन एक ऑटो-रिग्रेसिव लूप है जहाँ प्रत्येक नया टोकन आउटपुट होने पर इसे KV Cache में अगले इनपुट के रूप में जोड़ा जाता है और फिर से गणना ग्राफ से गुज़रता है।

4. पर्यावरण सेटअप और बिल्ड विधि

llama.cpp को C++ प्रोजेक्ट में शामिल करने से पहले, आइए सबसे पहले सोर्स कोड को बिल्ड करें।

4.1 रिपॉजिटरी की क्लोनिंग

1
2


git clone https://github.com/ggerganov/llama.cpp.git
cd llama.cpp

4.2 CMake का उपयोग करके बिल्ड करना

जब C++ प्रोजेक्ट के रूप में इसे अन्य ऐप्स में शामिल किया जाता है, तो CMake का उपयोग करना सबसे मानक है। प्लेटफ़ॉर्म-विशिष्ट एक्सेलेरेटर (बैकएंड) को सक्षम करके, गणनाओं को तेज़ किया जा सकता है।

केवल CPU (बुनियादी बिल्ड):

1
2
3


mkdir build && cd build
cmake ..
cmake --build . --config Release -j 8

NVIDIA GPU (CUDA) का उपयोग करते समय:

1
2
3


mkdir build && cd build
cmake .. -DGGML_CUDA=ON
cmake --build . --config Release -j 8

Apple Silicon (Metal) का उपयोग करते समय:

1
2
3


mkdir build && cd build
cmake .. -DGGML_METAL=ON
cmake --build . --config Release -j 8

यदि बिल्ड सफल होता है, तो build/bin/ निर्देशिका में llama-cli जैसी निष्पादन योग्य फ़ाइलें और बाद में वर्णित C++ API के साथ लिंक करने के लिए llama लाइब्रेरी (और ggml लाइब्रेरी) तैयार हो जाएँगी।

5. C++ में कस्टमाइज़ेशन परिचय: llama.cpp API का उपयोग

यहाँ से हम इस लेख के मुख्य विषय पर चर्चा करेंगे: C++ कोड के माध्यम से llama.cpp का नियंत्रण। केवल कमांड लाइन टूल का उपयोग करने के अलावा, अपने स्वयं के एप्लिकेशन (जैसे गेम इंजन, डेस्कटॉप ऐप, एंबेडेड सिस्टम, आदि) में LLM को शामिल करने के लिए C++ API को सीधे कॉल करना आवश्यक है।

llama.cpp मुख्य रूप से llama.h नामक हेडर फ़ाइल के माध्यम से C भाषा इंटरफ़ेस प्रदान करता है। C++ से कॉल करते समय भी इसी इंटरफ़ेस का उपयोग किया जाता है।

5.1 न्यूनतम आवश्यक इन्क्लूड और सेटिंग्स

अपने प्रोजेक्ट में llama.cpp का उपयोग करते समय, निम्नलिखित शामिल करें:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14


#include "llama.h"
#include <iostream>
#include <vector>
#include <string>
#include <stdexcept>

// त्रुटि प्रबंधन के लिए मैक्रो
#define LLAMA_ASSERT(x) \
 do { \
 if (!(x)) { \
 std::cerr << "Assertion failed: " << #x << std::endl; \
 std::terminate(); \
 } \
 } while (0)

5.2 मॉडल लोड करना और संदर्भ (Context) इनिशियलाइज़ करना

सबसे पहले, .gguf प्रारूप की मॉडल फ़ाइल लोड करें और अनुमान के लिए संदर्भ (मेमोरी स्पेस और KV कैश) सुरक्षित करें।

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36


int main(int argc, char ** argv) {
 if (argc < 2) {
 std::cerr << "Usage: " << argv[0] << " <model.gguf>" << std::endl;
 return 1;
 }
 std::string model_path = argv[1];

 // 1. बैकएंड का इनिशियलाइज़ेशन (CPU/GPU आदि का पर्यावरण सेटअप)
 llama_backend_init();

 // 2. मॉडल पैरामीटर्स के डिफ़ॉल्ट सेटिंग्स प्राप्त करें
 llama_model_params model_params = llama_model_default_params();
 model_params.n_gpu_layers = 35; // GPU में ऑफ़लोड करने के लिए लेयर्स की संख्या

 // 3. मॉडल को लोड करना
 llama_model * model = llama_load_model_from_file(model_path.c_str(), model_params);
 if (model == nullptr) {
 std::cerr << "Failed to load model" << std::endl;
 return 1;
 }

 // 4. संदर्भ पैरामीटर सेट करना
 llama_context_params ctx_params = llama_context_default_params();
 ctx_params.n_ctx = 2048; // अधिकतम संदर्भ आकार (टोकनों की संख्या)
 ctx_params.n_threads = 8; // अनुमान (inference) के लिए उपयोग किए जाने वाले CPU थ्रेड्स की संख्या

 // 5. संदर्भ (Context) बनाना
 llama_context * ctx = llama_new_context_with_model(model, ctx_params);
 if (ctx == nullptr) {
 std::cerr << "Failed to create context" << std::endl;
 llama_free_model(model);
 return 1;
 }

 std::cout << "Model and context loaded successfully!" << std::endl;
 // ... आगे की प्रक्रिया

5.3 प्रॉम्प्ट का टोकनाइज़ेशन (Tokenization)

LLM टेक्स्ट को सीधे नहीं समझता, बल्कि इसे इंटीजर ID (टोकन) के अनुक्रम के रूप में संसाधित करता है। इनपुट स्ट्रिंग को टोकन में बदलना आवश्यक है।

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23


 std::string prompt = "Q: जापान की राजधानी कहाँ है?\nA:";
 std::vector<llama_token> tokens_list;
 tokens_list.resize(prompt.length() + 4); // अतिरिक्त जगह के साथ बफ़र आकार

 // क्या शुरुआत में विशेष टोकन (BOS: Begin of Sequence आदि) जोड़ना है
 bool add_special = true;
 // स्ट्रिंग को टोकन ID की ऐरे में बदलना
 int n_tokens = llama_tokenize(
 model,
 prompt.c_str(),
 prompt.length(),
 tokens_list.data(),
 tokens_list.size(),
 add_special,
 false // parse_special
 );

 if (n_tokens < 0) {
 // यदि बफ़र पर्याप्त नहीं है तो पुनः आवंटन (reallocation) करके पुनः प्रयास करना आवश्यक है (सरलता के लिए यहाँ छोड़ा गया है)
 std::cerr << "Failed to tokenize prompt" << std::endl;
 return 1;
 }
 tokens_list.resize(n_tokens);

5.4 अनुमान लूप और सैंपलिंग

टोकन को मॉडल में इनपुट करें, अगले टोकन का संभाव्यता वितरण (Probability Distribution या Logits) प्राप्त करें, और वहां से सैंपलिंग करके अगला टोकन निर्धारित करने वाला लूप बनाएँ।

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72


 // उत्पन्न किए जाने वाले अधिकतम टोकनों की संख्या
 const int max_gen_tokens = 100;

 // बैच मूल्यांकन के लिए संरचना को इनिशियलाइज़ करना
 llama_batch batch = llama_batch_init(512, 0, 1);

 // प्रॉम्प्ट के टोकन को बैच में जोड़ना
 for (size_t i = 0; i < tokens_list.size(); i++) {
 llama_batch_add(batch, tokens_list[i], i, { 0 }, false);
 }
 // केवल प्रॉम्प्ट के अंतिम टोकन पर लॉजिट्स (भविष्यवाणी परिणाम) आउटपुट करने के लिए सेट करें
 batch.logits[batch.n_tokens - 1] = true;

 // पहला मूल्यांकन (प्रॉम्प्ट को मॉडल में फीड करना)
 if (llama_decode(ctx, batch) != 0) {
 std::cerr << "llama_decode() failed" << std::endl;
 return 1;
 }

 int n_cur = batch.n_tokens; // वर्तमान संदर्भ की लंबाई
 int n_decode = 0;

 std::cout << "\nOutput: ";

 // सैम्पलर संदर्भ का इनिशियलाइज़ेशन (Temperature, Top-K, Top-P आदि की सेटिंग्स)
 llama_sampler * smpl = llama_sampler_chain_init(llama_sampler_chain_default_params());
 llama_sampler_chain_add_top_k(smpl, 40);
 llama_sampler_chain_add_top_p(smpl, 0.9f, 1);
 llama_sampler_chain_add_temp(smpl, 0.7f);
 llama_sampler_chain_add_dist(smpl, 1234); // सीड वैल्यू

 while (n_decode < max_gen_tokens) {
 // 1. सैंपलिंग: वर्तमान संदर्भ के आधार पर अगले टोकन की भविष्यवाणी
 llama_token new_token_id = llama_sampler_sample(smpl, ctx, -1);

 // 2. यदि टोकन EOS (End of Sequence) है तो लूप समाप्त करें
 if (llama_token_is_eog(model, new_token_id)) {
 break;
 }

 // 3. टोकन को स्ट्रिंग (टेक्स्ट) में डिकोड करें और प्रदर्शित करें
 char buf[128];
 int n_chars = llama_token_to_piece(model, new_token_id, buf, sizeof(buf), 0, false);
 if (n_chars > 0) {
 std::cout << std::string(buf, n_chars) << std::flush;
 }

 // 4. नए उत्पन्न टोकन को अगले बैच के रूप में तैयार करें
 llama_batch_clear(batch);
 llama_batch_add(batch, new_token_id, n_cur, { 0 }, true);

 // 5. मॉडल का मूल्यांकन (KV कैश अपडेट करें, और अगले की भविष्यवाणी करें)
 if (llama_decode(ctx, batch) != 0) {
 std::cerr << "Failed to evaluate" << std::endl;
 break;
 }

 n_cur += 1;
 n_decode += 1;
 }

 std::cout << std::endl;

 // क्लीनअप
 llama_sampler_free(smpl);
 llama_batch_free(batch);
 llama_free(ctx);
 llama_free_model(model);
 llama_backend_free();

 return 0;
}

6. उन्नत कस्टमाइज़ेशन उदाहरण: C++ के माध्यम से लॉजिट्स हेरफेर और पेनाल्टी नियंत्रण

सिर्फ सरल टेक्स्ट जनरेशन तक सीमित न रहकर, जब किसी विशेष प्रारूप (जैसे केवल JSON) में आउटपुट को बाध्य करना हो, या विशिष्ट प्रतिबंधित शब्दों के आउटपुट को रोकना हो, तो सैंपलिंग से पहले के लॉजिट्स (Logits) को सीधे C++ की ओर से नियंत्रित किया जाता है।

आप प्रत्येक टोकन के आउटपुट होने से ठीक पहले रॉ स्कोर की ऐरे (संभाव्यता में परिवर्तित होने से पहले का मान) प्राप्त कर सकते हैं।

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11


// अनुमान के तुरंत बाद, और सैंपलिंग से पहले कच्चे (raw) लॉजिट ऐरे को प्राप्त करना
float * logits = llama_get_logits_ith(ctx, batch.n_tokens - 1);
int n_vocab = llama_n_vocab(model);

// प्रतिबंधित टोकन ID सूची (उदाहरण के लिए 1234, 5678)
std::vector<llama_token> forbidden_tokens = { 1234, 5678 };

// निषिद्ध टोकन की उपस्थिति की संभावना को 0 (Logit को माइनस इन्फिनिटी) पर सेट करना
for (llama_token bad_tok : forbidden_tokens) {
 logits[bad_tok] = -INFINITY;
}

इस तरह, C++ API को सीधे हैंडल करके, “अनुमान चक्र के प्रत्येक माइक्रोसेकंड-स्तर पर हस्तक्षेप” संभव हो जाता है, जो LangChain या Python के माध्यम से प्राप्त करना मुश्किल है या जिसमें अधिक ओवरहेड होता है।

7. परफॉर्मेंस ट्यूनिंग के रहस्य

C++ में कार्यान्वयन समाप्त करने के बाद, वास्तविक संचालन (production) के लिए गति को अधिकतम सीमा तक बढ़ाने के लिए यहां कुछ जांच बिंदु (checkpoints) दिए गए हैं।

बैच प्रोसेसिंग ऑप्टिमाइज़ेशन: कई उपयोगकर्ताओं के अनुरोधों को एक साथ संसाधित करते समय, llama_batch में कई अनुक्रमों को शामिल करें और एक बार में llama_decode को कॉल करें (Continuous Batching)। इससे मेमोरी एक्सेस साझा চরম हो सकता है और थ्रूपुट में काफी सुधार हो सकता है।
फ्लैश अटेंशन (Flash Attention) सक्षम करना: संदर्भ पैरामीटर में ctx_params.flash_attn = true; सेट करके, मेमोरी उपयोग को कम करते हुए अटेंशन गणना को तेज़ किया जा सकता है। लंबे संदर्भ (हजारों टोकन) से निपटने के दौरान यह एक आवश्यक सेटिंग है।
NUMA सपोर्ट: मल्टी-सॉकेट सर्वर वातावरण में llama_backend_init() से पहले NUMA सेटिंग्स को उचित रूप से कॉन्फ़िगर करके मेमोरी एक्सेस लेटेंसी को कम किया जा सकता है।

8. निष्कर्ष

इस लेख में, हमने llama.cpp की गणितीय पृष्ठभूमि से शुरुआत की, इसके आर्किटेक्चर की व्याख्या की, और C++ API का पूरा उपयोग करके कस्टम अनुमान इंजन (custom inference engine) बनाने के तरीके के बारे में विस्तार से बताया।

हालांकि Python इकोसिस्टम प्रोटोटाइपिंग के लिए बहुत सुविधाजनक है, लेकिन एज डिवाइस डिप्लॉयमेंट, गेम्स में एकीकरण (integration), और उत्पादन (production) वातावरण जहां रियल-टाइम प्रोसेसिंग की आवश्यकता होती है, वहां C/C++ आधारित llama.cpp का प्रत्यक्ष नियंत्रण अपना अत्यधिक प्रभाव दिखाता है।

आप भी कृपया स्वयं C++ कोड लिखने का प्रयास करें, और स्थानीय वातावरण (local environment) में LLM को स्वतंत्र रूप से हेरफेर करने के आनंद का अनुभव करें।

संदर्भ लिंक (Reference Links)

llama.cpp Official Repository

ggml - Tensor Library

Attention Is All You Need (Vaswani et al., 2017)

【2026 का नवीनतम】विंडोज़ वातावरण में लोकल LLM चलाने की संपूर्ण मार्गदर्शिका

Fri, 11 Sep 2026 10:00:00 +0900

1. प्रस्तावना: अब विंडोज़ पर लोकल LLM क्यों?

2026 तक, जनरेटिव AI और लार्ज लैंग्वेज मॉडल (LLM) का विकास एक बड़ा प्रतिमान बदलाव (paradigm shift) दिखा रहा है, जो क्लाउड पर विशाल API सेवाओं से हटकर व्यक्तिगत पीसी और ऑन-प्रिमाइसेस वातावरण में चलने वाले ‘लोकल LLM’ की ओर बढ़ रहा है। OpenAI का GPT-5 और Anthropic का Claude 3.5 जैसे क्लाउड AI बहुत शक्तिशाली हैं, लेकिन कंपनियाँ और व्यक्ति अपना सारा डेटा क्लाउड पर नहीं भेज सकते हैं। गोपनीयता (Privacy), सुरक्षा, विलंबता (latency), और दीर्घकालिक व टिकाऊ लागत के दृष्टिकोण से लोकल LLM की मांग पहले से कहीं अधिक तेजी से बढ़ रही है।

विशेष रूप से विंडोज़ वातावरण में लोकल LLM के इकोसिस्टम का विकास उल्लेखनीय रहा है। कुछ साल पहले तक “AI विकास और निष्पादन (execution) का मतलब Linux है” यह एक सामान्य बात थी, लेकिन 2026 में विंडोज़ एक बहुत ही शक्तिशाली और सुलभ AI प्लेटफॉर्म में बदल गया है।

इस लेख में, 2026 के नवीनतम तकनीकी रुझानों को ध्यान में रखते हुए, विंडोज़ वातावरण में लोकल LLM के निर्माण, संचालन और अनुकूलन (optimization) के लिए एक संपूर्ण मार्गदर्शिका प्रदान की गई है। शुरुआती लोगों के लिए Ollama का उपयोग करके सरल सेटअप से लेकर, उन्नत उपयोगकर्ताओं के लिए llama.cpp का उपयोग करके अत्यधिक अनुकूलन (extreme optimization), VRAM गणना के गणितीय दृष्टिकोण, आर्किटेक्चर की गहरी समझ, और लोकल फाइन-ट्यूनिंग तक, हम इसे विस्तार से समझाएंगे।

1.1 2026 में लोकल LLM के तकनीकी रुझान

वर्तमान लोकल LLM इकोसिस्टम को आकार देने वाले प्रमुख रुझान इस प्रकार हैं:

GGUF फॉर्मेट का पूर्ण उपयोग: GGUF (GPT-Generated Unified Format), जो मेटाडेटा और टेंसर को एक ही फ़ाइल में एकीकृत करता है, अब पूरी तरह से वास्तविक मानक (de facto standard) बन गया है। इसके कारण, केवल Hugging Face से एक फ़ाइल डाउनलोड करके इसे किसी भी वातावरण में चलाना संभव हो गया है।
MoE (Mixture of Experts) आर्किटेक्चर का लोकतंत्रीकरण (Democratization): छोटे लेकिन उच्च-प्रदर्शन वाले कई MoE मॉडल जारी किए गए हैं। अनुमान (inference) के दौरान केवल कुछ विशेषज्ञों (experts) को सक्रिय करके, यह उपभोक्ता पीसी (consumer PC) के कम्प्यूटेशनल भार को कम रखते हुए विशाल मॉडलों के बराबर प्रदर्शन दे रहा है।
इन्फरेंस इंजन (Inference Engine) का उच्च अमूर्तीकरण (Abstraction) और अनुकूलन: Ollama, LM Studio, AnythingLLM जैसे टूल बहुत परिष्कृत हो गए हैं, जिससे उपयोगकर्ताओं को CUDA ड्राइवर इंस्टॉल करने जैसी जटिल निर्भरताओं (dependencies) की चिंता करने की आवश्यकता नहीं है। इसके अलावा, FlashAttention 3 के विंडोज़ नेटिव समर्थन (native support) से इन्फरेंस गति में नाटकीय रूप से सुधार हुआ है।
NPU का उपयोग और Windows Copilot+ PC का उदय: NPU (Neural Processing Unit) का उपयोग करके छोटे LLM (SLM: Small Language Models) को कम बिजली की खपत के साथ चलाने की तकनीक व्यावहारिक चरण में प्रवेश कर चुकी है, यहाँ तक कि उन लैपटॉप में भी जिनमें GPU नहीं है।

2. हार्डवेयर आवश्यकताएँ और OS की तैयारी

लोकल LLM को व्यावहारिक गति (15-30 टोकन प्रति सेकंड या अधिक) पर चलाने के लिए हार्डवेयर का चयन सबसे महत्वपूर्ण है।

2.1 अनुशंसित हार्डवेयर कॉन्फ़िगरेशन

AI PC के विकास के साथ, आवश्यक विनिर्देश (specifications) भी बदल रहे हैं।

OS: Windows 11 Pro (24H2 या बाद का संस्करण)। WSL2 की पूर्ण कार्यक्षमता और उन्नत मेमोरी प्रबंधन, साथ ही नवीनतम DirectML API का उपयोग करने के लिए यह आवश्यक है।
CPU: Intel Core Ultra 200 सीरीज़ या उससे ऊपर, या AMD Ryzen 9000 सीरीज़ या उससे ऊपर। यदि CPU इन्फरेंस का भी उपयोग किया जा रहा है, तो ब्रॉडबैंड मेमोरी कम्युनिकेशन अनिवार्य है।
RAM: न्यूनतम 32GB, 64GB या उससे अधिक अनुशंसित। मुख्य मेमोरी की बैंडविड्थ (MB/s) CPU इन्फरेंस या ऑफलोडिंग के दौरान एक निर्णायक अड़चन (bottleneck) बन जाती है। DDR5-6000 या उच्चतर गति वाली मेमोरी आदर्श है।
GPU: NVIDIA RTX 4000/5000 सीरीज़। लोकल LLM में सबसे महत्वपूर्ण कम्प्यूटेशनल प्रदर्शन नहीं बल्कि “VRAM क्षमता” है।
- एंट्री लेवल: RTX 4060 Ti (16GB संस्करण) - सबसे अच्छा कॉस्ट-परफॉरमेंस। 8B से 14B क्लास के मॉडलों के लिए आदर्श।
- मिड-रेंज: RTX 4070 Ti SUPER (16GB) / RTX 4080 SUPER (16GB)
- हाई-एंड: RTX 4090 (24GB) / RTX 5090 (32GB) - 30B से 70B क्लास के क्वांटाइज्ड मॉडलों (quantized models) को चलाने के लिए आवश्यक।
स्टोरेज: PCIe Gen4 या Gen5 NVMe SSD। यह दसियों GB के मॉडलों के लोड होने के समय को काफी कम कर देता है।

2.2 WSL2 (Windows Subsystem for Linux 2) सेटअप

कई GUI टूल मूल रूप से (natively) विंडोज़ पर काम करते हैं, लेकिन Python का उपयोग करके विकास करने, नवीनतम टूल को संकलित (compile) करने और बाद में बताए गए LoRA फाइन-ट्यूनिंग के लिए WSL2 बहुत उपयोगी है। नवीनतम Windows 11 वातावरण में, केवल होस्ट साइड पर NVIDIA ड्राइवर स्थापित करके WSL2 से पारदर्शी (transparently) रूप से GPU (CUDA) का उपयोग किया जा सकता है।

एडमिनिस्ट्रेटर प्रिविलेज (Administrator privileges) के साथ PowerShell खोलें और निम्नलिखित चलाएँ:

1
2
3
4
5


# WSL2 और नवीनतम Ubuntu इंस्टाल करें
wsl --install -d Ubuntu-24.04

# कर्नेल अपडेट करें
wsl --update

इंस्टॉलेशन के बाद, WSL2 टर्मिनल में nvidia-smi चलाएँ। यदि GPU सही तरीके से पहचाना जाता है, तो यह सफल है।

3. लोकल LLM आर्किटेक्चर और इन्फरेंस मैकेनिज्म

यह समझना कि लोकल वातावरण में मॉडल टेक्स्ट कैसे उत्पन्न करता है और इसकी आंतरिक संरचना क्या है, समस्या निवारण (troubleshooting) और अनुकूलन (optimization) के लिए बहुत उपयोगी है।

नीचे दिया गया Mermaid आरेख एक सामान्य लोकल LLM के इन्फरेंस पाइपलाइन को दर्शाता है।

graph TD User["यूज़र इनपुट (प्रॉम्प्ट)"] --> Tokenizer["टोकेनाइज़र (Tokenizer)"] Tokenizer --> Embedding["एम्बेडिंग लेयर (Embedding)"] subgraph "Transformer Block (x Layers)" Embedding --> Attn["सेल्फ-अटेंशन (Self-Attention)"] Attn --> KVCache["KV कैश (Key/Value स्टोरेज)"] Attn --> FFN["फीड-फॉरवर्ड नेटवर्क (FFN)"] end FFN --> Logits["लॉजिट कैलकुलेशन (Logits)"] Logits --> Sampler["सैंपलर (Temperature, Top-K, Top-P)"] Sampler --> OutputToken["आउटपुट टोकन"] OutputToken --> |"ऑटोरिग्रेसिव जनरेशन"| Tokenizer OutputToken --> Decoder["डिटोकेनाइज़र (Detokenizer)"] Decoder --> FinalOutput["अंतिम आउटपुट टेक्स्ट"]

3.1 2 चरण (Phases): Prefill और Decode

LLM टेक्स्ट जनरेशन को अलग-अलग कम्प्यूटेशनल विशेषताओं वाले दो चरणों में विभाजित किया गया है।

Prefill (प्रॉम्प्ट प्रोसेसिंग) चरण: यह वह चरण है जहाँ पूरे इनपुट प्रॉम्प्ट को एक साथ प्रोसेस किया जाता है और समझा जाता है। चूंकि समानांतर गणना (parallel computation) संभव है, इसलिए GPU की कम्प्यूटेशनल क्षमता (FLOPS) सीधे गति से संबंधित है। यदि प्रॉम्प्ट लंबा है, तो इस चरण में कुछ सेकंड लग सकते हैं।
Decode (टोकन जनरेशन) चरण: यह वह चरण है जो एक-एक करके टोकन की भविष्यवाणी करता है और इसे अगले इनपुट (autoregressive) में भेजता है। इस चरण में समानांतर गणना सीमित है, इसलिए GPU का VRAM बैंडविड्थ (Memory Bandwidth) एक निर्णायक अड़चन (bottleneck) बन जाता है।

4. VRAM खपत की गणना और मॉडल साइज़ की गणितीय समझ

“मेरे पीसी पर कौन सा मॉडल चलेगा?” इसका सही अंदाजा लगाने के लिए, आपको VRAM गणना सूत्र को समझने की आवश्यकता है। जब VRAM की कमी के कारण सिस्टम मेमोरी (RAM) पर फॉलबैक होता है, तो इन्फरेंस की गति 10 से 100 गुना धीमी हो जाती है।

4.1 पैरामीटर आकार के आधार पर बेस VRAM

यह मॉडल वेट (weights) को VRAM में लोड करने के लिए आवश्यक मेमोरी की मात्रा है। इसकी गणना मॉडल आकार $P$ (पैरामीटर्स की संख्या, इकाई: 1 बिलियन = 1B) और प्रति पैरामीटर बाइट्स की संख्या $B$ का उपयोग करके की जाती है।

$$ V_{base} = P \times B \quad \text{(GB)} $$

उदाहरण के लिए, यदि 8B (8 बिलियन) पैरामीटर वाले मॉडल को FP16 (हाफ-प्रिसिजन फ्लोटिंग-पॉइंट, 16 बिट्स = 2 बाइट्स) में लोड किया जाता है:

$$ V_{base} = 8 \times 2 = 16 \text{ GB} $$

यानी 16GB VRAM वाले GPU में भी केवल मॉडल को लोड करने से ही वह लगभग अपनी सीमा तक पहुँच जाएगा।

4.2 क्वांटाइजेशन (Quantization) का जादू

यहीं पर “क्वांटाइजेशन” आता है। पैरामीटर्स की सटीकता (precision) को कम करके, मॉडल का आकार नाटकीय रूप से कम हो जाता है। सबसे आम 4-बिट क्वांटाइजेशन (उदा: Q4_K_M) के मामले में, यह प्रति पैरामीटर औसतन लगभग 0.55 बाइट्स होता है।

$$ V_{base\_4bit} = 8 \times 0.55 = 4.4 \text{ GB} $$

इस प्रकार, 16GB VRAM के साथ, आप 8B मॉडल को बहुत आसानी से चला सकते हैं।

4.3 KV कैश की गणना (GQA समर्थित संस्करण)

इन्फरेंस के दौरान, पिछले संदर्भ (context) को बनाए रखने के लिए “KV कैश” VRAM की खपत करता है। Llama 3 जैसे नवीनतम मॉडलों में मेमोरी बचाने के लिए GQA (Grouped Query Attention) का उपयोग किया जाता है।

KV कैश की खपत $V_{kv}$ (गीगाबाइट में) निम्नलिखित सूत्र द्वारा व्यक्त की जा सकती है:

$$ V_{kv} = 2 \times b \times s \times l \times \left( \frac{h_{kv}}{h_q} \right) \times h_q \times d \times B_{kv} \div 10^9 $$

इसे सरल करते हुए, हम की (key) और वैल्यू (value) के हेड्स की संख्या $h_{kv}$ का उपयोग करके आसानी से गणना कर सकते हैं:

$$ V_{kv} = 2 \times b \times s \times l \times h_{kv} \times d \times B_{kv} \div 10^9 $$

जहाँ:

$b$: बैच साइज़ (व्यक्तिगत लोकल उपयोग के लिए आमतौर पर 1)
$s$: सीक्वेंस लंबाई (संदर्भ लंबाई, उदा: 8192)
$l$: लेयर्स की संख्या (उदा: 32)
$h_{kv}$: KV हेड्स की संख्या (उदा: 8)
$d$: प्रति हेड डायमेंशन (उदा: 128)
$B_{kv}$: KV कैश के बाइट्स (FP16 के लिए 2)

गणना का उदाहरण (Llama 3 8B, कॉन्टेक्स्ट 8192, FP16 कैश): $V_{kv} = 2 \times 1 \times 8192 \times 32 \times 8 \times 128 \times 2 \div 10^9 \approx 1.07 \text{ GB}$

ध्यान दें कि संदर्भ की लंबाई $s$ जितनी लंबी होगी, आवश्यक VRAM उतना ही अधिक रैखिक (linearly) रूप से बढ़ेगा।

5. अभ्यास 1: Ollama का उपयोग करके सबसे तेज़ और सबसे छोटा सेटअप

अब जब हम थ्योरी समझ चुके हैं, तो आइए वास्तव में विंडोज़ वातावरण में LLM चलाएं। 2026 तक, “Ollama” सबसे यूज़र-फ्रेंडली टूल है। यह Docker की तरह ही एक बहुत ही सहज (intuitive) CLI प्रदान करता है।

5.1 इंस्टालेशन और रन (Installation and Execution)

Ollama आधिकारिक वेबसाइट से विंडोज़ इंस्टॉलर डाउनलोड करें और इसे चलाएं।
PowerShell खोलें और निम्नलिखित कमांड दर्ज करें। यहाँ, हम जापानी समर्थित llama3:8b का उपयोग करेंगे।

1

ollama run llama3:8b

पहली बार चलाने पर, मॉडल डाउनलोड होगा। इसके पूरा होने के बाद, आप सीधे टर्मिनल में चैट कर सकते हैं।

5.2 Modelfile का उपयोग करके कस्टम AI बनाना

आप आसानी से एक विशिष्ट व्यक्तित्व (persona) वाला AI बना सकते हैं। किसी भी स्थान पर एक Modelfile बनाएं।

1
2
3
4
5
6
7
8
9


FROM llama3:8b

SYSTEM """
आप एक अत्यंत प्रतिभाशाली सीनियर सॉफ्टवेयर इंजीनियर हैं।
उपयोगकर्ता के प्रश्नों का उत्तर हमेशा कोड उदाहरणों के साथ तार्किक और संक्षिप्त रूप में दें।
"""

PARAMETER temperature 0.3
PARAMETER num_ctx 8192

अपने स्वयं के मॉडल को बिल्ड (build) करने और चलाने के लिए निम्नलिखित कमांड चलाएँ:

1
2


ollama create SeniorDev -f ./Modelfile
ollama run SeniorDev

5.3 बाहरी ऐप्स (AI संपादक) से उपयोग

Ollama http://localhost:11434 पर OpenAI संगत API एंडपॉइंट को एक्सपोज़ करता है। Cursor या Continue.dev जैसे VS Code एक्सटेंशन के बैकएंड सेटिंग्स में उपरोक्त URL निर्दिष्ट करके और मॉडल के नाम के रूप में SeniorDev आदि निर्दिष्ट करके, आपको मुफ्त में एक शक्तिशाली लोकल कोडिंग असिस्टेंट मिल जाता है।

6. अभ्यास 2: llama.cpp के साथ अत्यधिक प्रदर्शन ट्यूनिंग (Extreme Performance Tuning)

यदि आप विस्तृत मेमोरी प्रबंधन चाहते हैं या नवीनतम फॉर्मेट्स (जैसे EXL2 और IQ क्वांटाइजेशन) को जल्दी आज़माना चाहते हैं, तो कोर इंजन llama.cpp का सीधे उपयोग करें।

6.1 llama.cpp के लिए बिल्ड प्रक्रिया

विंडोज़ वातावरण में, CUDA Toolkit और CMake का उपयोग करके स्रोत (source) से बिल्ड करना सबसे अच्छा तरीका है।

1
2
3
4
5
6
7
8


git clone https://github.com/ggerganov/llama.cpp
cd llama.cpp
mkdir build
cd build

# CUDA सपोर्ट के लिए कॉन्फ़िगर और कंपाइल करें
cmake .. -DLLAMA_CUBLAS=ON -DBUILD_SHARED_LIBS=OFF
cmake --build . --config Release -j 16

6.2 सर्वर मोड में एडवांस स्टार्टअप

मॉडल को होस्ट करने के लिए बिल्ड किए गए llama-server.exe का उपयोग करें।

1
2
3
4
5
6
7


.\bin\Release\llama-server.exe `
 --model "C:\models\Llama-3-8B-Instruct.Q4_K_M.gguf" `
 --ctx-size 8192 `
 --n-gpu-layers 99 `
 --threads 8 `
 --flash-attn `
 --port 8080

--n-gpu-layers 99: जहाँ तक संभव हो सभी लेयर्स को GPU VRAM में ऑफलोड करता है।
--flash-attn: FlashAttention 3 को सक्षम करता है, इन्फरेंस गति में सुधार करता है और KV कैश की VRAM खपत को कम करता है।

7. GUI फ्रंटएंड: LM Studio और लोकल RAG का निर्माण

यदि आप कमांड लाइन का उपयोग नहीं करना चाहते हैं या RAG (Retrieval-Augmented Generation) को सहजता (intuitively) से करना चाहते हैं, तो GUI का उपयोग करें।

7.1 LM Studio

LM Studio एक बेहतरीन एप्लिकेशन है जो मॉडल सर्च, डाउनलोड, सिस्टम आवश्यकता पूर्व-जाँच और चैट UI को एक जगह मिलाता है। ऐप में “Local Server” बटन दबाने से ही OpenAI संगत API शुरू हो जाता है।

7.2 AnythingLLM का उपयोग करके RAG आर्किटेक्चर

यहाँ RAG वातावरण का एक आर्किटेक्चर आरेख है जो आपके आंतरिक दस्तावेजों या व्यक्तिगत नोट्स को पढ़ सकता है:

graph LR Document["डॉक्यूमेंट (PDF, MD)"] --> Chunking["चंकिंग (Chunking)"] Chunking --> EmbedModel["एम्बेडिंग मॉडल (Embedding Model)"] EmbedModel --> VectorDB["वेक्टर डेटाबेस (Vector Database)"] UserQuery["यूज़र की क्वेरी (User Query)"] --> EmbedQuery["क्वेरी एम्बेडिंग (Query Embedding)"] EmbedQuery --> VectorDB VectorDB --> |"समानता खोज (Similarity Search)"| RetrievedDocs["संबंधित डॉक्यूमेंट्स निकालना"] UserQuery --> PromptBuilder["प्रॉम्प्ट निर्माण (Prompt Builder)"] RetrievedDocs --> PromptBuilder PromptBuilder --> LocalLLM["लोकल LLM"] LocalLLM --> Answer["अंतिम उत्तर (Final Answer)"]

AnythingLLM डेस्कटॉप संस्करण (विंडोज़) का उपयोग करके, बस सेटिंग स्क्रीन से Ollama (LLM और Embedding) निर्दिष्ट करें, और इसे लोकल VectorDB (LanceDB) का उपयोग करने के लिए सेट करें। केवल कुछ मिनटों में यह आर्किटेक्चर तैयार हो जाता है। यह एक ऐसा प्राइवेट AI बनाता है जो बाहरी रूप से कोई डेटा नहीं भेजता है।

8. Windows WSL2 पर फाइन-ट्यूनिंग (LoRA)

यदि आप मॉडल को न केवल लोकल रूप से चलाना चाहते हैं बल्कि अपने स्वयं के डेटा के साथ इसे और स्मार्ट बनाना चाहते हैं, तो आप LoRA (Low-Rank Adaptation) का उपयोग करके फाइन-ट्यूनिंग कर सकते हैं। 2026 तक, “Unsloth” नामक एक लाइब्रेरी का उपयोग करके, विंडोज़ के WSL2 वातावरण में, 16GB VRAM वाले 8B मॉडल की ट्रेनिंग कुछ ही घंटों में पूरी की जा सकती है।

वातावरण सेट करने के लिए WSL2 Ubuntu में निम्नलिखित चलाएँ:

1
2
3
4


conda create --name unsloth_env python=3.11
conda activate unsloth_env
pip install "unsloth[colab-new] @ git+https://github.com/unslothai/unsloth.git"
pip install --no-deps trl peft accelerate bitsandbytes

Unsloth ने CUDA कर्नेल को चरम सीमा तक अनुकूलित (optimize) किया है, मानक Hugging Face लाइब्रेरी की तुलना में ट्रेनिंग गति को दोगुना कर दिया है और VRAM की खपत को आधा कर दिया है। बस Jupyter Notebook शुरू करें और डेटासेट (JSONL प्रारूप) लोड करें, और कुछ ही एपोक (epochs) की ट्रेनिंग RTX 4060 Ti जैसे 12GB से 16GB VRAM वाले GPU पर संभव है।

9. परफॉरमेंस ट्रबलशूटिंग (Performance Troubleshooting)

यहाँ कुछ सामान्य समस्याएं और उनके समाधान दिए गए हैं:

1. इन्फरेंस की गति बहुत धीमी है (1 से 2 टोकन/सेकंड)

कारण: मॉडल VRAM में फिट नहीं हो रहा है और सिस्टम मेमोरी (RAM) पर ऑफलोड हो रहा है। समाधान: टास्क मैनेजर में “Dedicated GPU memory” चेक करें। यदि यह सीमा तक पहुँच गया है, तो कॉन्टेक्स्ट साइज़ (-c) कम करें या कम बिट वाले क्वांटाइज्ड मॉडल (जैसे Q4_K_M) का उपयोग करें।

2. “CUDA out of memory” एरर

कारण: VRAM पूरी तरह से खत्म हो गया है। ऐसा अक्सर तब होता है जब चैट लंबी हो जाती है और KV कैश बहुत बड़ा हो जाता है। समाधान: जानबूझकर मान को कम करें; Ollama के मामले में num_ctx, या llama.cpp के मामले में -c का मान कम करें।

3. टेक्स्ट जनरेशन (विशेषकर जापानी या हिंदी) अजीब है

कारण: प्रॉम्प्ट टेम्पलेट का बेमेल होना, या मॉडल उस भाषा का समर्थन नहीं करता है। समाधान: ऐसे मॉडल का उपयोग करें जिसके नाम में Instruct शामिल हो, और सुनिश्चित करें कि टूल में सही टेम्पलेट (जैसे ChatML या Llama3 फॉर्मेट) चुना गया है जो मॉडल के निर्माता द्वारा निर्दिष्ट किया गया था।

10. निष्कर्ष और भविष्य की संभावनाएं

2026 में, विंडोज़ वातावरण में लोकल LLM का निर्माण अब केवल कुछ इंजीनियरों का विशेषाधिकार नहीं रह गया है। GGUF फॉर्मेट के वास्तविक मानक (de facto standard) बनने, Ollama और LM Studio जैसे परिष्कृत इकोसिस्टम के उदय, और FlashAttention जैसे हार्डवेयर ऑप्टिमाइज़ेशन के कारण, अब कोई भी आसानी से एंटरप्राइज़-ग्रेड AI वातावरण प्राप्त कर सकता है।

कृपया इस लेख में बताए गए निम्नलिखित बिंदुओं का उपयोग करें:

VRAM की गणितीय गणना का उपयोग करके तार्किक रूप से अपने पीसी विनिर्देशों (specs) के लिए इष्टतम मॉडल आकार और क्वांटाइजेशन स्तर चुनें।
Ollama का उपयोग करके सबसे तेज़ वातावरण सेटअप करें, और अपनी उत्पादकता बढ़ाने के लिए इसे AI एडिटर के साथ एकीकृत (integrate) करें।
llama.cpp के उन्नत पैरामीटर नियंत्रण के साथ हार्डवेयर के चरम प्रदर्शन को प्राप्त करें।
गोपनीय डेटा को संभालने के लिए AnythingLLM के साथ एक सुरक्षित लोकल RAG सिस्टम बनाएं।
अपना खुद का कस्टम AI बनाने के लिए Unsloth (WSL2) का उपयोग करें जिसमें विशेष ज्ञान हो।

AI का “लोकतंत्रीकरण” अब सिर्फ एक चर्चा का शब्द (buzzword) नहीं है, बल्कि एक वास्तविक प्रणाली है जो आपके विंडोज़ डेस्कटॉप पर चलती है। क्लाउड API उपयोग की लागतों और सूचना रिसाव (information leakage) के जोखिमों से मुक्त होकर, अभी स्वतंत्र और शक्तिशाली प्राइवेट AI की दुनिया में कदम रखें।