Local AI 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) में छोड़ें।

【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 की दुनिया में कदम रखें।