DGX Spark हैंडबुक

लेखक: @0xSero

समीक्षक: @alexocheema और @alexzfunk

विशेष धन्यवाद: @MiaAI_lab

अगर आप लोकली inference रन करने की सोच रहे हैं, तो जाहिर है आप इस दिलचस्प 'गोल्डन ब्रिक' के बारे में जरूर जानेंगे। यह एक ऐसी मशीन है जिसे AI को लोकली सर्व करने के लिए बनाया गया है — छोटी, साफ-सुथरी, शांत और अपेक्षाकृत सस्ती (NVIDIA का DGX Spark पेज)।

जब मैंने पहली बार DGX Spark के बारे में सुना, तो मुझे यह कुछ खास नहीं लगा। इसके 128 GB मेमोरी होने के बावजूद, 273 GB/s की मेमोरी बैंडविड्थ मुझे काफी कम लगी। तुलना के लिए बता दूं कि RTX 5090 में सिर्फ 32 GB VRAM होने के बावजूद लगभग 6.5 गुना ज्यादा बैंडविड्थ (1,792 GB/s) होती है।

जब Spark पहली बार लॉन्च हुआ था, तब speculative decoding जैसी inference engineering तकनीकें इतनी आम नहीं थीं, और ज्यादातर छोटे मॉडल भी उतने सक्षम नहीं थे।

जैसे-जैसे AI इंडस्ट्री आगे बढ़ रही है और विकसित हो रही है, इंटेलिजेंस को छोटे से छोटे आकार में समेटा जा रहा है, जिससे इन छोटी मशीनों का पूरा पोटेंशियल इस्तेमाल किया जा सकता है।

1. Inference engineering की मांग तेजी से बढ़ रही है।
2. LLMs inference engineering में ज्यादा माहिर होते जा रहे हैं।
3. हाई क्वालिटी inference सिस्टम को बेहतर बनाता है।

अब DGX Spark स्पीड के मामले में क्लाउड सर्विसेज के बराबर बेहद स्मार्ट मॉडल्स को रन कर सकता है, वो भी आपके घर या ऑफिस के आराम से। ऐसे ढेरों AI सॉफ्टवेयर मौजूद हैं जो आपको कोडिंग करने, टैक्स फाइल करने, पढ़ाई करने या सिर्फ एंटरटेन करने में मदद कर सकते हैं।

स्पीड से मेरा मतलब उन tokens per second से है जो एक इंसान देखता है। क्लाउड हार्डवेयर बहुत तेज होता है, लेकिन प्रोवाइडर्स उसे कई यूजर्स में बांट देते हैं और प्रति टोकन लागत के हिसाब से ट्यून करते हैं, इसलिए हर यूजर को उसका कम हिस्सा मिलता है। घर पर वह मशीन पूरी तरह आपकी होती है, तो उसकी पूरी ताकत सिर्फ आपको मिलती है। इस बारे में और जानकारी advanced notes में दी गई है।

Sparks को आपस में जोड़ने के लिए ही बनाया गया है

DGX Sparks बहुत कम पावर खींचते हैं। जब कोई मॉडल लोड होकर सर्व कर रहा होता है, तो ये अक्सर लगभग 95 W पर काम करते हैं।

इसी वजह से इन्हें ज्यादा कूलिंग की जरूरत नहीं पड़ती और discrete GPUs के मुकाबले ये काफी शांत होते हैं। आप बिना किसी डर के स्टैंडर्ड अमेरिकन सर्किट पर इनमें से 2 से 4 मशीनें एक साथ चला सकते हैं। असल बात रॉ एफिशिएंसी नहीं, यही है: मेमोरी स्पीड की प्रति यूनिट के हिसाब से, डेटा सेंटर वाला B300 प्रति जूल लगभग दोगुना काम करता है (advanced notes देखें)। Spark बस एक नॉर्मल वॉल सॉकेट में प्लग हो जाता है।

हर Spark में ConnectX-7 नेटवर्क कार्ड होता है जिसमें दो QSFP पोर्ट होते हैं, जिनकी रेटिंग 200 Gb/s या 25 GB/s होती है। इससे आप Sparks को आपस में वायर कर सकते हैं, ताकि मेमोरी और इफेक्टिव मेमोरी बैंडविड्थ बढ़ जाए।

DGX Sparks कैसे लिंक होते हैं

Tensor parallelism में हर वेट मैट्रिक्स को Sparks के बीच बांट दिया जाता है, और हर Spark दूसरों के साथ एक ही समय पर अपनी मेमोरी से सिर्फ अपना हिस्सा पढ़ता है। इसलिए रीड स्पीड जुड़ती जाती है (NVIDIA का अपना स्केलिंग टेस्ट):

• दो Sparks के लिए 546 GB/s
• तीन के लिए 819 GB/s
• चार के लिए 1,092 GB/s

यह लगभग लीनियर तरीके से स्केल होता है। NVIDIA के अपने टेस्ट में, राइटिंग स्पीड दो Sparks पर 2 गुना और चार पर 3.7 गुना तेज हो गई (टेबल 3)। यह इतना अच्छा इसलिए काम करता है क्योंकि ConnectX-7 लिंक में लेटेंसी बहुत कम होती है, और CUDA GPU कोड के अंदर से ही Sparks के बीच डेटा मूव कर सकता है (ऐसा क्यों होता है, इसके बारे में और जानें)।

मेमोरी भी इसी तरह जुड़ती है: हर एक में 128 GB, चार में 512 GB, जिसमें से प्रति Spark लगभग 120 GB मेमोरी AI वर्कलोड्स के लिए असल में इस्तेमाल की जा सकती है।

Sparks को स्टैक करने की क्षमता इसकी सबसे बड़ी समस्या यानी कम मेमोरी बैंडविड्थ को काफी हद तक दूर कर देती है। नॉर्मल सॉकेट पर इसकी कम पावर खपत इसे किसी एक यूजर या छोटे घर के लिए शानदार बनाती है।

असल में लिंक किए गए DGX Spark

Dense बनाम MoE

इस वक्त दो मुख्य मॉडल आर्किटेक्चर हैं: sparse और dense। Qwen3.6-35B जैसे Mixture-of-experts मॉडल हर जनरेट हुए टोकन पर सिर्फ 3B पैरामीटर्स एक्टिवेट करते हैं, जो Qwen3.8-27B से 9 गुना कम है।

यही कारण है कि sparse LLMs DGX Spark के लिए खास तौर पर उपयुक्त हैं। ये इसकी कम मेमोरी बैंडविड्थ के साथ बेहतरीन तालमेल बिठाते हैं, जिससे मॉडल के कुल आकार के बावजूद यूजर्स को तेज अनुभव मिलता है।

MoE सिर्फ DGX Spark के लिए ही अच्छा नहीं है। यह डेटा सेंटर्स में भी एक बेहतर आर्किटेक्चर है। लोकल सेटअप के लिए जो चीज बदली है वो एक थ्रेशोल्ड है: हम एक खास स्पीड की उम्मीद करते हैं, और जो dense मॉडल काफी स्मार्ट थे, वे घर पर इतनी तेजी से रन करने के लिए बहुत बड़े थे। MoE मॉडल्स ने उस सीमा को पार कर लिया है, इसलिए अब ये लोकल हार्डवेयर पर उपयोगी और तेज दोनों हैं। Dense मॉडल भी शायद आखिरकार उस मुकाम तक पहुंच ही जाएंगे।

Dense LLMs बनाम MoEs

Speculative Decoding

MTP, DSpark, या DFlash वाला कोई भी LLM ज्यादा बेहतर रहेगा, क्योंकि ड्राफ्ट मॉडल आमतौर पर बहुत छोटे होते हैं और सही टोकन जनरेट करने के लिए उन्हें ज्यादा कंप्यूटेशन की जरूरत नहीं पड़ती।

यह Sparks की throughput को काफी बढ़ा देता है, और इसके बदले सिर्फ 1 से 2 GB मेमोरी लगती है, जो Spark में भरपूर मात्रा में होती है।

MoE की तरह, speculative decoding हर जगह मदद करता है, सिर्फ घर पर नहीं। लेकिन इन दोनों ने मिलकर ही लोकल AI को उस थ्रेशोल्ड के पार पहुंचाया है। पहले बेहतरीन ओपन मॉडल्स घर के हार्डवेयर पर बेहद धीमे चलते थे।

Speculative decoding throughput कैसे बढ़ाता है

एक साथ कई agents

एक Spark एक साथ आठ या उससे ज्यादा रिक्वेस्ट्स सर्व कर सकता है, और हर एक अभी भी बातचीत वाली स्पीड पर चलती है। उदाहरण के लिए, Qwen3.6-35B, जो बेसिक कोडिंग, कंप्यूटर और ब्राउज़र इस्तेमाल करने, वीडियो और इमेज एडिटिंग, और सामान्य सपोर्ट देने में सक्षम है, एक साथ 8 सेशन चला सकता है, और हर एक लगभग 40 tok/s की स्पीड पर चलता है।

तुलना के लिए बता दें कि ChatGPT Pro सब्सक्रिप्शन पर, GPT-6-Astra औसतन 37 tok/s की स्पीड से चलता है।

Astra की औसत स्पीड

यह इसलिए संभव है क्योंकि Spark में इसकी मेमोरी स्पीड के हिसाब से काफी ज्यादा कंप्यूट पावर है। आठ लोगों को सर्व करने का मतलब है कि हर स्टेप पर मॉडल को एक ही बार पढ़ना है, लेकिन गणित आठ गुना करना है, और Spark के पास गणित करने की क्षमता बची रहती है। 16-bit पर, 273 GB/s के लिए इसमें लगभग 100 TFLOPS होते हैं, यानी पढ़े गए मेमोरी के हर बाइट पर लगभग 370 ऑपरेशंस। M3 Ultra में 819 GB/s के लिए लगभग 26 TFLOPS होते हैं, यानी करीब 32 (EXO के आंकड़े)। यानी Spark के 4-bit हार्डवेयर को गिनने से पहले ही यह प्रति बाइट लगभग 11 गुना ज्यादा कंप्यूट है, जो Macs में होता ही नहीं है।

असली काम

एक Spark पर Qwen3.6-35B ने एक वीडियो बनाया जिसे एक दिन के अंदर 80,000+ व्यूज मिल गए। इसमें सिर्फ 3 मिनट लगे: इसने 3 वीडियो वाला एक फोल्डर लिया, उन्हें आपस में जोड़ा, और फ्रेम रेट को X की लिमिट के अंदर रखते हुए वीडियो को 4 गुना तेज कर दिया।

https://x.com/0xSero/status/2072206209323802746

लागत

DGX Spark की शुरुआती कीमत $3,999 थी, जिसे बाद में बढ़ाकर $4,699 कर दिया गया। 2026 में सभी हार्डवेयर की कीमतें बढ़ गई हैं।

असल कीमत इससे भी ज्यादा है। NVIDIA का अपना स्टोर आउट ऑफ स्टॉक है। मुझे जो सबसे सस्ता मिला वो लगभग $5,000 का है, सेकंड हैंड वाले करीब $6,000 में बिक रहे हैं, और 21 सितंबर को मैंने देखा कि NVIDIA की साइट उसी मशीन के $7,999 मांग रही थी जिसे मैंने पांच हफ्ते पहले $4,699 में खरीदा था।

GX10 की प्राइसिंग

21 सितंबर को NVIDIA का मार्केटप्लेस। पोस्ट

4000$ - 4700%

खरीदारी की सलाह

• कोई भी GB10 मशीन काम करेगी। ASUS, Dell, MSI और अन्य कंपनियां इसी चिप के अपने वर्जन बेचती हैं। उनमें वही सॉफ्टवेयर और वही recipes चलते हैं। SSD का साइज जरूर चेक करें: कुछ बड़े मॉडल रखने के बाद 1 TB जल्दी भर जाता है। मैं 4 TB वाला लूंगा।
• दूसरे Spark के साथ केबल भी खरीदें, क्योंकि दोनों को आपस में जोड़ने के लिए आपको इसकी जरूरत पड़ेगी।
• कुछ OEMs बेहतर एयरफ्लो वाले Sparks ऑफर करते हैं

पावर, शोर और आपका बिजली का बिल

Discrete GPUs जितनी गर्मी और शोर पैदा करते हैं, उसे हल्के में नहीं लिया जा सकता। 4x 3090 के साथ आप आसानी से 1/5 मेमोरी के लिए 1600-2000W खर्च कर सकते हैं। मुझे अपना RTX Pro 6000 टावर ऑफिस से बाहर निकालना पड़ा क्योंकि वह नियमित रूप से कमरे का तापमान 35°C तक पहुंचा देता था।

एक सामान्य US होम सर्किट पूरे दिन सुरक्षित रूप से लगभग 1,440 वॉट चला सकता है (US इलेक्ट्रिकल कोड)। इससे ज्यादा के लिए नया सर्किट चाहिए होगा, जिसका मतलब है इलेक्ट्रीशियन को बुलाना।

• एक Spark मॉडल रन करते समय लगभग 90-200 वॉट इस्तेमाल करता है (ServeTheHome)। अगर आप इसे चौबीसों घंटे चालू रखें तो यह लगभग $12 प्रति माह बैठता है।
• चार Sparks मिलकर लगभग 500 वॉट लेते हैं, और एक स्विच करीब 240W लेता है। लगभग $66-100 प्रति माह, और ये सब एक ही आउटलेट में फिट हो जाते हैं।
• मेरा फोर-GPU सेटअप 1,600 वॉट तक जाता है। यह एक सर्किट की क्षमता से ज्यादा है, और लगभग $300 प्रति माह बैठता है।

ये आंकड़े कहां से आए। हर आंकड़ा एक अलग तरह की रीडिंग है, इसलिए यहां इन्हें साथ-साथ दिया गया है। मासिक लागत यह मानकर निकाली गई है कि मशीन 18 सेंट प्रति kWh के हिसाब से दिन में 24 घंटे उसी पावर पर चल रही है:

मेरे टेस्ट

चार Sparks 90 W के चार गुना से ज्यादा क्यों लेते हैं। 90 W का आंकड़ा तब का है जब एक Spark अकेले कोई मॉडल सर्व कर रहा हो। जब एक बड़ा मॉडल चार में बंटा होता है, तो हर Spark हर शब्द पर काम करता है और अपना नेटवर्क लिंक बिजी रखता है, इसलिए हर एक ज्यादा पावर खींचता है — मेरी रीडिंग में औसतन लगभग 125 W। तो $12 और $66 प्रति माह वो खर्च है जब मशीन चौबीसों घंटे पूरी ताकत से चले। असल इस्तेमाल में, जब मशीन खाली भी रहती है, खर्च इससे कम होता है।

बिजली भी सस्ती नहीं हो रही है। US में घरेलू कीमतें इस साल लगभग 5% बढ़कर 18 सेंट प्रति kWh हो गई हैं, जिसकी एक वजह नए डेटा सेंटर्स भी हैं। अगस्त में, GPU सेटअप, दो Sparks और चार एयर कंडीशनर एक साथ चलने की वजह से मेरा खुद का बिल दोगुना होकर $1,000 प्रति माह पहुंच गया।

DGX Spark की आवाज

और शोर? मेरा GPU सेटअप जेट इंजन जैसी आवाज करता है। मेरे चार Sparks अधिकतम इतनी आवाज करते हैं:

कुछ व्यावहारिक बातें:

• इन्हें हर तरह के AI मॉडल्स, वर्ल्ड मॉडल्स, इमेज जनरेशन आदि के साथ इस्तेमाल करें।
• इन्हें साइड के बल खड़ा करें। मेरे वाले इस तरह ज्यादा ठंडे रहते हैं, क्योंकि मेश के चारों तरफ जगह मिल जाती है।
• डीबगिंग में मदद के लिए discord/reddit/x कम्युनिटीज जॉइन करें
• अपने सभी डिवाइसेज पर tailscale सेटअप करें

वे छह मॉडल जो मैं असल में चलाता हूं

मैंने दर्जनों मॉडल ट्राई किए हैं। ये वो छह हैं जिन पर मैं बार-बार लौटता हूं।

एक टोकन लगभग तीन-चौथाई शब्द के बराबर होता है, और 30 से ऊपर की कोई भी स्पीड सामान्य बातचीत जैसी लगती है।

हर आंकड़े में काम का नाम क्यों बताया गया है। इनमें से ज्यादातर recipes speculative decoding का इस्तेमाल करते हैं, जिसमें एक छोटा हेल्पर मॉडल आगे का अनुमान लगाता है। कोड और JSON का अनुमान लगाना आसान है, साधारण टेक्स्ट का नहीं, इसलिए एक ही मशीन पर एक ही मॉडल किसी एक काम में दूसरे से दोगुनी स्पीड दे सकता है। लंबे prompts भी स्पीड कम कर देते हैं। इसलिए यहां हर स्पीड के साथ यह बताया गया है कि क्या लिखा जा रहा था और prompt कितना लंबा था:

कई कामों में इसे सही तरीके से मापने का तरीका NVIDIA का SPEED-Bench है, जो 11 कैटेगरी के असली prompts और 1K से 32K टोकन की इनपुट लेंथ पर speculative decoding को टेस्ट करता है। मैंने अभी तक इसे Sparks पर रन नहीं किया है।

• एक Spark: Qwen3.6-35B, Qwen3.8-Flash-Next, Qwen3.8-27B
• दो Sparks: GLM-5.3-Flash.
• चार Sparks: DeepSeek-V4.1-Flash.

दो Sparks पर Qwen3.8-Flash-Next एनिमेशन और एक छोटा गेम बना रहा है। (21 सितंबर) पोस्ट

इन्हें कहां से पाएं। हर मॉडल का अपना ऑफिशियल पेज है, और सेक्शन 6 में हर एक के लिए टेस्ट किया गया Spark recipe दिया गया है:

• Qwen3.6-35B, या NVIDIA का 4-bit वर्जन
• Qwen3.8-27B
• Qwen3.8-Flash-Next
• GLM-5.3-Flash, या मेरा वन-Spark बिल्ड
• DeepSeek-V4.1-Flash
• GLM-5.3, या मेरा 3-bit बिल्ड

बड़े मॉडल फिट कैसे हो जाते हैं

इसका जवाब है quantization। Quantization मॉडल के weights को कंप्रेस करता है, और इसमें कुछ डेटा लॉस होता है: हर weight को कम bits में स्टोर किया जाता है (मान लीजिए 16 की जगह 4), जिससे मॉडल का आकार एक-चौथाई रह जाता है, लेकिन कुछ बारीकियां खो जाती हैं। मकसद यह होता है कि weights को कंप्रेस करते हुए भी ओरिजिनल मॉडल के व्यवहार के जितना हो सके करीब पहुंचा जाए।

जितना ज्यादा कंप्रेस करेंगे, क्वालिटी उतनी ही गिरेगी। Turboderp ने Qwen3.8-27B के लिए इसे मापा है। हर डॉट एक कंप्रेस्ड वर्जन है। बाईं ओर जाने का मतलब छोटा आकार, और नीचे जाने का मतलब ओरिजिनल के ज्यादा करीब:

Qwen3.6-35B-A3B के कंप्रेस्ड वर्जन्स के लिए डिस्क साइज के मुकाबले Mean KL divergence, कई प्रोवाइडर्स से। Log scale। चार्ट: https://huggingface.co/turboderp/Qwen3.8-27B-exl3

Spark पर दो फॉर्मेट्स खास मायने रखते हैं:

• NVFP4 NVIDIA का 4-bit फॉर्मेट है, और Spark का चिप इसे सीधे पढ़ लेता है। Qwen3.6-35B 72 GB से घटकर 24 GB हो जाता है और एक Spark में आराम से फिट हो जाता है।
• EXL3 में आप चुन सकते हैं कि ठीक-ठीक कितने bits इस्तेमाल करने हैं। 4 bits पर GLM-5.3-Flash 176 GB का होता है और दो Sparks में फिट हो जाता है। 2 bits पर यह 85 GB का होता है और एक में फिट हो जाता है, हालांकि इसकी शार्पनेस थोड़ी कम हो जाती है।

टिप:

छोटे मॉडल्स के लिए 4 bits सबसे सही है, बड़े मॉडल्स के लिए 3 bits

कैसे पता करें कि कंप्रेस किया गया मॉडल अभी भी अच्छा है या नहीं। अच्छे model cards में बताया होता है कि छोटा वर्जन ओरिजिनल के कितना करीब है। दो आंकड़ों पर ध्यान दें:

• Top-1 agreement: छोटा मॉडल कितनी बार ओरिजिनल जैसा ही अगला शब्द चुनता है। जितना ज्यादा, उतना अच्छा। मेरा वन-Spark GLM-5.3-Flash लगभग 80% बार मेल खाता है।
• KL divergence: इसके अनुमान ओरिजिनल से कितना भटकते हैं। जितना कम, उतना अच्छा। मेरे unpruned GLM-5.3 (3 bits) का स्कोर 0.089 है। pruned 197 GB वर्जन का स्कोर 0.511 है। कम Sparks में फिट करने की यही कीमत है।

6. एक Spark से चार तक: स्टेप-बाय-स्टेप गाइड

यही वो हिस्सा है जिसके बारे में मुझसे सबसे ज्यादा पूछा जाता है। एक बार में एक कदम बढ़ें। हर स्टेप अपने आप में पूरा है, इसलिए जहां आप संतुष्ट हों, वहीं रुक सकते हैं।

नीचे दिए गए ज्यादातर recipes MiaAI Lab के हैं, जो बेहतरीन Spark सेटअप्स को ऐसे repos में पैक करते हैं जिन्हें आप क्लोन करके एक स्क्रिप्ट से शुरू कर सकते हैं। कुछ मेरे अपने हैं। हर एक में यह लिखा होता है कि उसे किस पर टेस्ट किया गया और वह कितनी तेज चला।

ये काम हर Spark पर एक बार कर लें:

1. इसे अपडेट करें। DGX Dashboard में दिए गए अपडेट्स रन करें, फिर रीबूट करें।
2. अपने लैपटॉप से इसे एक्सेस करें। NVIDIA Sync या साधारण SSH का इस्तेमाल करें। घर से बाहर इसे एक्सेस करने के लिए, NVIDIA का एक Tailscale playbook है।
3. Hugging Face अकाउंट और टोकन बनाएं। ज्यादातर recipes इसी से मॉडल डाउनलोड करते हैं। इसे .env फाइल में रखें, repo में कभी नहीं।
4. अपनी डिस्क चेक करें। मॉडल्स बड़े होते हैं। एक Spark वाले recipe को करीब 25 से 130 GB खाली जगह चाहिए। चार Sparks वाले DeepSeek recipe को पहले Spark पर लगभग 476 GB जगह चाहिए।
5. Docker पहले से मौजूद है। DGX OS इसके साथ आता है, और लगभग हर recipe इसके अंदर ही चलता है, इसलिए आपको Python packages हाथ से इंस्टॉल नहीं करने पड़ते।

स्टेप 1: एक Spark

LM Studio से शुरुआत करें। NVIDIA की स्टेप-बाय-स्टेप गाइड फॉलो करें, Qwen3.6-35B डाउनलोड करें, और चैटिंग शुरू करें। इसमें करीब एक घंटा लगता है। इससे आपको पता चल जाएगा कि मशीन सही काम कर रही है, इससे पहले कि आप कुछ मुश्किल काम हाथ में लें।

फिर किसी recipe पर आएं। Recipes vLLM या SGLang का इस्तेमाल करते हैं, जो LM Studio से तेज हैं और एक साथ कई agents को सर्व कर सकते हैं। इनमें से कोई एक चुनें:

1. Qwen3.6-35B (4-bit NVFP4) MiaAI Lab एक यूजर के लिए 95 tok/s, आठ के लिए कुल 317 ~50 GB
2. Qwen3.8-27B (4-bit NVFP4) MiaAI Lab DSpark हेल्पर के साथ कोड पर ~51 tok/s, चैट में ~23 ~24 GB
3. Qwen3.8-Flash-Next (4-bit NVFP4) MiaAI Lab एक यूजर के लिए 48.7 tok/s, आठ के लिए कुल 162.9 ~130 GB
4. GLM-5.3-Flash (2-bit EXL3) मेरा, या Mia के recipe का वन-Spark वर्जन 10 से 25 tok/s, 262K context, vision ~85 GB

पहला वाला सबसे आसान है। इसमें सिर्फ तीन लाइनें हैं:

1git clone <https://github.com/MiaAI-Lab/Unsloth-Qwen3.6-35b-NVFP4-DGX-Spark.git>
2cd Unsloth-Qwen3.6-35b-NVFP4-DGX-Spark
3./start.sh

जब यह रन होने लगे, तो आपके पास Spark पर एक OpenAI-स्टाइल एड्रेस होगा। Pi, opencode, Open WebUI, या आप जो भी टूल इस्तेमाल करते हैं, उसे इससे जोड़ दें।

टिप:

अगर कोई मॉडल शुरू नहीं हो रहा है, तो लगभग हमेशा दिक्कत मेमोरी की होती है। पहले बाकी मॉडल्स बंद करें। एक Spark एक बार में एक बड़ा मॉडल चलाता है।

स्टेप 2: दो Sparks

यही वो सेटअप है जिसे मैं सबसे ज्यादा रिकमेंड करता हूं। जैसा मैंने अगस्त में कहा था: "2 DGX Sparks और आपका काम बन गया।"

2 dgx sparks

केबल। आपको दोनों QSFP पोर्ट्स के बीच एक छोटी QSFP केबल चाहिए होगी। इनमें से कोई भी काम करेगी (केबल गाइड):

• NVIDIA की अपनी: QSFP Cable 0.4 m for DGX Spark, $99.99। अक्सर स्टॉक में नहीं होती।
• जिनका नाम NVIDIA की docs में है: Amphenol NJAAKK-N911 या Luxshare LMTQF022-SD-R, 0.5 m, लगभग $159 से $187।
• एक सस्ता 200G विकल्प: NVIDIA MCP1650-V00AE30, लगभग $84।

आप जो भी खरीदें, लिंक 200 Gb/s पर ही चलेगा। इसके लिए USB-C या 10 GbE पोर्ट का इस्तेमाल न करें। वे बहुत धीमे होते हैं।

लिंक सेटअप करें। NVIDIA का connect two Sparks playbook फॉलो करें। यह हर पोर्ट को एक एड्रेस देता है और स्पीड चेक करता है। फिर पहले Spark ("head") से दूसरे ("worker") तक passwordless SSH सेटअप करें। हर टू-Spark recipe को इसकी जरूरत होती है।

मेरी सलाह है कि इसे सेटअप करने के लिए claude या gpt से कहें, यह ज्यादा आसान है।

कोई recipe चुनें:

1. Qwen3.8-Flash-Next (4-bit NVFP4) MiaAI Lab MTP के साथ एक यूजर के लिए 52.1 tok/s, 1M तक context
2. GLM-5.3-Flash (4-bit EXL3) MiaAI Lab एक यूजर के लिए 62.9 tok/s, चार के लिए कुल 146.5, 850K context
3. DeepSeek-V4.1-Flash (2.9-bit EXL3) MiaAI Lab कोड पर 38.8 से 43.0 tok/s, 600K context
4. GLM-5.3 (3-bit EXL3, 197 GB तक pruned) मेरा model card फिट हो जाता है; स्पीड अभी मापी नहीं गई है

ज्यादातर टू-Spark recipes एक जैसे दिखते हैं: example settings कॉपी करें, दोनों Sparks के एड्रेस डालें, डाउनलोड करें, शुरू करें। यह GLM-5.3-Flash वाला है:

1cp .env.example .env     # HEAD_IP और WORKER_IP सेट करें
2./download.sh
3./start.sh

ध्यान दें:

Sparks को लिंक करना काम करता है, लेकिन सॉफ्टवेयर इसी हिस्से में सबसे कम परिष्कृत है। किसी टेस्ट किए गए recipe को फॉलो करें और पहली बार के लिए एक दोपहर का समय निकाल कर रखें।

स्टेप 3: तीन Sparks

तीन Sparks को किसी स्विच की जरूरत नहीं होती। हर Spark में दो QSFP पोर्ट होते हैं, इसलिए आप इन्हें त्रिकोण में केबल से जोड़ते हैं: A से B, B से C, C से A। यानी तीन केबल। NVIDIA इसे switchless ring के रूप में सपोर्ट करता है।

तीन Sparks आपको लगभग 384 GB देते हैं। यह उन चीजों के लिए काफी है जो दो में नहीं समातीं:

• DeepSeek-V4.1-Flash उसकी नेटिव precision के साथ। MiaAI Lab का recipe इसे तीन Sparks वाले त्रिकोण पर एक यूजर के लिए 51.0 tok/s की स्पीड से चलाता है, 256K context के साथ। इसमें एक doctor कमांड है जो शुरू करने से पहले SSH, Docker और नेटवर्क लिंक्स चेक कर लेता है।
• GLM-5.3-Flash को ज्यादा जगह के साथ। टू-Spark EXL3 recipe में तीन के लिए start-tp3.sh दिया गया है।
• GLM-5.3, unpruned। मेरे 293 GB बिल्ड को लगभग तीन Sparks जितनी मेमोरी चाहिए।

DeepSeek recipe इस बात का अच्छा उदाहरण है कि बड़े वाले कैसे चलते हैं। इसमें एक नहीं, बल्कि कुछ स्टेप्स होते हैं:

1./start.sh doctor    # ssh, docker, links, disk चेक करता है
2./start.sh share     # मॉडल फोल्डर को बाकी Sparks के साथ शेयर करता है
3./start.sh serve     # पहले workers को शुरू करता है, फिर head को

टिप:

कुछ मॉडल सिर्फ 2 या 4 में बराबर बंटते हैं। तीसरा Spark खरीदने से पहले चेक कर लें कि recipe में "3x" लिखा हो।

स्टेप 4: चार Sparks

चार Sparks आपको लगभग 512 GB देते हैं। इन्हें जोड़ने के दो तरीके हैं।

विकल्प A: एक स्विच (जो मैं इस्तेमाल करता हूं)। हर Spark से एक केबल 200 GbE स्विच तक जाती है, ताकि हर एक दूसरे से सिर्फ एक hop दूर हो। NVIDIA का इसके लिए एक playbook है। लोग जो स्विच इस्तेमाल करते हैं:

• MikroTik CRS812-8DS-2DQ-2DDQ-RM। इसके 400G पोर्ट्स दो 200G लिंक्स में बंट जाते हैं।
• MikroTik CRS804-4DDQ-hRM. एक छोटा विकल्प (फोर-Spark बिल्ड नोट्स)।
• Exxact के पास फोर-Spark क्लस्टर के लिए एक अच्छी शॉपिंग लिस्ट है: स्विच, केबल्स और पावर।

जैसा मैंने सितंबर में कहा था: "मुझे नहीं लगता कि मार्केट में microtik स्विच के साथ 4x sparks से बेहतर कोई डील है।"

विकल्प B: बिना स्विच। चारों को एक रिंग में जोड़ दें, हर Spark अपने दोनों पड़ोसियों से केबल से जुड़ा हो। जो Sparks पड़ोसी नहीं हैं, वे बीच वाले के जरिए बात करते हैं। इससे स्विच की बचत होती है, लेकिन इसे सेटअप करना मुश्किल है:

• SparkRing स्विचलेस पेयर्स और फोर-स्पार्क रिंग्स के लिए एक पूरा सॉफ़्टवेयर स्टैक है। यह अल्फा सॉफ़्टवेयर है, इसलिए कोई वर्शन पिन करके रखें।
• यह GLM-5.3-Flash रेसिपी चार छोटी 100G केबल और पैच किए गए NCCL के साथ फोर-स्पार्क रिंग पर चलती है। आमतौर पर लगभग 45 tok/s, और वार्म होने पर 100 तक।

कोई रेसिपी चुनें:

• DeepSeek-V4.1-Flash (नेटिव) MiaAI Lab, start-tp4.sh एक यूज़र के लिए 45.4 tok/s, सोलह के लिए कुल 134.2, 1M कॉन्टेक्स्ट
• GLM-5.3-Flash (4-bit NVFP4) स्विचलेस रिंग ~45 tok/s सामान्य, ~100 वार्म

चार स्पार्क्स पर मेरे खुद के सबसे बेहतरीन रन में DFlash2 हेल्पर के साथ GLM-5.3-Flash के लिए 118 tok/s, और छोटे प्रॉम्प्ट्स पर DeepSeek-V4.1-Flash के लिए 83.8 से 95.3 tok/s मिले हैं (पोस्ट)।

हर कदम पर काम आने वाले टूल्स

• \\sparkDash:\\ आपके सभी Sparks को एक ही विंडो में दिखाने वाला वेब डैशबोर्ड। GPU, मेमोरी, नेटवर्क और लाइव टोकन प्रति सेकंड। इस गाइड में बताई गई कई स्पीड्स इसी से मापी गई हैं।
• \\NVIDIA की Spark प्लेबुक्स:\\ LM Studio, Ollama, vLLM, Sparks को लिंक करने और बहुत कुछ के लिए ऑफिशियल गाइड्स।
• \\local-ai-registry:\\ मेरी रेसिपीज़ और मेरे द्वारा किए गए हर स्पीड टेस्ट का रिकॉर्ड।
• \\b12x:\\ कई Spark रेसिपीज़ के पीछे काम करने वाला तेज़ मैथ्स। इसे आपको खुद इंस्टॉल नहीं करना होता; रेसिपीज़ खुद कर लेती हैं। नीचे दिए एडवांस्ड नोट्स देखें।

निष्कर्ष

Spark एक मेमोरी बॉक्स है। यह बड़े मॉडल्स को संभालता है, घर की बिजली पर शांति से उन्हें चलाता है, और जब भी आप एक और जोड़ते हैं तो और बेहतर हो जाता है।

अगर आप आज शुरुआत कर रहे हैं:

1. एक खरीदें और पहले ही दिन LM Studio से Qwen3.6-35B चलाएं।
2. रेसिपी पर शिफ्ट हों जब आपको स्पीड या कई एजेंट्स की ज़रूरत लगे।
3. दूसरा Spark और केबल खरीदें जब आपको GLM-5.3-Flash या DeepSeek-V4.1-Flash चाहिए हो। ज़्यादातर लोगों के लिए यहीं रुक जाना सही है।
4. तीन या चार पर तभी जाएं जब आपको सबसे बड़े मॉडल्स चाहिए हों या एक साथ कई चलाने हों।

क्या मैं इन्हें दोबारा खरीदूंगा? हाँ। और अगर मुझे शून्य से शुरू करना होता, तो मैं पहले दिन ही दो खरीद लेता।

एडवांस्ड: Sparks को लिंक करने से स्केलिंग कैसे होती है

Spark इस्तेमाल करने के लिए आपको यह जानना ज़रूरी नहीं है। यह उन लोगों के लिए है जो समझना चाहते हैं कि आंकड़े ऐसे क्यों दिखते हैं।

लिखने के मामले में, लगभग लीनियर

मॉडल जो भी हर शब्द लिखता है, उसका मतलब है मेमोरी से उसके एक्टिव वेट्स को पढ़ना। मॉडल को Sparks में बांट दें तो हर एक अपना हिस्सा एक साथ पढ़ता है, इसलिए रीड स्पीड जुड़ती जाती है।

NVIDIA ने इसे मापा है। एक से दो और फिर चार Sparks पर जाने से, हर शब्द लिखने का समय 269 ms से घटकर 133 ms और फिर 72 ms रह गया। यानी दो के साथ 2.0x और चार के साथ 3.7x (NVIDIA का ब्लॉग, टेबल 3)।

यह इतना करीब इसलिए पहुंच पाता है क्योंकि ConnectX-7 लिंक की लेटेंसी बहुत कम है, और Sparks के बीच डेटा का आदान-प्रदान सीधे GPU कोड के अंदर ही हो सकता है। Macs के लिए दी गई यह व्याख्या इसी बात को और विस्तार से समझाती है।

हर लेयर के बाद, अगली लेयर शुरू होने से पहले Sparks अपने आंशिक नतीजे आपस में बदलते हैं। यह बदलाव छोटा होता है, लेकिन हर लेयर और हर शब्द के लिए होता है। हर बार थोड़ा समय लगता है, जो Sparks बढ़ाने से कम नहीं होता।

• लिंक 200 Gb/s का है, यानी लगभग 25 GB/s। यह Spark की अपनी मेमोरी स्पीड का दसवां हिस्सा है। यह ठीक है क्योंकि ये बदलाव छोटे होते हैं।
• यह RDMA इस्तेमाल करता है। डेटा CPU की कॉपी किए बिना सीधे एक Spark की मेमोरी से दूसरे की मेमोरी में जाता है। हर QSFP पोर्ट दो 100 Gb/s हिस्सों के रूप में दिखता है, और पूरे 200 पाने के लिए सॉफ़्टवेयर को दोनों का इस्तेमाल करना पड़ता है (विवरण)। इसके लिए NVIDIA की लाइब्रेरी NCCL यही काम करती है।
• पढ़ने की स्केलिंग, लिखने जितनी अच्छी नहीं होती। उसी NVIDIA टेस्ट में, 32K-टोकन प्रॉम्प्ट पढ़ने की स्पीड दो Sparks के साथ 1.6x और चार के साथ 2.1x तेज़ हुई। पढ़ने में हर स्टेप पर Sparks के बीच ज़्यादा डेटा मूव होता है।
• रिंग्स में हॉप्स बढ़ जाते हैं। तीन Sparks के त्रिकोण में, हर Spark केबल से बाकी दोनों से जुड़ा होता है। चार Sparks की रिंग में, कुछ जोड़े पड़ोसी के ज़रिए बात करते हैं। स्विच लगाने से सब एक हॉप की दूरी पर आ जाते हैं। SparkRing रिंग्स को तेज़ बनाने के लिए अपना खुद का स्वैप कोड (SIRCL) लिखता है।
• Mixture-of-experts मॉडल्स में दूसरा स्प्लिट जुड़ जाता है। रेसिपीज़ अक्सर tensor parallel को "expert parallel" के साथ मिलाती हैं, जिसमें अलग-अलग Sparks अलग-अलग experts को संभालते हैं।

तेज़ होने के दो और तरीके

• एक साथ कई यूज़र्स। Spark हर स्टेप में मॉडल को एक बार पढ़ता है और उसी एक रीड से सबको जवाब देता है। इसलिए कुल स्पीड सिंगल-यूज़र स्पीड से कहीं तेज़ी से बढ़ती है।
• एक स्पेक्युलेटिव डिकोडर मॉडल जो आगे का अनुमान लगाता है। MTP, DSpark और DFlash2 तीनों यही करते हैं। एक छोटा, तेज़ हेल्पर कई शब्दों का ड्राफ्ट बनाता है, और बड़ा मॉडल एक ही रीड में उन सबकी जांच कर लेता है। जब अनुमान सही निकलते हैं, तो एक की कीमत पर कई शब्द मिल जाते हैं। यही कारण है कि GLM-5.3-Flash साधारण टेक्स्ट पर 27 tok/s से बढ़कर स्ट्रक्चर्ड आउटपुट पर 65 tok/s तक पहुंच जाता है, वो भी उसी रेसिपी में।

एक Spark पर 4 bits में Qwen3.6-35B-A3B, स्पीड-अप हेल्पर चालू हालत में। स्रोत: local-ai-registry स्पीड टेस्ट, अगस्त 2026.

Cloud AI और Local AI अलग हैं

क्लाउड GPU, Spark से कहीं ज़्यादा तेज़ होता है। लेकिन क्लाउड प्रोवाइडर्स हर GPU को कई यूज़र्स में बांटते हैं, और वे प्रति टोकन लागत और प्रति यूज़र स्पीड के बीच किसी एक बिंदु को चुनते हैं। ज़्यादातर लागत को चुनते हैं, इसलिए हर यूज़र को प्रति सेकंड उतने टोकन नहीं मिलते जितने हार्डवेयर एक व्यक्ति को दे सकता है। InferenceX Qwen3.8-Flash-Next के लिए इसी ट्रेड-ऑफ का चार्ट दिखाता है।

घर पर ऐसा कोई ट्रेड-ऑफ नहीं होता। डिब्बा आपका है, तो आप उसकी पूरी ताकत एक ही इंसान पर लगा सकते हैं। यही वजह है कि हार्डवेयर भले ही क्लाउड जितना तेज़ न हो, लेकिन Spark उतना ही तेज़ महसूस हो सकता है।

sm_121: Spark सॉफ़्टवेयर अपनी अलग दुनिया क्यों है

हर NVIDIA GPU का एक "compute capability" नंबर होता है जो सॉफ़्टवेयर को बताता है कि उसमें कौन-से इंस्ट्रक्शन्स हैं। Spark का GPU 12.1, यानी sm_121 है (Simon Willison का पहला रिव्यू)। RTX 5090 और RTX PRO 6000 sm_120 हैं, जो इसी के करीबी रिश्तेदार हैं। NVIDIA के डेटा सेंटर चिप्स, B200 और B300, sm_100 और sm_103 हैं, यानी एक अलग परिवार।

यह इसलिए मायने रखता है क्योंकि सबसे तेज़ AI कोड एक बार में एक ही परिवार के लिए लिखा जाता है। जब Spark लॉन्च हुआ, तो बहुत सारा कोड या तो चला नहीं या धीमा चला (NVIDIA फोरम, vLLM इश्यू)।

इसका समाधान लोगों द्वारा Spark के लिए खास कोड लिखने में रहा है:

• Local Inference Lab का b12x sm_120 और sm_121 के लिए एक कर्नल लाइब्रेरी है: DGX Spark, RTX Spark, RTX 5090 और RTX PRO 6000। इसमें 4-bit मैट्रिक्स मैथ्स (NVFP4, MXFP4), DeepSeek-स्टाइल मॉडल्स के लिए attention, mixture-of-experts लेयर्स और एक तेज़ मॉडल लोडर शामिल है। यह pip install b12x से इंस्टॉल होता है, और vLLM रेसिपीज़ flashinfer_b12x जैसे फ्लैग्स से इसे चालू करती हैं। Qwen3.6-35B रेसिपी इसी का इस्तेमाल करती है।
• SparkInfer b12x का पुराना नाम है। पुराना लिंक अब b12x पर रीडायरेक्ट होता है। मेरी वन-स्पार्क DeepSeek रेसिपी पढ़ने और लिखने दोनों के लिए इसके attention कोड का इस्तेमाल करती है। इसे gittensor के sparkinfer से कन्फ्यूज़ न करें, जो RTX कार्ड्स (सिर्फ sm_120) के लिए एक अलग रनटाइम है।
• ExLlamaV3 वह है जो EXL3 मॉडल्स चलाता है। MiaAI Lab Arm (GB10) पोर्ट और हेल्पर-मॉडल सपोर्ट के साथ एक फोर्क मेंटेन करता है।
• lil Local Inference Lab का लॉन्चर है। यह मशीन का लेआउट पढ़ता है और एक Spark या लिंक्ड ग्रुप के लिए सही vLLM कमांड तैयार करता है।

एडवांस्ड: एक रिसर्च मशीन के रूप में Spark

यह वो हिस्सा है जिसकी मुझे उम्मीद नहीं थी। Spark लिखने में धीमा है, लेकिन पढ़ने में बहुत तेज़ है। और मॉडल्स पर होने वाली ज़्यादातर रिसर्च का काम पढ़ना ही है।

Spark सबसे अच्छा क्या करता है: prefill

एक मॉडल दो अलग-अलग काम करता है:

• Prefill का मतलब है आपका प्रॉम्प्ट पढ़ना। पूरा प्रॉम्प्ट एक साथ प्रोसेस होता है, इसलिए सीमा सिर्फ रॉ कंप्यूटिंग पावर पर निर्भर करती है। GB10 में यह भरपूर है: 4-bit मैथ्स के लिए 1 पेटाफ्लॉप तक।
• Decode का मतलब है जवाब लिखना, एक बार में एक शब्द। हर शब्द का मतलब है मेमोरी से मॉडल को दोबारा पढ़ना, इसलिए सीमा मेमोरी स्पीड पर निर्भर करती है। यही Spark की कमज़ोरी है।

इसलिए Spark प्रॉम्प्ट्स को लिखने की तुलना में 13 से 41 गुना तेज़ी से पढ़ता है:

चार Sparks पर DeepSeek-V4.1-Flash: 32K-टोकन प्रॉम्प्ट पढ़ने पर 3,360 tok/s, 131K पर 3,273, जबकि लिखने की स्पीड 70 से 95 के आसपास बनी रहती है। (20 सितंबर) पोस्ट

रिसर्च को इसी की ज़रूरत क्यों है

मॉडल्स को छोटा बनाने के लिए मैं जो कुछ भी करता हूं, उसमें लगभग सब पढ़ना है, लिखना नहीं:

• Quantisation (कम bits)। EXL3 और NVFP4 बिल्ड्स बनाने के लिए सैंपल टेक्स्ट को मॉडल से गुज़ारा जाता है और मापा जाता है कि हर bit width पर हर लेयर कितना नुकसान करती है। यह पढ़ना है।
• Pruning (कम experts)। REAP सैंपल टेक्स्ट को mixture-of-experts मॉडल से गुज़ारता है और रिकॉर्ड करता है कि हर expert का कितना इस्तेमाल हुआ। सबसे कम काम आने वाले experts हटा दिए जाते हैं। मेरे 197 GB GLM-5.3 में 256 में से 168 experts बचे हैं। यह भी पढ़ना ही है।
• क्वालिटी चेक करना। Top-1 agreement और KL divergence तब मिलते हैं जब एक ही टेक्स्ट को ओरिजिनल और छोटे मॉडल से पढ़वाकर उनके अनुमानों की तुलना की जाती है। फिर से पढ़ना।
• लंबे कॉन्टेक्स्ट के टेस्ट। यह जांचना कि मॉडल 262,000 टोकन्स में से एक फैक्ट ढूंढ सकता है या नहीं, असल में एक बहुत लंबा रीड ही है।

मेरा खुद का वर्कफ़्लो ठीक इसी वजह से बदल गया। "अब मैं अपनी सारी pruning/exl3/benchmarking DGX Sparks पर चला रहा हूं, 6000s मैं inference के लिए रखता हूं। यह धीमा है, लेकिन 12 घंटे की जगह 2-3 दिन चलना ठीक है।" वन-स्पार्क DeepSeek जिसने 100,000 डाउनलोड्स पार किए, वह REAP-pruned और EXL3-squeezed मॉडल है।

यह रिसर्च के लक्ष्यों से कैसे जुड़ता है

अगर आपका लक्ष्य किसी मॉडल के बारे में कुछ सीखना है, तो Spark बिल्कुल फिट बैठता है:

• यह बड़े मॉडल को संभाल लेता है। आप क्लस्टर किराए पर लेने के बजाय एक या दो डिब्बों पर 300B मॉडल माप सकते हैं।
• यह घर की बिजली पर कई दिनों तक चलता है। लंबे कैलिब्रेशन और इवैल्यूएशन बिना किसी भारी बिल के, बिना निगरानी के चल सकते हैं।
• यह आपके तेज़ हार्डवेयर को आज़ाद रखता है। मेरे GPUs मॉडल्स सर्व करते हैं जबकि Sparks धीमा और बारीक काम संभालते हैं।
• आप अपने डेटा पर कैलिब्रेट कर सकते हैं। मैंने अपने एजेंट सेशन्स और लेखन पर मॉडल्स prune किए हैं, जो प्राइवेट है और मेरी डेस्क पर ही रहता है।
• यह रिसर्च एजेंट्स के लिए बेहतरीन होस्ट है। मैंने Sparks पर एक साथ चार एजेंट्स को रिसर्च लक्ष्यों पर काम करते देखा है, हर एक लगभग 120 tok/s पर।
• ट्रेनिंग Sparks पर अच्छी तरह स्केल होती है। NVIDIA के टेस्ट में, फाइन-ट्यूनिंग दो Sparks पर 2x और चार पर 4x तेज़ चली, क्योंकि Sparks हर स्टेप में सिर्फ एक बार सिंक करते हैं (टेबल 5)। NVIDIA की प्लेबुक्स PyTorch के साथ फाइन-ट्यूनिंग को कवर करती हैं। मैंने खुद ट्रेनिंग का समय नहीं मापा है।

एडवांस्ड: GB10, GB300, और अतिरिक्त मेमोरी के रूप में Spark

"GB" का मतलब Grace Blackwell है: एक ही पैकेज में Arm CPU और Blackwell GPU, जो NVLink-C2C नामक तेज़ लिंक के ज़रिए मेमोरी शेयर करते हैं। Spark में मौजूद GB10 इसी आइडिया का सबसे छोटा वर्शन है, जिसमें MediaTek के साथ बना 20-कोर Arm CPU है।

GB300 डेटा सेंटर वर्शन है: Grace CPU के साथ Blackwell Ultra (B300) GPUs। यह NVIDIA के GB300 NVL72 रैक्स में लगता है, और एक GB300 DGX Station को पावर देता है। GB10, GB300 में से काटा गया कोई टुकड़ा नहीं है। यह वही डिज़ाइन है जिसे छोटा बनाया गया है, यही वजह है कि एक ही सॉफ़्टवेयर दोनों पर चलता है।

निष्कर्ष

DGX Spark ने मेरे घर में अपनी एक अलग जगह बना ली है, और इसका सपोर्ट, उपयोगिता और क्षमता दिन-ब-दिन बढ़ती जा रही है।

स्रोत और आगे की पढ़ाई

• मेरी पोस्ट्स: ऊपर तारीख के साथ बताई गई हर चीज़ मेरे X प्रोफ़ाइल पर है। स्पीड्स मेरे खुद के टेस्ट्स से आई हैं, जो local-ai-registry में पब्लिश की गई हैं।
• रेसिपीज़: GitHub पर MiaAI Lab, मेरे Hugging Face मॉडल्स।
• हार्डवेयर और कीमत: NVIDIA का DGX Spark पेज, NVIDIA हार्डवेयर डॉक्स, कीमत बढ़ने पर VideoCardz, सितंबर की कीमतों पर VideoCardz, pi3g प्राइस ट्रैकर।
• Sparks को लिंक करना: NVIDIA क्लस्टरिंग डॉक्स, NVIDIA का स्केलिंग ब्लॉग, स्विच प्लेबुक, केबल गाइड, NVIDIA की टू-स्पार्क बेंचमार्किंग गाइड।
• पावर: ServeTheHome रिव्यू, आइडल पावर पर Tom's Hardware, अमेरिका की बिजली दरें (EIA via Utility Dive), लगातार चलने वाले लोड पर US इलेक्ट्रिकल कोड।
• फॉर्मैट्स और सॉफ़्टवेयर: NVFP4 पर NVIDIA, ExLlamaV3, b12x, REAP, compute capabilities।
• क्लाउड स्पीड: SemiAnalysis का InferenceX।
• GB300: GB300 NVL72 स्पेक्स, DGX Station स्पेक्स, Spark और Mac Studio पर EXO।
• शुरुआत कैसे करें: NVIDIA की Spark प्लेबुक्स।
• बड़ी तस्वीर: State of Local AI: 2026।