2026 में ओलामा के साथ एलएलएम को स्थानीय स्तर पर कैसे फाइन-ट्यून और चलाएं

स्थानीय स्तर पर एलएलएम क्यों चलाएं

स्थानीय अनुमान उन समस्याओं को हल करता है जो होस्ट किए गए एपीआई संरचनात्मक रूप से नहीं कर सकते हैं: डेटा आपकी मशीन को कभी नहीं छोड़ता है, पैमाने पर कोई प्रति-टोकन बिल नहीं है, और जिस मॉडल संस्करण के खिलाफ आपने परीक्षण किया है वह मॉडल संस्करण है जिसे आप अगले महीने चलाएंगे, किसी भी अपस्ट्रीम डिप्रेशन शेड्यूल की परवाह किए बिना। ट्रेडऑफ़ गुणवत्ता और सुविधा है – 7B-70B रेंज में ओपन-वेट मॉडल अच्छे हैं, लेकिन वे आम तौर पर जटिल तर्क कार्यों पर सीमांत होस्ट किए गए मॉडल से पीछे रह जाते हैं।

ओलामा स्थापित करना

ओलामा मैकओएस, विंडोज और लिनक्स के लिए मूल इंस्टॉलर भेजता है, और कुशल मात्रात्मक अनुमान के लिए हुड के नीचे llama.cpp को लपेटता है।

# macOS / Linux
curl -fsSL https://ollama.com/install.sh | sh

# Windows: download the installer from ollama.com/download

# Verify install
ollama --version

हार्डवेयर और मॉडल आकार

मापदंडों में मॉडल का आकार एक बार मात्रा निर्धारित करने के बाद मोटे तौर पर मेमोरी आवश्यकताओं को निर्धारित करता है। 4-बिट परिमाणीकरण के लिए सामान्य नियम के रूप में (अधिकांश पुलों के लिए ओलामा डिफ़ॉल्ट):

• 3बी-4बी मॉडल– 8 जीबी रैम पर आसानी से चलाएं, जिसमें बिना किसी अलग जीपीयू वाले अधिकांश आधुनिक लैपटॉप भी शामिल हैं।
• 7बी-8बी मॉडल– लगभग 8-12GB की आवश्यकता है; सामान्य प्रयोजन की चैट और कोडिंग सहायता के लिए एक आरामदायक मधुर स्थान।
• 13बी-14बी मॉडल– सुचारू प्रदर्शन के लिए 16-24GB की आवश्यकता है।
• 70बी-क्लास मॉडल– अच्छी गति के लिए 48 जीबी + वीआरएएम की आवश्यकता है, या सिस्टम रैम और सीपीयू में विभाजित होकर धीरे-धीरे चलेगा।

ऐप्पल सिलिकॉन मैक यहां अपने वजन से ऊपर हैं क्योंकि एकीकृत मेमोरी जीपीयू को पूर्ण सिस्टम रैम पूल तक पहुंचने देती है, जिससे वे 13बी-34बी मॉडल के लिए आश्चर्यजनक रूप से सक्षम हो जाते हैं।

आपका पहला स्थानीय मॉडल

# Pull and run a general-purpose model
ollama run llama3.1:8b

# Pull a coding-focused model
ollama run qwen2.5-coder:7b

# List installed models
ollama list

# Remove a model to free disk space
ollama rm llama3.1:8b

पहलाrunकमांड मॉडल (कई गीगाबाइट) डाउनलोड करता है और आपको एक इंटरैक्टिव चैट प्रॉम्प्ट में छोड़ देता है। मॉडल स्थानीय रूप से कैश किए जाते हैं, इसलिए बाद के रन तुरंत शुरू हो जाते हैं।

मॉडलफाइल के साथ व्यवहार को अनुकूलित करना

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

FROM qwen2.5-coder:7b

PARAMETER temperature 0.2
PARAMETER num_ctx 8192

SYSTEM """
You are a senior backend engineer. Answer concisely with working code.
Prefer Python and explain tradeoffs only when explicitly asked.
"""

ollama create backend-helper -f ./Modelfile
ollama run backend-helper

पायथन से ओलामा को कॉल करना

ओलामा ने पोर्ट 11434 पर एक स्थानीय आरईएसटी एपीआई को उजागर किया है, जिसके शीर्ष पर एक आधिकारिक पायथन क्लाइंट है – जो स्थानीय मॉडल को स्क्रिप्ट या बैकएंड सेवा में जोड़ने के लिए उपयोगी है।

pip install ollama

import ollama

response = ollama.chat(model="qwen2.5-coder:7b", messages=[
    {"role": "user", "content": "Write a Python function that flattens a nested list."}
])
print(response["message"]["content"])

# Streaming
for chunk in ollama.chat(model="llama3.1:8b", messages=[
    {"role": "user", "content": "Explain TCP vs UDP in two sentences."}
], stream=True):
    print(chunk["message"]["content"], end="", flush=True)

लोरा के साथ फाइन-ट्यूनिंग

ओलामा स्वयं एक अनुमान रनटाइम है, प्रशिक्षण उपकरण नहीं – फाइन-ट्यूनिंग के लिए, आप हगिंग फेस जैसी लाइब्रेरी के साथ एक लोरा एडाप्टर को प्रशिक्षित करते हैंpeftया अनस्लोथ, फिर या तो एडॉप्टर को बेस वेट में मर्ज करें या इसे जीजीयूएफ में परिवर्तित करें और इसे मॉडलफाइल के माध्यम से लोड करेंADAPTERनिर्देश.

pip install unsloth peft transformers datasets trl

from unsloth import FastLanguageModel
from trl import SFTTrainer
from transformers import TrainingArguments
from datasets import load_dataset

model, tokenizer = FastLanguageModel.from_pretrained(
    model_name="unsloth/llama-3.1-8b-bnb-4bit",
    max_seq_length=2048,
    load_in_4bit=True,
)

model = FastLanguageModel.get_peft_model(
    model,
    r=16,
    target_modules=["q_proj", "k_proj", "v_proj", "o_proj"],
    lora_alpha=16,
    lora_dropout=0,
)

dataset = load_dataset("json", data_files="my_training_data.jsonl", split="train")

trainer = SFTTrainer(
    model=model,
    tokenizer=tokenizer,
    train_dataset=dataset,
    dataset_text_field="text",
    max_seq_length=2048,
    args=TrainingArguments(
        per_device_train_batch_size=2,
        gradient_accumulation_steps=4,
        num_train_epochs=3,
        learning_rate=2e-4,
        output_dir="outputs",
    ),
)
trainer.train()
model.save_pretrained_gguf("my-finetuned-model", tokenizer, quantization_method="q4_k_m")

4-बिट QLoRA दृष्टिकोण (बेस मॉडल को 4-बिट में लोड करना, केवल छोटे LoRA एडाप्टर मैट्रिसेस को प्रशिक्षित करना) 7B-8B मॉडल के लिए 12-24GB VRAM के साथ एकल उपभोक्ता GPU पर इसे संभव बनाता है। एक बार जीजीयूएफ को निर्यात करने के बाद, एक मॉडलफाइल को इंगित करेंFROMस्थानीय फ़ाइल पर और इसे किसी अन्य मॉडल की तरह ओलामा में लोड करें।

जब लोकल होस्टेड एपीआई को मात देता है

स्थानीय मॉडल संकीर्ण, दोहराव वाले कार्यों के लिए सबसे अधिक उपयोगी होते हैं, जहां आपने उस एक कार्य पर होस्ट किए गए मॉडल की गुणवत्ता से मेल खाने के लिए एक छोटे मॉडल को ठीक किया है या प्रेरित किया है – वर्गीकरण, संरचित निष्कर्षण, संवेदनशील डेटा के साथ आंतरिक टूलींग, या ऑफ़लाइन/एज तैनाती। ओपन-एंडेड तर्क, जटिल मल्टी-स्टेप टूल उपयोग, या ऐसी किसी भी चीज़ के लिए जहां आउटपुट गुणवत्ता सीधे उत्पाद को प्रभावित करती है, क्लाउड जैसा फ्रंटियर होस्टेड मॉडल अभी भी जीतता है; हमारा देखेंक्लाउड एपीआई ट्यूटोरियलयदि आप उसी प्रोजेक्ट के लिए उस मार्ग पर विचार कर रहे हैं।