छोटे और ऑन-डिवाइस मॉडल्समध्यमपाठ 2287 मिनट का पाठ

अपने कंप्यूटर पर मॉडल चलाना

llama.cpp और Ollama जैसे टूल्स आपको लैपटॉप पर open-weight मॉडल्स चलाने की सुविधा देते हैं। जानें कि आपको कितनी मेमोरी चाहिए, GPU कब काम आता है, और GGUF फ़ाइल क्या होती है।

पाठ वीडियो में

60 सेकंड में

अपने कंप्यूटर पर मॉडल चलाना

llama.cpp और Ollama जैसे टूल्स आपको लैपटॉप पर open-weight मॉडल्स चलाने की सुविधा देते हैं। जानें कि आपको कितनी मेमोरी चाहिए, GPU कब काम आता है, और GGUF फ़ाइल क्या होती है।

1/3
आसान शब्दों में
रसोई के बिना रेसिपी की किताब किसी काम की नहीं होती। मॉडल फ़ाइल रेसिपी की किताब जैसी है। llama.cpp या Ollama जैसा प्रोग्राम वह रसोई है जो इसे पढ़ता है और आपके अपने घर में ही जवाब तैयार करता है।
किसी मॉडल को अपने कंप्यूटर (locally) पर चलाने के लिए आपको दो चीज़ों की ज़रूरत होती है: मॉडल फ़ाइल (weights) और एक runtime, यानी वह प्रोग्राम जो weights को लोड करता है और टेक्स्ट जनरेट करता है। दो जाने-माने मुफ़्त runtimes हैं: llama.cpp, जो एक ओपन-सोर्स C/C++ प्रोजेक्ट है, और Ollama, एक ऐसा टूल जो मॉडल्स को डाउनलोड करना और चलाना आसान बनाता है और llama.cpp पर ही आधारित है।

GGUF: फ़ाइल फ़ॉर्मैट

llama.cpp और Ollama आम तौर पर GGUF फ़ाइलों का इस्तेमाल करते हैं। एक GGUF फ़ाइल weights, tokenizer और सेटिंग्स को एक ही फ़ाइल में समेट देती है, जो अक्सर पहले से ही quantised (छोटा किया हुआ, अगला पाठ देखें) होती है। आपको Q4 या Q8 जैसे टैग वाले नाम दिखेंगे। ये मोटे तौर पर बताते हैं कि हर weight कितने bits का इस्तेमाल करता है।

आपको कितनी मेमोरी की ज़रूरत है?

अंदाज़ा लगाने का एक आसान तरीक़ा: parameters की संख्या × प्रति parameter बाइट्स, फिर runtime और बातचीत (context) के लिए कुछ अतिरिक्त मेमोरी जोड़ लें।
Precisionप्रति parameter बाइट्स1B-parameter मॉडल7B-parameter मॉडल
16-bit2लगभग 2 GBलगभग 14 GB
8-bit1लगभग 1 GBलगभग 7 GB
4-bit0.5लगभग 0.5 GBलगभग 3.5 GB
यह केवल weights के लिए है। लंबी बातचीतों के लिए ज़्यादा मेमोरी की ज़रूरत होती है, क्योंकि मॉडल अब तक के टेक्स्ट का एक कैश (KV cache) रखता है। अपने ऑपरेटिंग सिस्टम और ब्राउज़र के लिए भी जगह छोड़ें। 8 GB वाले लैपटॉप पर, शुरुआत करने के लिए एक छोटा 4-bit मॉडल सबसे सही रहता है।
Python: rough memory estimate (standard library only)python
def estimate_gb(params_billion: float, bits: int, overhead: float = 1.2) -> float:
    """Weights only, times a rough overhead factor for runtime and context."""
    bytes_per_param = bits / 8
    weights_gb = params_billion * bytes_per_param   # 1B params x 1 byte = about 1 GB
    return round(weights_gb * overhead, 1)

for size in (1, 3, 7):
    for bits in (16, 8, 4):
        print(f"{size}B model at {bits}-bit: about {estimate_gb(size, bits)} GB")

CPU या GPU?

हार्डवेयरकिसके लिए अच्छा हैकिन बातों का ध्यान रखें
केवल CPUछोटे मॉडल्स, सीखने और कम इस्तेमाल के लिए। लगभग किसी भी लैपटॉप पर काम करता है।जवाब जनरेट होने की गति धीमी होती है, ख़ासकर बड़े मॉडल्स के लिए
लैपटॉप या डेस्कटॉप GPUकाफ़ी तेज़ी से जनरेशन होता है अगर मॉडल GPU की अपनी मेमोरी (VRAM) में समा जाएअगर मॉडल VRAM से बड़ा है, तो उसका कुछ हिस्सा CPU पर चलता है और स्पीड घट जाती है
Apple silicon MacCPU और GPU एक ही मेमोरी पूल साझा करते हैं, जिसका इस्तेमाल llama.cpp कर सकता हैसाझा मेमोरी (shared memory) का इस्तेमाल आपके द्वारा चलाई जा रही बाकी चीज़ें भी करती हैं

शुरुआत करना (उदाहरण: मौजूदा डॉक्युमेंटेशन ज़रूर देखें)

अलग-अलग वर्शन में कमांड बदल सकते हैं, इसलिए इन्हें केवल उदाहरण समझें और Ollama व llama.cpp के आधिकारिक पेज ज़रूर देखें।
Example commands (may change; check current docs)bash
# Ollama: download a model and chat with it in the terminal
ollama run <model-name>
ollama list                 # models you have downloaded

# llama.cpp: run a GGUF file you downloaded yourself
llama-cli -m ./my-model.gguf -p "Explain UPI in two sentences."

# llama.cpp: start a local server your own code can call
llama-server -m ./my-model.gguf --port 8080
Ollama डिफ़ॉल्ट रूप से पोर्ट 11434 पर एक लोकल HTTP सर्वर भी चलाता है, ताकि आपके अपने प्रोग्राम मॉडल को कॉल कर सकें। कोई भी डेटा आपके कंप्यूटर से बाहर जाने की ज़रूरत नहीं होती।
Python: call a local Ollama model (requests package; check the API docs)python
import requests

resp = requests.post(
    "http://localhost:11434/api/generate",
    json={"model": "<model-name>", "prompt": "Give three tips for saving water at home.", "stream": False},
    timeout=120,
)
resp.raise_for_status()
print(resp.json()["response"])
सावधान रहें
मॉडल फ़ाइलों को सिर्फ़ उन्हीं सोर्स से डाउनलोड करें जिन पर आपको भरोसा हो, जैसे पब्लिशर का आधिकारिक पेज। Python के pickle पर आधारित कुछ पुराने मॉडल फ़ाइल फ़ॉर्मैट लोड होते समय कोड भी चला सकते हैं। GGUF और safetensors फ़ाइलें सिर्फ़ डेटा रखने के लिए बनाई गई हैं, लेकिन छेड़छाड़ किया गया या ख़राब तरीक़े से बना मॉडल फिर भी ग़लत जवाब दे सकता है।
नोट
लोकल सर्वर आपकी अपनी मशीन के लिए होता है। इसे बिना ऑथेंटिकेशन और सीमाओं के इंटरनेट पर खुला न छोड़ें, वरना अनजान लोग आपके कंप्यूटर की प्रोसेसिंग पावर का इस्तेमाल करने लगेंगे।
यह आज़माएँ। अपने लैपटॉप की RAM (और अगर GPU मेमोरी हो, तो उसे भी) चेक करें। टेबल की मदद से लिखें कि 4-bit पर बाकी कामों के लिए जगह बचाते हुए आप सबसे बड़ा कौन-सा मॉडल चला सकते हैं।

और देखें और पढ़ें

लैब

अपने कंप्यूटर पर चल रहा एक छोटा मॉडल, या उसे चलाने की एक लिखित योजना।

~40 min

समस्या

विकल्प A (अगर आप सॉफ़्टवेयर इंस्टॉल कर सकते हैं):

  1. आधिकारिक निर्देशों का पालन करते हुए Ollama इंस्टॉल करें या llama.cpp बिल्ड करें।
  2. एक छोटा मॉडल चुनें जिसका लाइसेंस आपने पढ़ लिया हो। इसे चलाएँ और इससे पाँच सवाल पूछें: दो अंग्रेज़ी में, दो किसी ऐसी भारतीय भाषा में जिसे आप जानते हैं, और एक किसी ऐसे तथ्य के बारे में जिसे आप जाँच सकते हैं।
  3. रिकॉर्ड करें: मॉडल का नाम और साइज़, quantisation, पहले जवाब में लगा समय, क्या हर जवाब सही था, और आपके सिस्टम मॉनिटर के अनुसार RAM का इस्तेमाल।

विकल्प B (काग़ज़ पर):

  1. अपने कंप्यूटर की RAM, CPU और GPU (यदि हो) लिखें।
  2. मेमोरी टेबल या Python के अनुमान का इस्तेमाल करके एक ऐसा मॉडल साइज़ और quantisation चुनें जो बाकी कामों के लिए जगह छोड़ते हुए आसानी से समा जाए।
  3. वे चरण लिखें जिनका आप पालन करेंगे, आप मॉडल कहाँ से डाउनलोड करेंगे, और पाँच टेस्ट सवाल उनके अपेक्षित जवाबों के साथ लिखें।

प्रैक्टिस लैब

कोड में बदलाव करें और इसे रन करें। Python आपके ब्राउज़र में चलता है — हमारे सर्वर पर कुछ नहीं भेजा जाता।

आउटपुट

कोई आउटपुट नहीं। वैल्यूज़ देखने के लिए print(...) जोड़ें।

आपका काम तब पूरा होगा जब

कठिन सवाल

उत्तर देखने से पहले ख़ुद जवाब देने की कोशिश करें। अगर आप इनके जवाब दे सकते हैं, तो आप पाठ समझ गए हैं।

Q1एक ही मॉडल की दो GGUF फ़ाइलों पर Q8 और Q4 का लेबल लगा है। Q4 वाली फ़ाइल भी आपके सवालों के उतने ही अच्छे जवाब देती है। फिर भी आप और टेस्टिंग क्यों जारी रख सकते हैं?दिखाएं

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

Q2लैपटॉप पर "मॉडल के लिए अपनी RAM का केवल आधा हिस्सा ही इस्तेमाल करें" एक समझदारी भरा नियम क्यों है?दिखाएं

ऑपरेटिंग सिस्टम, ब्राउज़र और अन्य ऐप्स को भी मेमोरी की ज़रूरत होती है, और लंबी बातचीतों के दौरान मॉडल का context cache भी बढ़ता है। अगर मेमोरी ख़त्म हो जाती है, तो कंप्यूटर डिस्क पर डेटा स्वैप (swap) करने लगता है और सब कुछ बहुत धीमा हो जाता है। कुछ जगह खाली रखने से मॉडल और आपका कंप्यूटर दोनों ठीक से चलते रहते हैं।

जारी रखने के लिए कृपया साइन इन करें।

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

मेरे पास GPU नहीं है। क्या मैं फिर भी मॉडल चला सकता हूँ?

हाँ। llama.cpp और Ollama CPU पर भी चलते हैं। सीखने और हल्के-फुल्के काम के लिए छोटे मॉडल्स काफ़ी काम आते हैं। GPU के मुक़ाबले जवाब जनरेट होने में ज़्यादा समय लगेगा, इसलिए छोटे मॉडल से शुरुआत करें।

पहला जवाब धीमा और बाद वाले तेज़ क्यों होते हैं?

पहली बार runtime को मॉडल फ़ाइल डिस्क से मेमोरी में लोड करनी पड़ती है। इसके बाद वह कुछ देर तक मेमोरी में ही लोड रहती है, इसलिए बाद के जवाब जल्दी आने लगते हैं।

llama.cpp और Ollama में क्या फ़र्क़ है?

llama.cpp एक लो-लेवल इंजन है जिसमें कई सारे विकल्प होते हैं। Ollama उसी तरह के इंजन को एक आसान टूल में समेट देता है जिसमें मॉडल लाइब्रेरी और एक लोकल API शामिल होती है। शुरुआती लोग अक्सर Ollama से शुरुआत करते हैं; जिन्हें बारीक़ नियंत्रण चाहिए होता है वे अक्सर सीधे llama.cpp का इस्तेमाल करते हैं।

मेरा लैपटॉप बहुत गर्म हो जाता है। क्या यह कोई समस्या है?

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

पाठ का टेस्ट

5 सवाल। पास होने और इस पाठ को पूरा करने के लिए 3 सही होने चाहिए (60%)।

टेस्ट देने और अपनी प्रोग्रेस सेव करने के लिए साइन इन करें