मुख्य सामग्री पर जाएँ

KTransformers ट्यूटोरियल: GLM-5.3-Flash को लोकली चलाएँ

GPU VRAM, सिस्टम RAM, SGLang, और KTransformers को मिलाकर हेटेरोजीनियस CPU-GPU इन्फरेंस के लिए एक विशाल MoE मॉडल लोकली चलाएँ।
· 11 मि॰ पढ़ें

AI के साथ खोजें

KTransformers एक ओपन-सोर्स इन्फरेंस फ़्रेमवर्क है जो इन्फरेंस के दौरान CPU और GPU को अलग-अलग एक्सपर्ट्स को सक्रिय रूप से निष्पादित करने देता है, ताकि आप Mixture-of-Experts (MoE) मॉडल्स चला सकें जो आपके GPU मेमोरी से कहीं बड़े हों। vLLM जैसे फ़्रेमवर्क भी वेट्स को CPU मेमोरी में ऑफ़लोड कर सकते हैं, लेकिन KTransformers खास तौर पर MoE मॉडल्स की स्पार्स संरचना के इर्द-गिर्द बनाया गया है।

इस ट्यूटोरियल में, हम KTransformers और SGLang का उपयोग करके GLM-5.3-Flash चलाएँगे—एक 320B-पैरामीटर मॉडल जिसके वेट्स 192 GB VRAM में नहीं समाते। हम CPU और GPU मेमोरी उपयोग की निगरानी करेंगे, एक्सपर्ट प्लेसमेंट के साथ प्रयोग करेंगे, OpenAI-कम्पैटिबल API को परखेंगे, और मॉडल को Pi से लोकल कोडिंग एजेंट की तरह जोड़ेंगे।

मुख्य विचार सरल है: CPU मेमोरी को केवल ओवरफ़्लो स्टोरेज की तरह बरतने के बजाय, KTransformers इन्फरेंस के दौरान CPU compute और GPU compute—दोनों का उपयोग करता है।

संक्षेप में

  • KTransformers बड़े MoE मॉडल्स को GPU VRAM और सिस्टम RAM में चलाता है, जहाँ RAM में रहने वाले एक्सपर्ट्स का compute CPU पर होता है।
  • GLM-5.3-Flash के नेटिव FP8 वेट्स लगभग 306 GiB लेते हैं, इसलिए आधिकारिक गाइड कम से कम 350 GB उपलब्ध सिस्टम मेमोरी की सिफारिश करता है।
  • हमने 2× RTX PRO 6000 GPUs (कुल 192 GB VRAM) पर 32K कॉन्टेक्स्ट विंडो के साथ पूरा मॉडल चलाया, लगभग 11 टोकन प्रति सेकंड की रफ़्तार पर।
  • सर्वर OpenAI-कम्पैटिबल API एक्सपोज़ करता है, इसलिए Pi जैसे कोडिंग एजेंट सीधे मॉडल का उपयोग कर सकते हैं।

KTransformers क्या है?

KTransformers एक ओपन-सोर्स इन्फरेंस फ़्रेमवर्क है जो बहुत बड़े भाषा मॉडल्स को GPU VRAM और CPU RAM के संयोजन से चलाता है। आमतौर पर, बड़े मॉडल को सर्व करना उसके अधिकांश वेट्स को GPU मेमोरी में लोड करने की मांग करता है, जो GLM-5.3-Flash जैसे मॉडल के लिए जल्दी ही महंगा हो जाता है।

KTransformers अलग तरीका अपनाता है: यह कई MoE एक्सपर्ट वेट्स को सिस्टम मेमोरी में रखता है और GPU मेमोरी को इन्फरेंस के उन हिस्सों के लिए सुरक्षित रखता है जिन्हें GPU एक्सेलेरेशन से सबसे अधिक लाभ मिलता है।

यह MoE मॉडल्स के लिए इसलिए अच्छा काम करता है क्योंकि हर टोकन के लिए हर एक्सपर्ट का उपयोग नहीं होता। उदाहरण के लिए, GLM-5.3-Flash में 288 रूटेड एक्सपर्ट्स हैं, लेकिन उसका राउटर हर टोकन के लिए उनमें से केवल 8 (साथ में 1 साझा एक्सपर्ट) चुनता है। इसलिए KTransformers एक्सपर्ट compute को CPU और GPU में बाँट सकता है:

KTransformers वर्कफ़्लो डायग्राम जो दिखाता है कि MoE एक्सपर्ट्स CPU और GPU के बीच विभाजित हैं

KT-Kernel और SGLang साथ में कैसे काम करते हैं

वर्तमान KTransformers स्टैक हेटेरोजीनियस CPU-GPU इन्फरेंस के लिए KT-Kernel को SGLang के साथ इंटीग्रेट करता है। हर कंपोनेंट अलग काम संभालता है:

  • SGLang सर्विंग रनटाइम देता है: API रिक्वेस्ट्स, बैचिंग, रिक्वेस्ट शेड्यूलिंग, KV-cache मैनेजमेंट, और GPU पैरेललिज़्म।
  • KT-Kernel मानक MoE एक्ज़ीक्यूशन पाथ को CPU-GPU-अवेयर एक्सपर्ट एक्ज़ीक्यूशन से बदल देता है। चुने गए एक्सपर्ट GPU पर चलते हैं, जबकि बाकी CPU मेमोरी में रहते हैं और CPU पर compute होते हैं।

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

दूसरे शब्दों में, KTransformers CPU मेमोरी और GPU मेमोरी को एक साझा इन्फरेंस सिस्टम की तरह मानता है, न कि पूरे मॉडल को GPU VRAM में फिट करने की ज़रूरत रखता है। यही वह बात है जो बहुत बड़े MoE मॉडल्स को उस हार्डवेयर पर चलने देती है जहाँ सामान्यतः इतनी GPU मेमोरी उपलब्ध नहीं होती।

GLM-5.3-Flash क्या है?

GLM-5.3-Flash, Z.ai का ओपन-वेट, नेटिवली मल्टीमॉडल MoE मॉडल है, जिसे अगस्त 2026 में MIT लाइसेंस के तहत जारी किया गया। “Flash” नाम के बावजूद यह एक बड़ा मॉडल है: कुल 320B पैरामीटर्स, जिनमें प्रति टोकन करीब 18B सक्रिय होते हैं।

लोकल इन्फरेंस के लिए ये स्पेक सबसे अहम हैं:

  • एक्सपर्ट्स: टॉप-8 रूटिंग के साथ 288 रूटेड एक्सपर्ट्स, साथ में 1 साझा एक्सपर्ट
  • वेट्स: आधिकारिक FP8 चेकपॉइंट (zai-org/GLM-5.3-Flash) के लिए करीब 306 GiB
  • कॉन्टेक्स्ट विंडो: अधिकतम 1M टोकन तक
  • इनपुट्स: टेक्स्ट, इमेज, और वीडियो, रीज़निंग और टूल कॉलिंग सपोर्ट के साथ

KTransformers सीधे आधिकारिक FP8 वेट्स पढ़ता है, इसलिए कोई कन्वर्ज़न या अतिरिक्त क्वांटाइज़ेशन स्टेप नहीं है। बेंचमार्क और पूर्ण मॉडल ओवरव्यू के लिए हमारा GLM-5.3-Flash गाइड देखें।

GLM-5.3-Flash हार्डवेयर आवश्यकताएँ

GLM-5.3-Flash के लिए हार्डवेयर का सवाल ज़्यादातर सिस्टम RAM पर केंद्रित है। आधिकारिक KTransformers GLM-5.3-Flash ट्यूटोरियल कम से कम 350 GB उपलब्ध सिस्टम मेमोरी रिज़र्व करने की सिफारिश करता है।

अनुशंसित सेटअप: 2× RTX PRO 6000

इस ट्यूटोरियल के लिए, हम लगभग इस स्पेसिफिकेशन वाली RunPod इंस्टेंस का उपयोग करते हैं:

GPU:         2× RTX PRO 6000
VRAM:        96 GB each
Total VRAM:  192 GB

System RAM:  350 GB+
Storage:     500 GB+
Python:      3.11

2× RTX PRO 6000 GPUs के साथ RunPod पॉड लॉन्च करना

GLM-5.3-Flash का आधिकारिक FP8 चेकपॉइंट लगभग 306 GiB (करीब 329 GB) है, जबकि हमारे दो GPUs मिलकर कुल 192 GB VRAM देते हैं। इसलिए पूरा मॉडल सिर्फ GPU मेमोरी में लोड नहीं हो सकता।

इसके बजाय, KTransformers MoE वेट्स का बड़ा हिस्सा सिस्टम RAM में रखता है और सबसे उपयोगी compute को GPUs पर ले जाता है। 350 GB की सिफारिश मॉडल वेट्स के साथ-साथ रनटाइम ओवरहेड के लिए पर्याप्त जगह छोड़ती है।

इस सेटअप में अधिक GPU मेमोरी RAM की ज़रूरत को खत्म नहीं करती। CPU मेमोरी KTransformers के हेटेरोजीनियस इन्फरेंस डिज़ाइन का जानबूझकर हिस्सा है: एक्सपर्ट वेट्स RAM में रहते हैं जबकि GPU मॉडल के उन हिस्सों को संभालता है जिन्हें एक्सेलेरेशन से सबसे ज़्यादा फ़ायदा होता है।

वर्तमान GLM-5.3-Flash इम्प्लीमेंटेशन में कुछ विशेष CPU और GPU आवश्यकताएँ भी हैं:

  • GPU: NVIDIA SM89 या SM120 आर्किटेक्चर्स, जिनमें RTX 40 सीरीज़, RTX 50 सीरीज़ और RTX PRO 6000 जैसे Blackwell वर्कस्टेशन कार्ड शामिल हैं।
  • CPU: AVX-512 सपोर्ट, जिस पर FP8 CPU एक्सपर्ट kernel निर्भर करता है।

क्या आप GLM-5.3-Flash एक ही GPU पर चला सकते हैं?

हाँ, बशर्ते आपके पास पर्याप्त सिस्टम RAM और समर्थित CPU हो। आधिकारिक ट्यूटोरियल में सिंगल-GPU कॉन्फ़िगरेशन शामिल है जो --kt-num-gpu-experts 0 सेट करता है, ताकि MoE एक्सपर्ट्स CPU साइड पर हैंडल हों।

हम यहाँ दो RTX PRO 6000 GPUs का उपयोग कर रहे हैं, लेकिन यह सख्त न्यूनतम आवश्यकता नहीं है। दूसरा GPU हमें ज़्यादा VRAM और अतिरिक्त हेडरूम देता है, ताकि अपेक्षाकृत नए KTransformers इम्प्लीमेंटेशन के साथ प्रयोग करते समय लचीलापन रहे—न कि सेटअप को उस सबसे छोटे हार्डवेयर पर कसकर ट्यून करना जो किसी तरह मॉडल चला सके।

चरण 1: SGLang के साथ KTransformers इंस्टॉल करें

एक साफ Python 3.11 एनवायरनमेंट बनाएँ और SGLang सपोर्ट के साथ KTransformers इंस्टॉल करें:

python3.11 -m venv /workspace/kt
source /workspace/kt/bin/activate

pip install --upgrade pip
pip install "ktransformers[sglang]"

सुनिश्चित करें कि KTransformers, KT-Kernel, SGLang, और CUDA सही ढंग से डिटेक्ट हो रहे हैं:

kt version

आपको कुछ इस तरह का आउटपुट दिखना चाहिए:

KTransformers CLI v0.7.0.post4

Python      3.11.13
Platform    Linux 6.8.0-136-generic
CUDA        13.0

Packages:
kt-kernel   0.7.0.post4
sglang-kt   0.7.0.post4

यह पुष्टि करता है कि KTransformers रनटाइम और उसका SGLang बैकएंड इंस्टॉल हैं और उपयोग के लिए तैयार हैं।

चरण 2: Hugging Face से GLM-5.3-Flash डाउनलोड करें

सर्वर शुरू करने से पहले, Hugging Face से आधिकारिक GLM-5.3-Flash चेकपॉइंट डाउनलोड करें:

hf download zai-org/GLM-5.3-Flash \
  --local-dir /workspace/GLM-5.3-Flash

Hugging Face से zai-org/GLM-5.3-Flash मॉडल डाउनलोड करना

चेकपॉइंट करीब 306 GiB है, इसलिए आपकी बैंडविड्थ के आधार पर डाउनलोड में समय लग सकता है।

फिर KTransformers को लोकल मॉडल पाथ पर पॉइंट करें:

export MODEL_PATH=/workspace/GLM-5.3-Flash

चरण 3: SGLang के साथ GLM-5.3-Flash सर्वर लॉन्च करें

अब दो-तरफ़ा टेन्सर पैरेललिज़्म के साथ GLM-5.3-Flash लॉन्च करें, ताकि दोनों RTX PRO 6000 GPUs का उपयोग हो। मॉडल 1M टोकन तक के कॉन्टेक्स्ट को सपोर्ट करता है, और आधिकारिक उदाहरण 501,025-टोकन की वैलिडेटेड कॉन्फ़िगरेशन उपयोग करते हैं। हम शुरुआत में 32K कॉन्टेक्स्ट विंडो लेते हैं, ताकि सेटअप परखते समय मेमोरी उपयोग अनुमानित रहे।

CUDA_VISIBLE_DEVICES=0,1 \
python -m sglang.launch_server \
  --model-path "$MODEL_PATH" \
  --kt-weight-path "$MODEL_PATH" \
  --served-model-name GLM-5.3-flash \
  --host 0.0.0.0 \
  --port 30000 \
  --tp-size 2 \
  --context-length 32768 \
  --max-total-tokens 32768 \
  --mem-fraction-static 0.85 \
  --chunked-prefill-size 2048 \
  --kt-method FP8 \
  --kt-cpuinfer 64 \
  --kt-threadpool-count 2 \
  --kt-num-gpu-experts 14 \
  --kt-gpu-prefill-token-threshold 2048 \
  --kt-expert-placement-strategy uniform \
  --cuda-graph-bs 1 2 4 \
  --enable-p2p-check \
  --tool-call-parser glm47 \
  --reasoning-parser glm45

SGLang और KTransformers के साथ zai-org/GLM-5.3-Flash मॉडल चलाना

यह कॉन्फ़िगरेशन मॉडल को पोर्ट 30000 पर OpenAI-कम्पैटिबल SGLang सर्वर के ज़रिए एक्सपोज़ करता है। दोनों GPUs --tp-size 2 के साथ उपयोग होते हैं, जबकि KTransformers MoE वर्कलोड का एक हिस्सा CPU पर रखता है और चुने गए एक्सपर्ट्स को GPUs पर प्लेस करता है।

पहले रन के लिए सेटिंग्स जानबूझकर संयमित रखी गई हैं: 32K कॉन्टेक्स्ट, 85% स्टैटिक GPU मेमोरी उपयोग, 14 GPU एक्सपर्ट्स, और 64 CPU इन्फरेंस थ्रेड्स। एक बार सर्वर स्थिर हो जाए, तो आप थ्रूपुट बढ़ाने के लिए बड़ी कॉन्टेक्स्ट विंडो, अधिक GPU एक्सपर्ट्स, या अलग मेमोरी सेटिंग्स के साथ प्रयोग कर सकते हैं।

मुख्य KTransformers लॉन्च फ़्लैग्स की व्याख्या

ऊपर दिए ज़्यादातर फ़्लैग्स मानक SGLang विकल्प हैं। ये वे हैं जो नियंत्रित करते हैं कि KTransformers CPU और GPU के बीच काम कैसे बाँटता है:

FlagValueयह क्या करता है
--kt-methodFP8एक्सपर्ट वेट्स की प्रिसिशन सेट करता है, जो GLM-5.3-Flash के नेटिव FP8 चेकपॉइंट से मेल खाती है।
--kt-cpuinfer64एक्सपर्ट compute के लिए उपयोग होने वाले CPU थ्रेड्स की संख्या।
--kt-threadpool-count2CPU थ्रेड पूल्स की संख्या, आमतौर पर NUMA नोड्स की संख्या से मिलाई जाती है।
--kt-num-gpu-experts14GPU पर प्रति MoE लेयर प्लेस किए जाने वाले एक्सपर्ट्स की संख्या।
--kt-expert-placement-strategyuniformGPU एक्सपर्ट्स कैसे चुने जाते हैं। अन्य विकल्पों में frequency, front-loading, और random शामिल हैं।
--kt-gpu-prefill-token-threshold2048प्रॉम्प्ट लंबाई, जिसके ऊपर प्रीफिल GPU-साइड लेयरवाइज़ पाथ पर स्विच करता है।

चरण 4: CPU-GPU ऑफ़लोडिंग और एक्सपर्ट प्लेसमेंट की जाँच करें

अब जब सर्वर चल रहा है, तो हम देख सकते हैं कि KTransformers GPU VRAM और सिस्टम RAM का उपयोग कैसे कर रहा है, फिर GPU-रेज़िडेंट एक्सपर्ट्स की संख्या बदलकर संसाधन उपयोग और प्रदर्शन में बदलाव देख सकते हैं।

RunPod पर, free -h भ्रामक हो सकता है क्योंकि कंटेनर होस्ट मशीन की कुल RAM देख सकता है न कि केवल पॉड के लिए उपलब्ध मेमोरी। बेहतर है कि GPU मेमोरी और कंटेनर मेमोरी को अलग-अलग मॉनिटर करें।

GPU VRAM उपयोग मॉनिटर करें

नया टर्मिनल खोलें और GPU उपयोग मॉनिटर करें:

watch -n 1 nvidia-smi

KTransformers के साथ GLM-5.3-Flash चलाते समय GPU VRAM उपयोग मॉनिटर करना

हमारी वर्तमान कॉन्फ़िगरेशन में, पूरी तरह लोड हुआ मॉडल प्रति GPU लगभग 48 GB उपयोग करता है, जिससे काफी VRAM अप्रयुक्त रहती है। यह संकेत देता है कि अधिक एक्सपर्ट्स को GPUs पर प्लेस करने की गुंजाइश है, या पर्याप्त सिस्टम RAM के साथ सिंगल-GPU कॉन्फ़िगरेशन परखने की।

RunPod पर कंटेनर RAM मॉनिटर करें

कंटेनर RAM के लिए, cgroup मेमोरी काउंटर्स सीधे पढ़ें:

watch -n 1 'echo -n "Used: "; awk "{printf \"%.1f GiB\n\", \$1/1024/1024/1024}" /sys/fs/cgroup/memory.current; echo -n "Limit: "; awk "{printf \"%.1f GiB\n\", \$1/1024/1024/1024}" /sys/fs/cgroup/memory.max'

RunPod पर कंटेनर सिस्टम मेमोरी उपयोग मॉनिटर करना

आप देखेंगे कि उपलब्ध सिस्टम RAM का बड़ा हिस्सा मॉडल वेट्स और CPU-साइड एक्सपर्ट्स ने घेर रखा है। यह अपेक्षित है: KTransformers जानबूझकर कई MoE एक्सपर्ट्स को RAM में रखता है, बजाय इसके कि वे सभी VRAM में रहें।

--kt-num-gpu-experts ट्यून करें

अब, --kt-num-gpu-experts के अलग-अलग मानों के साथ सर्वर को रीस्टार्ट करें। उदाहरण के लिए, इनकी तुलना करें:

0
10
20

--kt-num-gpu-experts नियंत्रित करता है कि प्रति MoE लेयर कितने एक्सपर्ट्स GPU पर प्लेस होंगे। 0 पर, एक्सपर्ट compute CPU साइड पर रहता है; मान बढ़ाने पर अधिक एक्सपर्ट्स GPU मेमोरी में चले जाते हैं।

हर कॉन्फ़िगरेशन के लिए GPU VRAM उपयोग, कंटेनर RAM उपयोग, टोकन प्रति सेकंड, और टाइम-टू-फ़र्स्ट-टोकन की तुलना करें। सामान्यतः, अधिक GPU एक्सपर्ट्स अधिक VRAM लेते हैं लेकिन CPU-साइड एक्सपर्ट एक्ज़ीक्यूशन घटता है, जो पर्याप्त VRAM होने पर इन्फरेंस प्रदर्शन सुधार सकता है।

आधिकारिक ट्यूटोरियल की एक चेतावनी: जब GLM-5.3-Flash के लिए Layerwise Prefill सक्षम हो, तो वर्तमान इम्प्लीमेंटेशन रेज़िडेंट GPU एक्सपर्ट काउंट को शून्य पर सामान्यीकृत कर देता है। यदि VRAM उपयोग रन के बीच मुश्किल से बदलता दिखे, तो यह संभावित कारण है।

यह प्रयोग KTransformers का मुख्य लाभ दिखाता है: CPU RAM और GPU VRAM एक ही इन्फरेंस सिस्टम के ट्यून करने योग्य हिस्से बन जाते हैं, ताकि आप स्पीड के बदले मेमोरी प्लेसमेंट का सौदा कर सकें—बजाय इसके कि पूरा MoE मॉडल GPUs पर ही फिट होना ज़रूरी हो।

चरण 5: OpenAI-कम्पैटिबल API का परीक्षण करें

सर्वर चल रहा है, तो अब हम पुष्टि कर सकते हैं कि मॉडल उपलब्ध है और SGLang के OpenAI-कम्पैटिबल API के ज़रिए वास्तविक रिक्वेस्ट भेज सकते हैं।

पहले जाँचें कि मॉडल रजिस्टर्ड है:

curl http://localhost:30000/v1/models

इसके बाद, एक टेस्ट प्रॉम्प्ट भेजें:

curl http://localhost:30000/v1/chat/completions \
  -H "Content-Type: application/json" \
  -d '{
    "model": "GLM-5.3-flash",
    "messages": [
      {
        "role": "user",
        "content": "Create a FastAPI application with a health endpoint."
      }
    ],
    "max_tokens": 500
  }'

KTransformers OpenAI-कम्पैटिबल API के ज़रिए GLM-5.3-Flash द्वारा जनरेटेड चैट कम्प्लीशन रिस्पॉन्स

यदि सेटअप सही काम कर रहा है, तो सर्वर जेनरेटेड कोड और उपयोग आँकड़ों के साथ एक सामान्य चैट कम्प्लीशन रिस्पॉन्स लौटाएगा।

चरण 6: Pi के साथ GLM-5.3-Flash को लोकल कोडिंग एजेंट के रूप में उपयोग करें

Pi एक हल्का-फुल्का कोडिंग एजेंट है जो किसी भी OpenAI-कम्पैटिबल मॉडल को अपने बैकएंड के रूप में उपयोग कर सकता है, जिससे GLM-5.3-Flash केवल प्रॉम्प्ट का जवाब देने के बजाय सीधे कोडिंग टास्क पर काम कर सकता है।

Pi इंस्टॉल करें

Pi को इसके इंस्टॉल स्क्रिप्ट से इंस्टॉल करें:

curl -fsSL https://pi.dev/install.sh | sh

Pi कोडिंग एजेंट इंस्टॉल करना

फिर Pi को अपने PATH में जोड़ें:

echo 'export PATH="/root/.local/share/pi-node/current/bin:$PATH"' >> ~/.bashrc
source ~/.bashrc

Pi को KTransformers सर्वर की ओर पॉइंट करें

एक मॉडल कॉन्फ़िगरेशन बनाएँ जो Pi को लोकल KTransformers सर्वर की ओर पॉइंट करे:

mkdir -p ~/.pi/agent && cat > ~/.pi/agent/models.json <<'EOF'
{
  "providers": {
    "ktransformers": {
      "baseUrl": "http://localhost:30000/v1",
      "api": "openai-completions",
      "apiKey": "local",
      "models": [
        {
          "id": "GLM-5.3-flash",
          "name": "GLM-5.3-Flash",
          "reasoning": true,
          "input": ["text"],
          "contextWindow": 32768,
          "maxTokens": 8192,
          "cost": {
            "input": 0,
            "output": 0,
            "cacheRead": 0,
            "cacheWrite": 0
          }
        }
      ]
    }
  }
}
EOF

Pi शुरू करें:

pi

फिर मॉडल सेलेक्टर खोलें:

/model

Pi में KTransformers-सेर्व्ड GLM-5.3-Flash मॉडल का चयन करना

GLM-5.3-Flash के साथ एक कोडिंग टास्क चलाएँ

GLM-5.3-Flash चुनें और कोई वास्तविक कोडिंग टास्क आज़माएँ:

Build a FastAPI service with /health and /users endpoints.
Add pytest tests and run them.

Pi कोडिंग एजेंट में GLM-5.3-Flash FastAPI कोडिंग टास्क पर काम करते हुए

कुछ ही सेकंड में, Pi फ़ाइलें बनाना, API लिखना, टेस्ट चलाना, और समस्या मिलने पर उन्हें ठीक करना शुरू कर देना चाहिए—जैसे-जैसे वह टास्क पर काम करता है।

SGLang और KTransformers इन्फरेंस सर्वर लॉग्स मॉनिटर करना

आप पहला टर्मिनल भी देख सकते हैं, जहाँ SGLang सर्वर चल रहा है। हमारे टेस्ट में जेनरेशन स्पीड लगभग 11 टोकन प्रति सेकंड थी। इस आकार के मॉडल के लिए, जिसमें पर्याप्त CPU ऑफ़लोडिंग हो, यह उचित है—और सेटअप को और ट्यून किया जा सकता है, अधिक एक्सपर्ट्स को GPUs पर ले जाकर।

GLM-5.3-Flash द्वारा FastAPI टास्क पूरा करने के बाद Pi कोडिंग एजेंट का सारांश

कुछ ही मिनटों में, मॉडल ने एंडपॉइंट्स बना लिए, टेस्ट लिखे और चलाए, स्मोक टेस्ट किया, और प्रोजेक्ट चलाने के तरीके की एक छोटी सी रूपरेखा भी दी।

दिलचस्प बात यह है कि पूरा मॉडल लोकली चल रहा है, भले ही उसके वेट्स उपलब्ध GPU VRAM से कहीं बड़े हैं। Pi कोडिंग-एजेंट लूप संभालता है, जबकि SGLang और KTransformers वास्तविक मॉडल इन्फरेंस संभालते हैं।

KTransformers बनाम vLLM बनाम llama.cpp

ऐसा नहीं है कि VRAM से बड़े मॉडल चलाने का बस एक ही तरीका KTransformers हो। vLLM और llama.cpp दोनों CPU ऑफ़लोडिंग सपोर्ट करते हैं, लेकिन वे काम को अलग तरह से बाँटते हैं:

फ़्रेमवर्कCPU मेमोरी का उपयोग कैसे करता हैएक्सपर्ट compute कहाँ चलता हैसबसे उपयुक्त उपयोग
vLLMवेट्स का हिस्सा CPU RAM में ऑफ़लोड करता है (--cpu-offload-gb) और ज़रूरत पर उन्हें GPU पर ट्रांसफ़र करता हैGPUहाई-थ्रूपुट सर्विंग, जब मॉडल अधिकांशतः VRAM में समा जाता है
llama.cppलेयर्स को CPU और GPU के बीच बाँटता है, और MoE एक्सपर्ट टेन्सर्स को RAM में रख सकता है (--n-cpu-moe)CPU और GPUकंज़्यूमर हार्डवेयर पर क्वांटाइज़्ड GGUF मॉडल्स
KTransformers + SGLangज़्यादातर एक्सपर्ट्स RAM में रखता है और प्रति लेयर नियत संख्या में एक्सपर्ट्स GPU पर प्लेस करता हैCPU और GPU, ऑप्टिमाइज़्ड AVX-512 एक्सपर्ट kernels के साथनेटिव-प्रिसिशन MoE मॉडल्स, जिन मशीनों में सैकड़ों GB RAM हो

इस सेटअप में SGLang और KTransformers एक-दूसरे के प्रतिस्पर्धी नहीं हैं। SGLang सर्विंग साइड संभालता है, जबकि KTransformers हेटेरोजीनियस CPU-GPU MoE एक्ज़ीक्यूशन संभालता है।

अंतिम विचार

मुझे इस सेटअप की सबसे पसंदीदा बात यह लगी कि KTransformers पारंपरिक इन्फरेंस स्टैक से थोड़ा अलग काम करता है। केवल मॉडल लेयर्स की शर्त में सोचने के बजाय, यह कुछ एक्सपर्ट्स को GPU पर प्लेस करता है जबकि बाकी सिस्टम RAM में रहते हैं, और CPU वाकई एक्सपर्ट compute में हिस्सा लेता है। CPU सिर्फ़ ओवरफ़्लो स्टोरेज की भूमिका नहीं निभाता।

इस ट्यूटोरियल में, हमने दो RTX PRO 6000 GPUs पर पूरा GLM-5.3-Flash मॉडल लोकली चलाया, भले ही उसके वेट्स उपलब्ध VRAM से कहीं बड़े हों।

यह सबसे तेज़ सेटअप नहीं है। मुझे लगभग 11 टोकन प्रति सेकंड मिल रहे थे, और GPU एक्सपर्ट्स की संख्या और प्लेसमेंट ट्यून करने की अभी काफी गुंजाइश है। यदि आपके पास पर्याप्त RAM है तो आप सिंगल GPU के साथ भी प्रयोग कर सकते हैं; मैंने यहाँ केवल अधिक हेडरूम देने के लिए दो GPUs का उपयोग किया।

मेरे लिए, इस गाइड की मुख्य सीख यही है: KTransformers इसलिए खास नहीं है कि उसने CPU ऑफ़लोडिंग “इजाद” की। यह इसलिए खास है क्योंकि यह CPU RAM, CPU compute, और GPU compute—तीनों को MoE मॉडल्स की स्पार्स संरचना के इर्द-गिर्द साथ में काम कराता है।

KTransformers और GLM-5.3-Flash FAQs

KTransformers के साथ GLM-5.3-Flash चलाने के लिए कितनी RAM चाहिए?

आधिकारिक KTransformers ट्यूटोरियल कम से कम 350 GB उपलब्ध सिस्टम मेमोरी की सिफारिश करता है। नेटिव FP8 वेट्स करीब 306 GiB लेते हैं, और शेष रनटाइम ओवरहेड को कवर करता है।

क्या KTransformers GLM-5.3-Flash को एक ही GPU पर चला सकता है?

हाँ। आधिकारिक ट्यूटोरियल में --kt-num-gpu-experts 0 वाली सिंगल-GPU कॉन्फ़िगरेशन शामिल है, जो एक्सपर्ट compute को CPU पर रखती है। फिर भी आपको पर्याप्त सिस्टम RAM और AVX-512 सपोर्ट वाला CPU चाहिए।

GLM-5.3-Flash के लिए KTransformers किन GPUs और CPUs को सपोर्ट करता है?

वर्तमान इम्प्लीमेंटेशन NVIDIA SM89 और SM120 GPUs को सपोर्ट करता है, जिनमें RTX 40 सीरीज़, RTX 50 सीरीज़, और RTX PRO 6000 शामिल हैं। CPU साइड पर, FP8 एक्सपर्ट kernel के लिए AVX-512 आवश्यक है।

KTransformers के साथ GLM-5.3-Flash कितनी तेज़ है?

हमारे टेस्ट में 2× RTX PRO 6000 GPUs पर 32K कॉन्टेक्स्ट विंडो और प्रति लेयर 14 GPU एक्सपर्ट्स के साथ जेनरेशन स्पीड लगभग 11 टोकन प्रति सेकंड रही। रफ़्तार मुख्यतः इस पर निर्भर करती है कि कितने एक्सपर्ट्स GPU पर बैठे हैं, आपका CPU कैसा है, और आपकी मेमोरी बैंडविड्थ कैसी है।

KTransformers और किन मॉडल्स को सपोर्ट करता है?

KTransformers कई बड़े MoE मॉडल्स को सपोर्ट करता है, जिनमें GLM-5, GLM-5.2, Kimi K2.5, MiniMax-M2.5, और Qwen3-235B-A22B शामिल हैं। वर्तमान सूची और मॉडल-विशिष्ट ट्यूटोरियल के लिए KTransformers GitHub रिपॉज़िटरी देखें।

Abid Ali Awan

लेखक

Abid Ali Awan

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

विषय