पायथन कोडिंग के लिए सर्वश्रेष्ठ स्थानीय LLM: स्थानीय या होस्टेड API?

पहले अपनी बाधाओं (constraints) पर विचार करें, मॉडल के नाम पर नहीं

Python कोडिंग के लिए सर्वोत्तम स्थानीय LLM के प्रश्न का कोई निश्चित उत्तर नहीं है, क्योंकि मॉडल तेज़ी से बदलते हैं और आपकी मशीन ही वास्तविक सीमा है। नामों की तुलना करने से पहले, चार चीज़ें लिख लें:

• GPU मेमोरी। यह तय करता है कि आप किन मॉडल साइज़ को चला सकते हैं।
• कॉन्टेक्स्ट विंडो की आवश्यकता। एक फ़ंक्शन संपादित करना, एक पूरे पैकेज पर तर्क देने से अलग है।
• गोपनीयता नियम। कुछ कोड आपकी मशीन से बाहर नहीं जा सकता, जो स्थानीय रूप से चलाने का एक वैध कारण है।
• अस्वीकृति सहनशीलता। सुरक्षा टूलिंग, स्क्रैपर्स, रिवर्स इंजीनियरिंग और फ़ज़र्स भारी रूप से फ़िल्टर किए गए मॉडल्स में अस्वीकृति (refusals) ट्रिगर कर सकते हैं।

यदि सख्त ऑफ़लाइन संचालन एक कठोर आवश्यकता है, तो आपको एक ऐसा मॉडल चाहिए जिसे आप स्वयं चला सकें। यदि ऐसा नहीं है, तो एक होस्टेड API हार्डवेयर के प्रश्न को समाप्त कर देता है। यह साइट दूसरे समूह से संबंधित है: यह एक होस्टेड, OpenAI-संगत API है, न कि एक लोकल रनटाइम, और इसे अपने लोकल सेटअप के साथ परखना उचित रहेगा।

आपको कितनी GPU मेमोरी की आवश्यकता है

वजन के लिए एक अनुमानित नियम: पैरामीटर की संख्या × प्रति पैरामीटर बाइट्स। 16-बिट सटीकता पर यह प्रति पैरामीटर 2 बाइट है; 8-बिट पर, 1 बाइट; 4-बिट पर, लगभग 0.5 बाइट।

मॉडल साइज़	16-बिट	8-बिट	4-बिट
7B	14 GB	7 GB	3.5 GB
14B	28 GB	14 GB	7 GB
32B	64 GB	32 GB	16 GB

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

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

सार्वजनिक लीडरबोर्ड किसी अन्य के कार्यों को मापते हैं। एक बेहतर विधि एक घंटे का समय लेती है और आपके अपने कोड का उपयोग करती है।

1. 15 से 20 वास्तविक कार्य एकत्र करें: एक बग जिसका परीक्षण विफल हो रहा है, एक फ़ंक्शन जिसे डॉकस्ट्रिंग से लिखना है, एक रिफैक्टर, टाइप हिंट्स जोड़ने का अनुरोध।
2. प्रत्येक मॉडल को समान प्रॉम्प्ट, समान तापमान (कोड के लिए 0.2 एक उचित शुरुआत है) और समान सीड के साथ चलाएँ जहाँ समर्थित हो।
3. टेस्ट चलाकर स्कोर करें, उत्तर पढ़कर नहीं। क्या यह वास्तविक मॉड्यूल इम्पोर्ट करता है? क्या यह पास होता है?
4. अस्वीकृतियों को अलग से नोट करें। एक मॉडल जो कोड पर 5% बेहतर है लेकिन आपके पोर्ट स्कैनर कार्य को अस्वीकार करता है, आपके लिए बुरा है।
5. प्रति टास्क समय और होस्टेड मॉडल्स के लिए प्रति टास्क लागत रिकॉर्ड करें।

हार्नेस को एक फ़ाइल में रखें ताकि आप जब भी नया मॉडल आए तो उसे पुनः चला सकें। वह पुन: उपयोग किसी भी एकल परिणाम से अधिक मूल्यवान है।

एक होस्टेड विकल्प का उसी टास्क सेट पर परीक्षण

चूँकि API OpenAI-संगत है, आपके हार्नेस को केवल एक अलग बेस URL की आवश्यकता है। यह स्क्रिप्ट एक फ़ंक्शन मांगती है, पहला Python ब्लॉक निकालती है और इसे एक परीक्षण के खिलाफ चलाती है। मॉडल ID uncensored है।

Copyimport re
import subprocess
import tempfile
from openai import OpenAI

client = OpenAI(base_url="https://api.uncensoredlocalllm.com/v1", api_key="YOUR_API_KEY")

TASK = "Write a Python function parse_size(text) that converts '10KB' or '2 MB' to bytes."
TEST = "assert parse_size('10KB') == 10240\nassert parse_size('2 MB') == 2 * 1024 * 1024\nprint('ok')"

r = client.chat.completions.create(
    model="uncensored",
    temperature=0.2,
    seed=7,
    messages=[
        {"role": "system", "content": "You write correct Python 3. Reply with one fenced code block and no commentary."},
        {"role": "user", "content": TASK},
    ],
)
text = r.choices[0].message.content
m = re.search(r"```(?:python)?\n(.*?)```", text, re.S)
code = m.group(1) if m else text

with tempfile.NamedTemporaryFile("w", suffix=".py", delete=False) as f:
    f.write(code + "\n" + TEST)
out = subprocess.run(["python3", f.name], capture_output=True, text=True, timeout=20)
print(out.stdout.strip() or out.stderr.strip())

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

जहाँ एक होस्टेड मॉडल एक Python डेवलपर की मदद करता है

एक होस्टेड एंडपॉइंट हर मामले में बेहतर नहीं है, लेकिन कुछ कार्य इसके लिए अच्छे हैं:

• बड़ा कॉन्टेक्स्ट। विंडो 100,000 टोकन की है, प्रॉम्प्ट और पूर्णता सहित। यह एक बड़े मॉड्यूल, उसके परीक्षणों और एक स्टैक ट्रेस को एक अनुरोध में फिट करता है।
• फ़ंक्शन कॉलिंग। आप run_tests या read_file जैसे टूल परिभाषित कर सकते हैं और मॉडल को लूप में उन्हें कॉल करने दे सकते हैं, जिसके परिणाम role: "tool" संदेशों के रूप में भेजे जाते हैं।
• JSON मोड। response_format: {"type":"json_object"} के साथ आप एक संरचित कोड रिव्यू प्राप्त कर सकते हैं, जैसे कि लाइन नंबरों के साथ मुद्दों की एक सूची।
• सुरक्षा कार्यों में कम अस्वीकृति। मॉडल को कानूनी वयस्क उपयोग के लिए बिना सामग्री अस्वीकृति के उत्तर देने के लिए ट्यून किया गया है, जिसमें उन सिस्टम का सुरक्षा परीक्षण भी शामिल है जिनके आप मालिक हैं या जिनका परीक्षण करने के लिए आप अधिकृत हैं।

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

मॉडल को टूल कॉलिंग के साथ अपने टेस्ट चलाने देना

टूल कॉलिंग एक एक-शॉट जवाब को एक लूप में बदल देती है: मॉडल टेस्ट चलाने का अनुरोध करता है, विफलता देखता है और कोड ठीक करता है। एक टूल परिभाषित करें और कॉल को स्वयं हैंडल करें।

Copyimport json
import subprocess
from openai import OpenAI

client = OpenAI(base_url="https://api.uncensoredlocalllm.com/v1", api_key="YOUR_API_KEY")

tools = [{
    "type": "function",
    "function": {
        "name": "run_tests",
        "description": "Run pytest in the project and return the output",
        "parameters": {"type": "object", "properties": {}, "required": []},
    },
}]

messages = [
    {"role": "system", "content": "You fix Python bugs. Call run_tests to check your work."},
    {"role": "user", "content": "The tests in this project fail. Run them and tell me the first error."},
]

for _ in range(5):
    r = client.chat.completions.create(model="uncensored", messages=messages, tools=tools, temperature=0.2)
    msg = r.choices[0].message
    messages.append(msg)
    if not msg.tool_calls:
        print(msg.content)
        break
    for call in msg.tool_calls:
        out = subprocess.run(["pytest", "-x", "-q"], capture_output=True, text=True)
        messages.append({"role": "tool", "tool_call_id": call.id, "content": (out.stdout + out.stderr)[-4000:]})

लूप पांच राउंड तक सीमित है ताकि एक भ्रमित मॉडल अनंत काल तक न चले। टूल आउटपुट को छोटा रखें, क्योंकि आप जो भी वापस करते हैं, उसे अगले राउंड में इनपुट के रूप में बिल किया जाता है। इसे अंतिम 4,000 अक्षरों तक काटने से प्रत्येक टर्न सस्ता रहता है।

कोडिंग कार्य के लिए लागत

कोडिंग प्रॉम्प्ट इनपुट-भारी होते हैं: आप कोड पेस्ट करते हैं और एक छोटा जवाब पाते हैं। 6,000 इनपुट टोकन और 1,500 आउटपुट टोकन वाले एक रिफैक्टर अनुरोध को 1M प्रति $0.15 और $0.50 पर लें:

• इनपुट: 6,000 / 1,000,000 x $0.15 = $0.0009
• आउटपुट: 1,500 / 1,000,000 x $0.50 = $0.00075
• कुल: प्रति अनुरोध $0.00165

ऐसे एक हजार अनुरोधों की लागत $1.65 है। $0.50 का ट्रायल क्रेडिट लगभग 303 अनुरोधों को कवर करता है, जो 20-कार्य वाले बेंचमार्क को कई बार चलाने के लिए पर्याप्त है। भारी मात्रा में प्रति अनुरोध स्थानीय GPU सस्ता हो सकता है, लेकिन इसमें अग्रिम लागत होती है और जब आप इसका उपयोग नहीं कर रहे होते हैं, तो यह शून्य तक कम नहीं होता। मूल्य निर्धारण पृष्ठ पर पूर्ण तालिका दी गई है।

कोड जनरेशन के लिए व्यावहारिक सेटिंग्स

• तापमान 0.1 से 0.3। निम्न मान मनगढ़ंत API और यादृच्छिक शैली परिवर्तनों को कम करते हैं।
• बीज को पिन करें जब आप प्रॉम्प्ट की तुलना करते हैं, ताकि अंतर प्रॉम्प्ट से आए न कि सैम्पलिंग से।
• सिस्टम संदेश में पायथन संस्करण और लाइब्रेरी बताएं: "Python 3.11, केवल मानक लाइब्रेरी" काफ़ी हद तक अनुमान लगाने की ज़रूरत ख़त्म कर देता है।
• कोड के साथ परीक्षण मांगें। एक मॉडल जो अपना स्वयं का परीक्षण लिखता है, अक्सर जब आप उन्हें चलाते हैं तो अपनी ही off-by-one त्रुटियों को पकड़ लेता है।
• गलती का ट्रेसबैक भेजें, इसका विवरण नहीं।

इसे आज़माने के लिए, API कुंजी पेज पर ट्रायल क्रेडिट प्राप्त करें, फिर क्विकस्टार्ट का पालन करें। चैट-शैली उपयोग के लिए, बिना सेंसर वाले LLM चैट गाइड देखें। सेवा वयस्कों के वैध उपयोग के लिए है, और यह नाबालिगों से जुड़ी यौन सामग्री उत्पन्न नहीं करती है।

कोडिंग मॉडल के साथ सामान्य गलतियाँ

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

अधिक गाइड

• एक LLM की लागत कितनी होती है? टोकन-प्रति गणित और उदाहरण
• Uncensored LLM चैट: एकीकरण गाइड और उपयोग के मामले