Qwen3.8-27B को स्क्रैच से इंस्टॉल करना: Mac पर लोकल डिप्लॉयमेंट और परफॉरमेंस ट्यूनिंग के लिए एक गाइड

पहले निष्कर्ष: क्या आपका Mac इसे चला सकता है?

केवल यूनिफाइड मेमोरी को देखते हुए, आप इस तालिका का उपयोग करके निर्णय ले सकते हैं:

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

कुछ 24GB Mac वास्तव में 4-bit लोड कर सकते हैं, लेकिन सफल लोडिंग का मतलब यह नहीं है कि यह लंबे समय तक उपयोग के लिए उपयुक्त है। macOS, ब्राउज़र, डेवलपमेंट टूल, मॉडल रनिंग बफ़र, कॉन्टेक्स्ट कैश और DFlash 2 ड्राफ्ट मॉडल सभी एक ही यूनिफाइड मेमोरी के लिए प्रतिस्पर्धा करते हैं। मॉडल शुरू होने पर ठीक दिख सकता है, लेकिन सबसे आम विफलता तब होती है जब लंबा कोड इनपुट करने के बाद यह स्वैप करना शुरू कर देता है।

इसके अतिरिक्त, यह ट्यूटोरियल केवल Apple Silicon पर लागू होता है, जिसमें M1, M2, M3, M4 और M5 सीरीज़ के Mac शामिल हैं। Intel Mac इस MLX रूट का पालन नहीं करते हैं।

आखिर 27B क्या है? एक सामान्य ग़लतफ़हमी को सुधारना

मॉडल के नाम में 'B' का मतलब Billion (अरब) है।

तो 27B का मतलब लगभग 27 अरब पैरामीटर है, न कि 270 अरब।

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

Qwen3.8-27B एक Dense मॉडल है। Dense को सीधे तौर पर समझा जा सकता है: उत्पन्न प्रत्येक टोकन के लिए, मुख्य पैरामीटर गणना में भाग लेते हैं।

यह उन MoE मॉडलों से अलग है जिनके नाम में A3B या A10B होता है। उदाहरण के लिए, एक 35B-A3B मॉडल कुल 35 अरब पैरामीटर स्टोर कर सकता है, लेकिन हर बार केवल लगभग 3 अरब पैरामीटर ही सक्रिय करता है। इसे अभी भी सभी वज़न के लिए स्टोरेज स्पेस तैयार करना होता है, लेकिन प्रति टोकन गणना और मेमोरी रीडिंग बहुत कम होती है।

इसलिए, आप यह नहीं मान सकते कि दो मॉडलों की गति, मेमोरी उपयोग और क्षमता का स्तर समान है, सिर्फ इसलिए कि दोनों "लगभग 30B" कहते हैं। कुल पैरामीटर, सक्रिय पैरामीटर, मॉडल आर्किटेक्चर और क्वांटाइज़ेशन प्रेसिजन को एक साथ विचार करना होगा।

Qwen3.8-27B एक पारंपरिक "हर लेयर पर फुल अटेंशन" मॉडल नहीं है। आधिकारिक मॉडल कार्ड से पता चलता है कि इसमें 64 लेयर हैं, जो Gated DeltaNet और Gated Attention के हाइब्रिड आर्किटेक्चर का उपयोग करता है: मोटे तौर पर हर 3 लेयर लीनियर अटेंशन के बाद 1 लेयर स्टैंडर्ड अटेंशन होती है। यह मूल रूप से 262,144 टोकन कॉन्टेक्स्ट को सपोर्ट करता है, इसमें इमेज और वीडियो समझने की क्षमता है, थिंकिंग मोड डिफ़ॉल्ट रूप से सक्षम है, और reasoning_effort के माध्यम से रीज़निंग डेप्थ को समायोजित करने की अनुमति देता है।

ये क्षमताएँ बताती हैं कि यह कोड, रिसर्च, लंबे कार्यों और Agents के लिए क्यों उपयुक्त है; वे यह भी बताती हैं कि तैनाती के समय आप केवल "27B" क्यों नहीं देख सकते।

इसकी क्षमता का स्तर क्या है?

यदि हम मोटे तौर पर पर्सनल कंप्यूटर पर स्थानीय मॉडलों को वर्गीकृत करें:

• 3B–8B: तेज़ स्टार्टअप, कम ऑक्यूपेंसी, सामान्य Q&A, सरल निष्कर्षण और हल्के टूल कॉल के लिए उपयुक्त; जटिल कार्यों में भटकने की संभावना।
• 14B–30B: वर्तमान में सबसे व्यावहारिक उच्च-गुणवत्ता वाली रेंज, कोड जनरेशन, लंबे टेक्स्ट प्रोसेसिंग, संरचित विश्लेषण और Agent कार्य को विश्वसनीय रूप से संभालना शुरू करती है।
• 70B और उससे ऊपर Dense: समग्र स्थिरता अक्सर अधिक मजबूत होती है, लेकिन मेमोरी क्षमता और बैंडविड्थ की आवश्यकताएँ काफी बढ़ जाती हैं, और व्यक्तिगत तैनाती की लागत बहुत अधिक होती है।

Qwen3.8-27B बिल्कुल उस स्थिति में है जहाँ "व्यक्तिगत उपकरण वास्तविक रूप से तैनात कर सकते हैं, और क्षमता उत्पादन वर्कफ़्लो में प्रवेश करने के लिए पर्याप्त है।"

आधिकारिक मॉडल कार्ड में, इसने SWE-bench Pro पर 61.7 और Terminal Bench 2.1 पर 73.0 स्कोर किया; उसी तालिका में, Opus 4.6 Max ने क्रमशः 53.4 और 78.2 स्कोर किया। यह परिणाम इंगित करता है कि कुछ कोडिंग और टर्मिनल Agent कार्यों पर, Qwen3.8-27B क्लोज्ड-सोर्स फ़्लैगशिप के साथ एक ही तालिका में चर्चा किए जाने के योग्य है।

लेकिन इसे "27B ने क्लोज्ड-सोर्स फ़्लैगशिप को पूरी तरह से पीछे छोड़ दिया" के रूप में न लिखें।

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

एक अधिक सटीक स्थिति यह है: यह क्लोज्ड-सोर्स फ़्लैगशिप का पूर्ण प्रतिस्थापन नहीं है, लेकिन यह एक स्थानीय मॉडल है जो गंभीरता से काम करवा सकता है।

असली निर्णायक कारक मेमोरी गणना है

बहुत से लोग "मॉडल पैरामीटर काउंट" को सीधे "रनिंग मेमोरी" से जोड़ते हैं: 27B, तो 27GB चाहिए।

यह गणना गलत है। पैरामीटर काउंट को प्रत्येक पैरामीटर द्वारा घेरे गए बिट्स की संख्या से गुणा किया जाना चाहिए।

27 अरब पैरामीटर के लिए मोटे तौर पर गणना:

• BF16: 2 बाइट प्रति पैरामीटर, मूल वज़न लगभग 54GB।
• 8-bit: लगभग 1 बाइट प्रति पैरामीटर, सैद्धांतिक मान लगभग 27GB।
• 4-bit: लगभग 0.5 बाइट प्रति पैरामीटर, सैद्धांतिक मान लगभग 13.5GB।

सैद्धांतिक मान केवल मुख्य वज़न की गणना करते हैं। वास्तविक मॉडल रिपॉजिटरी में क्वांटाइज़ेशन स्केल, कॉन्फ़िगरेशन, वोकैबुलरी, विज़ुअल घटक आदि भी शामिल होते हैं। Hugging Face पर MLX कम्युनिटी वर्जन 4-bit के लिए लगभग 16.1GB और 8-bit के लिए लगभग 29.5GB है। एक टेक्स्ट BF16 कम्युनिटी कन्वर्ज़न स्पष्ट रूप से लगभग 54GB बताता है।

यह केवल "फ़ाइल कितनी बड़ी है" है, न कि "स्टार्टअप के बाद यह कितनी जगह घेरता है।" मॉडल चलने पर कम से कम चार प्रकार की जगह की खपत करेगा।

1. कॉन्टेक्स्ट कैश

मॉडल को यह याद रखना होता है कि उसने पहले क्या पढ़ा है, अन्यथा उसे हर नए टोकन के लिए सब कुछ फिर से गणना करनी होगी। स्टैंडर्ड अटेंशन भाग KV Cache का उपयोग करता है, और लीनियर अटेंशन लेयरों के अपने स्वयं के स्टेट होते हैं।

कॉन्टेक्स्ट जितना लंबा होगा, कैश उतना ही बड़ा होगा। mlx-dspark प्रोजेक्ट के परीक्षणों से पता चलता है कि Qwen3.8-27B के लिए 128K कॉन्टेक्स्ट पर, कैश लगभग 11GB जोड़ सकता है; एक पूर्ण 256K कॉन्टेक्स्ट लगभग 23GB जोड़ सकता है।

यही कारण है कि "मॉडल 262K सपोर्ट करता है" का मतलब यह नहीं है कि 24GB Mac को 262K खोलना चाहिए। क्षमता सीमा वह है जो मॉडल संभाल सकता है, न कि आपकी मशीन का आरामदायक डिफ़ॉल्ट।

2. रनिंग बफ़र और अस्थायी सक्रियण

जिस चरण में मॉडल एक लंबा प्रॉम्प्ट पढ़ता है उसे Prefill कहा जाता है। इस चरण के दौरान, बड़ी मात्रा में इनपुट को एक साथ संसाधित किया जाना चाहिए, और मेमोरी और गणना का दबाव अचानक बढ़ सकता है। जब आप केवल "नमस्ते" कहते हैं तो एक मेमोरी स्क्रीनशॉट 20,000 टोकन कोड चिपकाने के बाद की स्थिति का प्रतिनिधित्व नहीं करता है।

3. macOS और अन्य एप्लिकेशन

Apple Silicon का CPU और GPU यूनिफाइड मेमोरी साझा करते हैं, जो MLX की दक्षता का आधार है और यही कारण है कि मेमोरी बजट रूढ़िवादी होना चाहिए। मॉडल, सिस्टम, Chrome, Cursor, Docker और अन्य प्रोग्राम सभी एक ही पूल में जगह के लिए प्रतिस्पर्धा करते हैं।

4. DFlash 2 ड्राफ्ट मॉडल

DFlash 2 एक मुफ्त स्विच नहीं है। इसे एक अतिरिक्त ड्राफ्ट मॉडल और संबंधित कैश लोड करने की आवश्यकता होती है। प्रोजेक्ट एक पीक चैट लंबाई संदर्भ प्रदान करता है: 4-bit टार्गेट मॉडल प्लस ड्राफ्ट के लिए लगभग 18GB, और 8-bit के लिए लगभग 29GB। यह अभी भी macOS के लिए जगह आरक्षित नहीं करता है।

इसलिए, पूर्ण सूत्र होना चाहिए:

वास्तविक मेमोरी = मॉडल वज़न + कॉन्टेक्स्ट कैश + रनिंग बफ़र + ड्राफ्ट मॉडल + macOS और अन्य ऐप्स

इस सूत्र को समझना किसी भी ब्लॉगर के कंप्यूटर की गति को याद रखने से अधिक महत्वपूर्ण है।

4-bit, 8-bit, BF16: कैसे चुनें?

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

सामान्य Mac उपयोगकर्ताओं के लिए, मैं इस तरह चुनने का सुझाव देता हूँ:

24GB / 32GB: सीधे 4-bit से शुरू करें

मॉडल रिपॉजिटरी:

1mlx-community/Qwen3.8-27B-4bit

4-bit फ़ाइल लगभग 16.1GB है। 24GB इसे आज़मा सकता है, लेकिन आपको सक्रिय रूप से बड़े बैकग्राउंड एप्लिकेशन बंद करने चाहिए और 8K–16K कॉन्टेक्स्ट से शुरू करना चाहिए। 32GB दैनिक उपयोग के लिए अधिक उपयुक्त होगा।

सिर्फ इसलिए कि 24GB "लोड कर सकता है," अल्ट्रा-लॉन्ग कॉन्टेक्स्ट और DFlash 2 को जमा करते न रहें। पहले इसे स्थिर रूप से चलाएँ, फिर एक-एक करके वेरिएबल जोड़ें।

48GB / 64GB: 8-bit पर विचार करें

मॉडल रिपॉजिटरी:

1mlx-community/Qwen3.8-27B-8bit

8-bit फ़ाइल लगभग 29.5GB है। 48GB एक यथार्थवादी शुरुआती बिंदु है, और 64GB अधिक आरामदायक होगा। यदि आप गति, कॉन्टेक्स्ट स्पेस और सिस्टम मार्जिन को अधिक महत्व देते हैं, तो 64GB 4-bit का उपयोग जारी रख सकता है; केवल "उच्च सटीकता" के लिए 8-bit पर जाने की कोई आवश्यकता नहीं है।

BF16: "फिट हो सकता है" को "उपयोग के लिए उपयुक्त" न समझें

BF16 टेक्स्ट वज़न पहले से ही लगभग 54GB है। 64GB Mac सैद्धांतिक रूप से इसे फिट करने के करीब है, लेकिन सिस्टम, कैश और बफ़र जोड़ने के बाद, मार्जिन बहुत कम होगा। वास्तविक दीर्घकालिक उपयोग के लिए, 96GB और उससे ऊपर पर विचार करना बेहतर है।

अधिकांश लोगों के लिए, 4-bit और 8-bit के बीच अनुभव में अंतर "अपर्याप्त मेमोरी के कारण स्वैपिंग शुरू होने" के कारण होने वाले अंतर से बहुत छोटा है। एक बार लगातार स्वैपिंग होने पर, कोई भी क्वांटाइज़ेशन प्रेसिजन प्रतिक्रिया गति को नहीं बचा सकता है।

तैनाती-पूर्व तैयारी: चिप, मेमोरी और डिस्क की जाँच करें

पहले, टर्मिनल खोलें और मशीन की जानकारी की पुष्टि करें:

1system_profiler SPHardwareDataType

आपको एक Apple M-सीरीज़ चिप और यूनिफाइड मेमोरी क्षमता देखनी होगी।

फिर डिस्क की जाँच करें:

1df -h .

मॉडल वॉल्यूम के कम से कम दोगुने उपलब्ध स्थान को छोड़ने की सिफारिश की जाती है। डाउनलोड प्रक्रिया कैश उत्पन्न कर सकती है, उसके बाद ड्राफ्ट मॉडल, कई क्वांटाइज़ेशन वर्जन और लॉग। 4-bit के लिए 35GB से अधिक खाली स्थान और 8-bit के लिए 60GB से अधिक तैयार करना सबसे अच्छा है।

यह ट्यूटोरियल Python वातावरण प्रबंधित करने के लिए uv का उपयोग करता है। यदि स्थापित नहीं है:

1brew install uv

एक स्वतंत्र निर्देशिका और वर्चुअल वातावरण बनाएँ:

1mkdir -p qwen38-local/models
2cd qwen38-local
3
4uv venv .venv
5source .venv/bin/activate

इसका लाभ केवल "पेशेवर दिखना" नहीं है, बल्कि MLX, Transformers और अन्य प्रोजेक्ट्स के बीच निर्भरताओं के आपसी प्रदूषण से बचना है। यदि आप बाद में इसका उपयोग नहीं करना चाहते हैं, तो बस इस प्रोजेक्ट निर्देशिका को हटा दें।

आवश्यक उपकरण स्थापित करें:

1uv pip install -U huggingface_hub mlx-dspark

mlx-dspark को वर्तमान में Apple Silicon और Python 3.10 या उससे ऊपर की आवश्यकता है, और यह स्वचालित रूप से mlx-lm, mlx-vlm और उपयुक्त MLX निर्भरताएँ स्थापित करेगा।

मॉडल डाउनलोड करना: ब्राउज़र में एक-एक करके फ़ाइलों पर क्लिक न करें

बड़े मॉडल आमतौर पर कई वज़न शार्ड में विभाजित होते हैं। ब्राउज़र में एक-एक करके डाउनलोड करने में रुकावट, फ़ाइलों का गायब होना और फिर से शुरू करने में असुविधा होने की संभावना है। एक अधिक विश्वसनीय तरीका आधिकारिक Hugging Face hf कमांड का उपयोग करना है।

4-bit डाउनलोड कमांड

1MODEL_DIR="$PWD/models/Qwen3.8-27B-4bit"
2
3hf download mlx-community/Qwen3.8-27B-4bit \
4  --local-dir "$MODEL_DIR"

8-bit डाउनलोड कमांड

1MODEL_DIR="$PWD/models/Qwen3.8-27B-8bit"
2
3hf download mlx-community/Qwen3.8-27B-8bit \
4  --local-dir "$MODEL_DIR"

Hugging Face Hub का नया संस्करण Xet चंक्ड डाउनलोड का उपयोग करता है, जो नेटवर्क के आधार पर डिफ़ॉल्ट रूप से अनुकूली समवर्तीता का उपयोग करता है। अधिकांश लोगों को पिछले ट्यूटोरियल से पुराने hf_transfer कॉन्फ़िगरेशन को कॉपी करने की आवश्यकता नहीं है।

आप यह "हाई-परफॉरमेंस डाउनलोड" स्विच भी देख सकते हैं:

1HF_XET_HIGH_PERFORMANCE=1 hf download ...

इसे आँख बंद करके सक्षम न करें। Hugging Face आधिकारिक दस्तावेज़ में कहा गया है कि यह समवर्तीता, बफ़रिंग और CPU उपयोग को बढ़ाता है, जो इसे कम से कम 64GB मेमोरी वाली उच्च-बैंडविड्थ मशीनों के लिए अधिक उपयुक्त बनाता है। कम मेमोरी वाले Mac संसाधन प्रतिस्पर्धा के कारण वास्तव में धीमे हो सकते हैं। 24GB और 32GB मशीनों को पहले डिफ़ॉल्ट सेटिंग्स का उपयोग करना चाहिए।

डाउनलोड करने के बाद, निर्देशिका आकार की जाँच करें:

1du -sh "$MODEL_DIR"

पहला रन: पहले बेसिक स्पीड का परीक्षण करें, DFlash 2 को जल्दी सक्षम न करें

स्थानीय मॉडलों को तैनात करने में सबसे आम गलती एक साथ दस ऑप्टिमाइज़ेशन विकल्पों को चालू करना है। अंत में, यह तेज़ चल सकता है, लेकिन आप नहीं जानते कि किसे श्रेय दें; यदि यह धीमा चलता है, तो आप नहीं जानते कि किसे बंद करें।

सही क्रम पहले एक बेसलाइन चलाना है।

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

1कृपया Python में एक थ्रेड-सेफ कैश लागू करें जो एक्सपायरी टाइम और LRU एविक्शन को सपोर्ट करता हो। पहले डिज़ाइन समझाएँ, फिर पूरा कोड और टेस्ट प्रदान करें।

बेसलाइन परीक्षण:

1mlx-dspark generate \
2  --model "$MODEL_DIR" \
3  --mode baseline \
4  --prompt "कृपया Python में एक थ्रेड-सेफ कैश लागू करें जो एक्सपायरी टाइम और LRU एविक्शन को सपोर्ट करता हो। पहले डिज़ाइन समझाएँ, फिर पूरा कोड और टेस्ट प्रदान करें।" \
5  --max-new-tokens 600

चार संख्याएँ रिकॉर्ड करें:

1. मॉडल लोडिंग समय।
2. प्रॉम्प्ट प्रोसेसिंग गति (Prefill tok/s)।
3. पहले टोकन का समय (TTFT)।
4. औपचारिक जनरेशन गति (generation tok/s)।

जनरेशन गति यह निर्धारित करती है कि "शब्द एक-एक करके कितनी तेज़ी से निकलते हैं," जबकि Prefill और TTFT यह निर्धारित करते हैं कि "एंटर दबाने के बाद आपको कितनी देर इंतजार करना होगा।" कोड Agents के लिए, हर राउंड में बड़ी मात्रा में सिस्टम प्रॉम्प्ट और कोड को फिर से पढ़ने की आवश्यकता हो सकती है, इसलिए Prefill अक्सर शुद्ध जनरेशन गति से अधिक उपयोगकर्ता अनुभव को प्रभावित करता है।

परीक्षण के दौरान, "एक्टिविटी मॉनिटर → मेमोरी" भी खोलें और मेमोरी प्रेशर और Swap का निरीक्षण करें। पीला होने का तुरंत मतलब समस्या नहीं है, लेकिन यदि Swap लगातार बढ़ता रहता है, तो इसका मतलब है कि इस कॉन्फ़िगरेशन में कोई स्थिर मार्जिन नहीं है।

केवल 50 टोकन न चलाएँ। छोटे उत्तर लोडिंग और वार्म-अप समय को बहुत अधिक अनुपात में लाएँगे और निरंतर जनरेशन के दौरान वास्तविक गति नहीं दिखाएँगे। कम से कम 400–1000 टोकन उत्पन्न करने की सिफारिश की जाती है।

DFlash 2 27B को तेज़ कैसे चलाता है?

सामान्य डिकोडिंग सीरियल है। Qwen3.8-27B एक टोकन उत्पन्न करता है, पूरा टार्गेट मॉडल एक बार चलता है; अगला उत्पन्न करता है, और फिर से चलता है। 1000 टोकन उत्पन्न करने के लिए लगभग 1000 लगातार राउंड की आवश्यकता होती है।

DFlash 2 एक हल्का ड्राफ्ट मॉडल जोड़ता है। ड्राफ्ट मॉडल पहले समानांतर में उम्मीदवार टोकन का एक सेट प्रस्तावित करता है, और फिर 27B मुख्य मॉडल उन्हें सामूहिक रूप से सत्यापित करता है। सही अनुमान एक बार में कई स्वीकार किए जा सकते हैं, जबकि गलत को मुख्य मॉडल द्वारा ठीक किया जाता है।

आप इसे इस तरह सोच सकते हैं:

• ड्राफ्ट मॉडल एक सहायक है जो त्वरित ड्राफ्टिंग के लिए ज़िम्मेदार है।
• 27B मुख्य मॉडल अंतिम निर्णय शक्ति वाला प्रधान संपादक है।
• सहायक जितनी अधिक बार लगातार सही अनुमान लगाता है, प्रधान संपादक को उतने ही कम पूर्ण राउंड लेने पड़ते हैं।

ड्राफ्ट मॉडल स्वतंत्र रूप से आउटपुट का निर्णय नहीं लेता है। DFlash 2 मॉडल कार्ड में कहा गया है कि ग्रीडी डिकोडिंग के तहत, आउटपुट टार्गेट मॉडल के अनुरूप होता है; रैंडम सैंपलिंग के दौरान, यह टार्गेट मॉडल के वितरण को बनाए रखता है।

यह हर परिदृश्य में तेज़ी लाने की गारंटी भी नहीं है।

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

DFlash 2 सक्षम करना: टूल को स्वयं कैलिब्रेट करने दें, दूसरों के पैरामीटर कॉपी न करें

पहले प्रोजेक्ट के अंतर्निहित बेंचमार्क को चलाएँ:

1mlx-dspark benchmark \
2  --model "$MODEL_DIR" \
3  --modes dflash \
4  --caps auto \
5  --trials 3

यहाँ स्पष्ट रूप से --modes dflash निर्दिष्ट करें क्योंकि बेंचमार्क का वर्तमान संस्करण डिफ़ॉल्ट रूप से DSpark और lookup का परीक्षण करता है और स्वचालित रूप से Qwen3.8-27B के DFlash 2 पर स्विच नहीं होगा। पहला रन मिलान करने वाला ड्राफ्ट मॉडल डाउनलोड करेगा; --caps auto आपके Mac, टार्गेट मॉडल और क्वांटाइज़ेशन वर्जन के आधार पर उपयुक्त ड्राफ्ट कैप का परीक्षण करेगा। M1 Max, M4 Pro और M5 Max में अलग-अलग मेमोरी बैंडविड्थ और गणना लागत होती है, इसलिए इष्टतम पैरामीटर बिल्कुल समान नहीं होने चाहिए।

इसलिए, केवल इसलिए कि आपने किसी और को --max-draft 7 लिखते देखा है, इसे स्थायी रूप से कॉपी करने की अनुशंसा नहीं की जाती है। पहले स्वचालित कैलिब्रेशन को उत्तर देने दें, फिर वास्तविक कार्यों के साथ पुनः परीक्षण करें।

ऑटो मोड सक्षम करने के लिए उसी प्रॉम्प्ट का उपयोग करें:

1mlx-dspark generate \
2  --model "$MODEL_DIR" \
3  --mode auto \
4  --prompt "कृपया Python में एक थ्रेड-सेफ कैश लागू करें जो एक्सपायरी टाइम और LRU एविक्शन को सपोर्ट करता हो। पहले डिज़ाइन समझाएँ, फिर पूरा कोड और टेस्ट प्रदान करें।" \
5  --max-new-tokens 600

अब इसकी तुलना बेसलाइन से करें:

• क्या आउटपुट टेक्स्ट सुसंगत है?
• क्या TTFT काफी लंबा हो गया है?
• generation tok/s में कितना सुधार हुआ है?
• मीन एक्सेप्ट लेंथ क्या है?
• क्या पीक मेमोरी और Swap खराब हो गए हैं?

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

mlx-dspark प्रोजेक्ट के प्रोजेक्ट बेंचमार्क में M4 Pro 48GB पर, 8-bit लगभग 8.4 tok/s से बढ़कर 30.5 tok/s हो गया, औसतन लगभग 3.63 गुना; 4-bit लगभग 14.7 tok/s से बढ़कर 33.8 tok/s हो गया, औसतन लगभग 2.30 गुना।

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

वास्तव में उपयोगी मानदंड यह नहीं है कि "दूसरे 30 tok/s तक पहुँच गए," बल्कि यह है कि क्या आपके उच्च-आवृत्ति कार्य तेज़ हो गए हैं।

यदि आप आमतौर पर मॉडल से कोड संशोधित करवाते हैं, तो वास्तविक रिपॉजिटरी में संशोधन कार्यों के साथ इसका परीक्षण करें; यदि आप लेख लिखने के लिए इसका उपयोग करते हैं, तो लगातार 1500 टोकन उत्पन्न करें; यदि आप एक Agent कनेक्ट करना चाहते हैं, तो एक पूर्ण टूल कॉल चलाएँ। केवल अगर वास्तविक कार्यों का कुल समय कम हो जाता है, तो DFlash 2 को चालू रखना उचित है।

मॉडल को स्थानीय API के रूप में लॉन्च करना

यह पुष्टि करने के बाद कि बेसिक और ऑटो दोनों मोड स्थिर हैं, आप मॉडल को एक रेजिडेंट सेवा बना सकते हैं। 24GB Mac के लिए, पहले कॉन्टेक्स्ट को 8K तक सीमित करें:

1mlx-dspark serve \
2  --model "$MODEL_DIR" \
3  --mode auto \
4  --context-window 8192

32GB 16K से शुरू कर सकता है; स्थिर होने के बाद, धीरे-धीरे 32K तक बढ़ाएँ:

1mlx-dspark serve \
2  --model "$MODEL_DIR" \
3  --mode auto \
4  --context-window 16384

सेवा शुरू होने के बाद, दूसरे टर्मिनल में स्थिति की जाँच करें:

1curl http://127.0.0.1:8080/health
2curl http://127.0.0.1:8080/v1/models

/health वास्तविक मोड, कॉन्टेक्स्ट सीमा और मेमोरी चेतावनियाँ लौटाएगा; /v1/models वह मॉडल ID प्रदान करेगा जिसे क्लाइंट को भरना चाहिए।

दो प्रकार के क्लाइंट के लिए पतों को मिलाएँ नहीं:

1OpenAI Base URL: http://127.0.0.1:8080/v1
2Anthropic Base URL: http://127.0.0.1:8080
3Anthropic Messages route: /v1/messages

यह OpenAI और Anthropic दोनों संगत इंटरफ़ेस प्रदान करता है। चैट क्लाइंट, कोड टूल और Agents जो कस्टम Base URL का समर्थन करते हैं, आमतौर पर कनेक्ट किए जा सकते हैं।

curl के साथ एक वार्तालाप परीक्षण करें। निम्नलिखित 4-bit के लिए लौटाई गई मॉडल ID का उपयोग उदाहरण के रूप में करता है; यदि आपने 8-bit डाउनलोड किया है, तो कृपया इसे /v1/models द्वारा लौटाए गए वास्तविक मान से बदलें:

1curl http://127.0.0.1:8080/v1/chat/completions \
2  -H "Content-Type: application/json" \
3  -d '{
4    "model": "Qwen3.8-27B-4bit",
5    "messages": [
6      {"role": "user", "content": "तीन वाक्यों में समझाएँ कि यूनिफाइड मेमोरी क्या है।"}
7    ],
8    "max_tokens": 200
9  }'

जब केवल स्थानीय मशीन पर इसका उपयोग किया जाता है, तो 127.0.0.1 सबसे सुरक्षित और आसान विकल्प है। कुछ क्लाइंट आपको API Key भरने के लिए मजबूर करते हैं; आप कोई भी प्लेसहोल्डर स्ट्रिंग भर सकते हैं। जब प्रमाणीकरण सक्षम नहीं है, तो स्थानीय सेवा इसे सत्यापित नहीं करेगी।

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

कॉन्टेक्स्ट कैसे सेट करें ताकि मेमोरी फट न जाए?

सबसे विश्वसनीय तरीका अनुमान लगाना नहीं है, बल्कि चरणों में बढ़ाना है:

1. 24GB से 8K से शुरू करें, स्थिर होने के बाद 16K आज़माएँ।
2. 32GB से 16K से शुरू करें, फिर 32K आज़माएँ।
3. 48GB / 64GB से 32K से शुरू करें, कार्यों के लिए आवश्यकतानुसार 64K आज़माएँ।
4. केवल तभी 128K तक बढ़ाएँ जब वास्तव में अल्ट्रा-लंबे दस्तावेज़ों या बड़े कोडबेस को प्रोसेस कर रहे हों।

हर बार जब आप स्तर बढ़ाते हैं, तो वही परीक्षण दोहराएँ: फिक्स्ड प्रॉम्प्ट, फिक्स्ड अधिकतम आउटपुट, TTFT, जनरेशन स्पीड, पीक मेमोरी और Swap रिकॉर्ड करें।

"मॉडल 262K सपोर्ट करता है" एक क्षमता पैरामीटर है, डिफ़ॉल्ट अनुशंसा नहीं। दैनिक चैट, लेखन और अधिकांश कोडिंग कार्यों के लिए, 16K–32K पहले से ही कई परिदृश्यों को कवर कर सकता है।

बड़े कॉन्टेक्स्ट का मतलब ज़्यादा स्मार्ट नहीं है; बहुत अधिक अप्रासंगिक सामग्री भरने से मुख्य जानकारी कमज़ोर हो सकती है, जिससे मॉडल धीमा, अधिक महंगा और ट्रैक से भटकने की अधिक संभावना होती है।

यदि सेवा का उपयोग Agent के लिए किया जाता है, तो Prefix Cache को बनाए रखने को प्राथमिकता दें। कोड Agents के लिए System Prompts और टूल परिभाषाएँ अक्सर बहुत लंबी होती हैं; कई राउंड के बीच प्रीफ़िक्स का पुन: उपयोग करने से बार-बार होने वाले Prefill को काफी कम किया जा सकता है।

थिंकिंग मोड कैसे चुनें? परीक्षण में सबसे अनदेखा किया जाने वाला वेरिएबल

Qwen3.8 डिफ़ॉल्ट रूप से उत्तर देने से पहले सोचेगा। जटिल कोड संशोधनों, गणितीय तर्क, शोध विश्लेषण और मल्टी-राउंड Agent कार्यों के लिए, आप डिफ़ॉल्ट थिंकिंग मोड रख सकते हैं; सामान्य चैट, अनुवाद, सारांश और प्रारूप रूपांतरण के लिए, सोचने की प्रक्रिया अक्सर केवल प्रतीक्षा समय और आउटपुट टोकन बढ़ाती है।

यदि आप सोच बनाए रखना चाहते हैं लेकिन तर्क की गहराई कम करना चाहते हैं, तो पूर्ण कमांड का उपयोग करें:

1mlx-dspark serve \
2  --model "$MODEL_DIR" \
3  --mode auto \
4  --context-window 16384 \
5  --reasoning-effort low

यदि कार्य बहुत सीधा है, तो आप सोच बंद कर सकते हैं:

1mlx-dspark serve \
2  --model "$MODEL_DIR" \
3  --mode auto \
4  --context-window 16384 \
5  --no-thinking

ये दो पैरामीटर सेवा का डिफ़ॉल्ट व्यवहार सेट करते हैं। संबंधित फ़ील्ड का समर्थन करने वाले क्लाइंट प्रति अनुरोध उन्हें ओवरराइड भी कर सकते हैं, इसलिए टूल कनेक्ट करने के बाद, पुष्टि करें कि क्लाइंट ने चुपचाप अपने डिफ़ॉल्ट पर वापस नहीं बदल दिया है।

सभी कार्यों के लिए उपयुक्त कोई एक उत्तर नहीं है। "Low" प्रति राउंड तेज़ लग सकता है, लेकिन अपर्याप्त विश्लेषण के कारण Agent को बार-बार पुन: प्रयास करने का कारण बन सकता है, जिससे समग्र कार्य धीमा हो जाता है। सबसे विश्वसनीय तरीका अभी भी पूर्ण कार्य के लिए कुल समय की गणना करना है, न कि केवल पहले राउंड के उत्तरों की तुलना करना।

एक नियम याद रखना चाहिए: बेसलाइन बनाम DFlash 2 A/B परीक्षण करते समय, थिंकिंग मोड समान होना चाहिए। यदि एक में थिंकिंग ऑन है और दूसरे में ऑफ है, तो टोकन काउंट और टास्क पथ बदल जाता है, और गणना की गई गति का कोई तुलनात्मक अर्थ नहीं है। सैंपलिंग पैरामीटर, प्रॉम्प्ट, अधिकतम आउटपुट लंबाई, कॉन्टेक्स्ट और कोल्ड/हॉट स्टार्ट स्थितियाँ भी सुसंगत होनी चाहिए।

सबसे छोटा डिप्लॉयमेंट रूट: आवश्यक कमांड को एक साथ संपीड़ित करना

पहले जो चर्चा की गई थी वह यह है कि प्रत्येक चरण क्यों किया जाता है। यदि आप पहले से ही सिद्धांतों को समझते हैं और केवल इसे जल्दी से दोहराना चाहते हैं, तो आप निम्नलिखित क्रम में निष्पादित कर सकते हैं। उदाहरण 4-bit और 8K कॉन्टेक्स्ट चुनता है, जो 24GB Mac पर रूढ़िवादी शुरुआत के लिए उपयुक्त है; डाउनलोड और बेंचमार्क का वास्तविक समय नेटवर्क और चिप पर निर्भर करता है और "सबसे छोटे" में शामिल नहीं है:

1brew install uv
2
3mkdir -p qwen38-local/models
4cd qwen38-local
5uv venv .venv
6source .venv/bin/activate
7
8uv pip install -U huggingface_hub mlx-dspark
9
10MODEL_DIR="$PWD/models/Qwen3.8-27B-4bit"
11hf download mlx-community/Qwen3.8-27B-4bit \
12  --local-dir "$MODEL_DIR"
13
14mlx-dspark generate \
15  --model "$MODEL_DIR" \
16  --mode baseline \
17  --prompt "Explain unified memory and give three suggestions for running local large models." \
18  --max-new-tokens 400
19
20mlx-dspark benchmark \
21  --model "$MODEL_DIR" \
22  --modes dflash \
23  --caps auto \
24  --trials 3
25
26mlx-dspark serve \
27  --model "$MODEL_DIR" \
28  --mode auto \
29  --context-window 8192

इस कमांड सेट का लक्ष्य "पहले सुरक्षित रूप से चलाना" है, न कि हार्डवेयर को निचोड़ना। सफलतापूर्वक चलने के बाद, मेमोरी मार्जिन के आधार पर क्रम में 16K और 32K कॉन्टेक्स्ट आज़माएँ, या 4-bit रिपॉजिटरी को 8-bit से बदलें। परीक्षण डेटा के सार्थक होने के लिए एक बार में केवल एक वेरिएबल बदलें।

सेवा शुरू होने के बाद, तीसरे पक्ष के क्लाइंट से कनेक्ट करने में जल्दबाजी न करें; पहले /health और /v1/models तक पहुँचें। पूर्व पुष्टि करता है कि कोई मेमोरी चेतावनी नहीं है और अपेक्षित मोड वास्तव में सक्षम है, जबकि बाद वाला मॉडल ID की पुष्टि करता है। फिर लगभग 400 टोकन का एक लंबा उत्तर पूरा करें और Activity Monitor में मेमोरी प्रेशर और Swap का निरीक्षण करें। यदि सभी चार सामान्य हैं, तो Base URL को अपने दैनिक टूल में भरें। जाँच के ये कुछ मिनट अधिकांश "क्लाइंट कनेक्ट नहीं हो सकता" और "थोड़ी देर चलने के बाद पूरी मशीन लैगी हो जाती है" समस्याओं को समाप्त कर सकते हैं।

अगले दिन कैसे पुनरारंभ करें?

वर्चुअल एनवायरनमेंट और MODEL_DIR केवल वर्तमान टर्मिनल सत्र में प्रभावी होते हैं। जब आप अगले दिन टर्मिनल को फिर से खोलते हैं, तो आपको फिर से डाउनलोड या पुनर्स्थापित करने की आवश्यकता नहीं है; बस निर्देशिका पर वापस जाएँ, एनवायरनमेंट को सक्रिय करें और पथ को फिर से घोषित करें:

1cd qwen38-local
2source .venv/bin/activate
3MODEL_DIR="$PWD/models/Qwen3.8-27B-4bit"
4
5mlx-dspark serve \
6  --model "$MODEL_DIR" \
7  --mode auto \
8  --context-window 8192

टूल को अपग्रेड करते समय, वर्चुअल एनवायरनमेंट के भीतर निष्पादित करें:

1uv pip install -U huggingface_hub mlx-dspark

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

LAN एक्सेस: कम से कम पहले एक लॉक जोड़ें

डिफ़ॉल्ट 127.0.0.1 केवल स्थानीय मशीन द्वारा एक्सेस किया जा सकता है। यदि आप उसी Wi-Fi पर किसी अन्य Mac या iPad को इसे कॉल करने देना चाहते हैं, तो आप सभी नेटवर्क कार्ड पर सुन सकते हैं और साथ ही एक API Key सेट कर सकते हैं:

1mlx-dspark serve \
2  --model "$MODEL_DIR" \
3  --mode auto \
4  --context-window 16384 \
5  --host 0.0.0.0 \
6  --api-key "Please replace with a sufficiently long random string"

क्लाइंट 127.0.0.1 को इस Mac के LAN IP से बदलता है और अनुरोध में Authorization: Bearer your_key भेजता है। macOS फ़ायरवॉल की भी जाँच करें ताकि केवल विश्वसनीय नेटवर्क को पोर्ट 8080 तक पहुँचने की अनुमति हो।

यह अभी भी केवल एक LAN समाधान है। इंटरनेट के माध्यम से एक्सेस करने के लिए, आपको TLS, रिवर्स प्रॉक्सी, एक्सेस कंट्रोल और रेट लिमिटिंग की भी आवश्यकता है; राउटर पर सीधे 8080 मैप न करें। सबसे आसान तरीका एक विश्वसनीय VPN के माध्यम से होम नेटवर्क पर वापस आना और फिर स्थानीय सेवा तक पहुँचना है।

सामान्य समस्या निवारण

1. लोड होने के बीच में सिस्टम द्वारा मॉडल को मार दिया गया

पहले पुष्टि करें कि आपने सही क्वांटाइज़ेशन संस्करण चुना है। 24GB और 32GB को 8-bit गलती से डाउनलोड नहीं करना चाहिए, और BF16 को बिल्कुल न छुएँ। Docker, वर्चुअल मशीन, बड़ी संख्या में ब्राउज़र टैब और अन्य स्थानीय मॉडल बंद करें, फिर 4-bit पुन: प्रयास करें।

2. चल सकता है, लेकिन पूरा Mac बहुत लैगी हो जाता है

Swap देखने के लिए Activity Monitor खोलें। यदि Swap बढ़ता रहता है, तो पहले कॉन्टेक्स्ट छोटा करें, फिर DFlash 2 बंद करें। केवल मॉडल प्रक्रिया के अपने नंबरों को न देखें, क्योंकि यूनिफ़ाइड मेमोरी प्रेशर पूरे सिस्टम द्वारा एक साथ होता है।

3. DFlash 2 वास्तव में धीमा है

पुष्टि करें कि तुलना की स्थितियाँ सुसंगत हैं: एक ही प्रॉम्प्ट, एक ही आउटपुट लंबाई, एक ही थिंकिंग मोड, एक ही कोल्ड स्टार्ट या हॉट स्टार्ट। छोटे उत्तर स्पेक्युलेटिव डिकोडिंग लाभों को आंकने के लिए उपयुक्त नहीं हैं। तीन से अधिक राउंड चलाएँ और वास्तविक लंबे कार्यों के साथ परीक्षण करें।

यदि यह अभी भी धीमा है, तो इसका मतलब है कि वर्तमान कार्य स्वीकृति दर कम है, या ड्राफ्ट मॉडल द्वारा लाई गई अतिरिक्त मेमोरी के कारण सिस्टम ने स्वैप करना शुरू कर दिया। इसे बंद करना कोई विफलता नहीं है; एक स्थिर बेसलाइन पहले से ही एक प्रभावी समाधान है।

4. पहला टोकन बहुत धीमा है, लेकिन बाद की जनरेशन ठीक है

यह एक Prefill बाधा है। जाँच करें कि क्या इनपुट बहुत लंबा है, क्या हर राउंड में बड़ी संख्या में अप्रासंगिक फ़ाइलें बार-बार भरी जा रही हैं, और क्या Prefix Cache हिट हो रही है। Agents के लिए, प्रॉम्प्ट लंबाई को अनुकूलित करना अक्सर जनरेशन tok/s का पीछा जारी रखने से अधिक प्रभावी होता है।

5. डाउनलोड गति बहुत धीमी है या बाधित हो गई है

कैश और रिज़्यूमेशन का लाभ उठाने के लिए बस उसी hf download कमांड को फिर से चलाएँ। अधूरी निर्देशिका को हटाएँ और शून्य से शुरू न करें। जब Hugging Face एक्सेस अस्थिर हो, तो आधिकारिक रूप से अनुशंसित ModelScope रूट पर विचार करें।

6. इसे इमेज पहचानने देना चाहते हैं

"मॉडल में विज़ुअल क्षमता है" और "वर्तमान सेवा विज़ुअल इनपुट का समर्थन करती है" के बीच अंतर करें। उल्लिखित MLX रिपॉजिटरी विज़ुअल घटकों को बरकरार रखती है, लेकिन mlx-dspark वर्तमान में एक टेक्स्ट इन्फ़रेंस सेवा प्रदान करता है; इसे भेजी गई इमेज सामग्री मॉडल में प्रवेश नहीं करेगी।

इमेज का परीक्षण करने के लिए, आपको अस्थायी रूप से DFlash 2 को बायपास करना होगा और इसके बजाय mlx-vlm का उपयोग करना होगा:

1uv run python -m mlx_vlm.generate \
2  --model "$MODEL_DIR" \
3  --max-tokens 200 \
4  --temperature 0 \
5  --prompt "Please describe this image." \
6  --image "/absolute/path/example.jpg"

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

एक डिप्लॉयमेंट अनुक्रम जिसके विफल होने की संभावना सबसे कम है

एक निष्पादन चेकलिस्ट:

1. पुष्टि करें कि यह Apple Silicon Mac है।
2. 16GB के लिए 27B छोड़ दें; 24GB/32GB के लिए 4-bit चुनें; 48GB/64GB के लिए 8-bit पर विचार करें।
3. मॉडल के लिए पर्याप्त डिस्क स्थान आरक्षित करें और एक स्वतंत्र वातावरण बनाने के लिए uv का उपयोग करें।
4. पूर्ण रिपॉजिटरी डाउनलोड करने के लिए hf download का उपयोग करें; ब्राउज़र में एक-एक करके वेट फ़ाइलों पर क्लिक न करें।
5. पहले --mode baseline के साथ एक फिक्स्ड प्रॉम्प्ट चलाएँ, लोडिंग, Prefill, TTFT, जनरेशन स्पीड और मेमोरी रिकॉर्ड करें।
6. 8K, 16K या 32K कॉन्टेक्स्ट से शुरू करें; सीधे पूर्ण 262K न खोलें।
7. टूल को आपकी मशीन पर कैलिब्रेट करने देने के लिए mlx-dspark benchmark --modes dflash --caps auto --trials 3 चलाएँ।
8. बिल्कुल उसी वास्तविक कार्य के साथ बेसलाइन और auto की तुलना करें।
9. केवल तभी DFlash 2 को दीर्घकालिक रूप से सक्षम करें जब गति में उल्लेखनीय सुधार हो और मेमोरी प्रेशर स्थिर हो।
10. अंत में, स्थानीय API शुरू करें और कोड टूल, नॉलेज बेस या Agents से कनेक्ट करें।

स्थानीय डिप्लॉयमेंट का महत्व केवल API फीस बचाना नहीं है।

जब Qwen3.8-27B आपके Mac पर एक स्थानीय सेवा बन जाती है जिसे किसी भी समय कॉल किया जा सकता है, तो आप संवेदनशील कोड और दस्तावेज़ों को अपनी मशीन पर रख सकते हैं, ऑफ़लाइन सामग्री प्रोसेस कर सकते हैं, और इसे ऑटोमेशन कार्यों, व्यक्तिगत नॉलेज बेस और लंबे समय तक चलने वाले Agent वर्कफ़्लो में कनेक्ट कर सकते हैं।

मेरी अपनी पासिंग लाइन सरल है: सामान्य कार्य स्वैप नहीं करते हैं, उत्तर की गति सहनीय है, और मैं अगले दिन इसे सक्रिय रूप से खोलूंगा। केवल जब ये तीन पूरे होते हैं तो डिप्लॉयमेंट वास्तव में सफल होता है।

यदि आपने इसे पहले ही चला लिया है, तो कृपया टिप्पणियों में अपना "चिप मॉडल, यूनिफ़ाइड मेमोरी, 4/8-bit, कॉन्टेक्स्ट लंबाई, बेसलाइन और DFlash 2 tok/s" छोड़ने में संकोच न करें। यदि पर्याप्त डेटा है, तो मैं इसे Mac कॉन्फ़िगरेशन परीक्षण तालिका में व्यवस्थित करना जारी रख सकता हूँ।

यदि आपको अभी भी डिप्लॉयमेंट परेशानी भरा लगता है

मैंने इस लेख में शामिल इंस्टॉलेशन कमांड, मॉडल डाउनलोड, स्पीड टेस्ट, DFlash 2 एक्सेलेरेशन, स्थानीय API स्टार्टअप और सामान्य समस्या निवारण को एक डिप्लॉयमेंट चेकलिस्ट में व्यवस्थित किया है जिसका सीधे पालन किया जा सकता है:

1https://github.com/wdwxw/macRunqwen38_27b_install

आप स्वयं क्रम में कॉपी और निष्पादित कर सकते हैं, या इस GitHub रिपॉजिटरी को सीधे Codex या Claude Code को दे सकते हैं, इसे README.md पढ़ने दें, अपने Mac कॉन्फ़िगरेशन की जाँच करें और चेकलिस्ट के अनुसार इंस्टॉलेशन पूरा करें। इस तरह आपको एक लंबे लेख से बार-बार कमांड खोजने की आवश्यकता नहीं है, और बाद के अपडेट और समस्या निवारण अधिक सुविधाजनक हैं।