คู่มือ DGX Spark

ผู้เขียน: @0xSero

ผู้ตรวจทาน: @alexocheema และ @alexzfunk

ขอขอบคุณเป็นพิเศษ: @MiaAI_lab

ถ้าคุณกำลังคิดจะรัน inference แบบ local อยู่ล่ะก็ คุณจะต้องได้รู้จักกับ "อิฐทองคำ" ก้อนนี้อย่างแน่นอน มันคือเครื่องที่สร้างมาเพื่อรัน AI แบบ local โดยเฉพาะ ออกแบบมาให้เล็ก เรียบร้อย เงียบ และราคาค่อนข้างจับต้องได้ (หน้าผลิตภัณฑ์ DGX Spark ของ NVIDIA

ตอนแรกที่ผมได้ยินเรื่อง DGX Spark ผมไม่ได้ปลื้มมันเท่าไหร่ แม้จะมี หน่วยความจำ 128 GB แต่ memory bandwidth ที่ 273 GB/s ดูจะน้อยเกินไป เพื่อให้เห็นภาพ RTX 5090 มี bandwidth สูงกว่าถึงประมาณ 6.5 เท่า (1,792 GB/s) ทั้งที่มี VRAM แค่ 32 GB เท่านั้น

ตอนที่ Spark เปิดตัวใหม่ ๆ เทคนิคด้าน inference engineering อย่าง speculative decoding ยังไม่เป็นที่นิยมมากนัก และโมเดลขนาดเล็กส่วนใหญ่ก็ยังเก่งไม่พอ

แต่เมื่อวงการ AI พัฒนาและเติบโตขึ้น ความฉลาดถูกบีบอัดให้เล็กลงเรื่อย ๆ ซึ่งทำให้กล่องเล็ก ๆ เหล่านี้สามารถรีดประสิทธิภาพออกมาได้เต็มที่

1. ความต้องการด้าน Inference engineering กำลังเพิ่มสูงขึ้น
2. LLM เริ่ม ทำงานด้าน inference engineering ได้เก่งขึ้น
3. Inference ที่มีคุณภาพสูงช่วยยกระดับระบบโดยรวม

ตอนนี้ DGX Spark สามารถรันโมเดลที่ฉลาดมาก ๆ ด้วยความเร็วเทียบเท่าบริการบนคลาวด์ได้เลย โดยทำทั้งหมดได้จากบ้านหรือออฟฟิศของคุณเอง ซอฟต์แวร์ AI ก็มีให้เลือกใช้เพียบ ไม่ว่าจะเป็นตัวช่วยเขียนโค้ด ยื่นภาษี อ่านหนังสือ หรือแค่ไว้คุยเล่นแก้เบื่อ

คำว่าความเร็วในที่นี้ หมายถึงจำนวน token ต่อวินาทีที่คนคนเดียวเห็น ฮาร์ดแวร์บนคลาวด์นั้นเร็วกว่ามาก แต่ผู้ให้บริการต้องแชร์ทรัพยากรนั้นให้ผู้ใช้หลายคน และปรับจูนเพื่อให้ต้นทุนต่อ token ต่ำที่สุด แต่ละคนจึงได้ส่วนแบ่งน้อยลง แต่ที่บ้าน เครื่องนี้เป็นของคุณคนเดียว ประสิทธิภาพทั้งหมดจึงเป็นของคุณ ดูรายละเอียดเพิ่มเติมได้ในหัวข้อหมายเหตุขั้นสูง

Spark เกิดมาเพื่อเชื่อมต่อกัน

DGX Spark กินไฟน้อยมาก ปกติจะอยู่ ราว ๆ 95 W ตอนโหลดโมเดลและเปิดให้บริการ

ด้วยเหตุนี้ มันจึงไม่ต้องพึ่งระบบระบายความร้อนมากนัก และเงียบกว่าการ์ดจอแยก (discrete GPU) พอสมควร คุณสามารถวางซ้อนกัน 2 ถึง 4 เครื่องบน วงจรไฟฟ้ามาตรฐานของอเมริกา ได้เลยโดยไม่ต้องกังวล และนั่นแหละคือประเด็นสำคัญ ไม่ใช่เรื่องของประสิทธิภาพดิบ ๆ เพราะถ้าวัดงานที่ทำต่อจูลในหน่วยความเร็วของหน่วยความจำ B300 ในดาต้าเซ็นเตอร์จะ ทำงานได้มากกว่าเกือบสองเท่า (ดูในหมายเหตุขั้นสูง) แต่ข้อดีของ Spark คือแค่เสียบปลั๊กเข้ากับเต้ารับธรรมดาที่ผนังก็ใช้งานได้แล้ว

Spark ทุกเครื่องมี การ์ดเครือข่าย ConnectX-7 พร้อมพอร์ต QSFP สองพอร์ต ซึ่งรองรับความเร็ว 200 Gb/s หรือ 25 GB/s สิ่งนี้ทำให้คุณสามารถ เชื่อมต่อ Spark เข้าด้วยกัน เพื่อเพิ่มขนาดหน่วยความจำและ memory bandwidth รวมได้

วิธีเชื่อมต่อ DGX Spark

เมื่อใช้ tensor parallelism weight matrix ทั้งหมดจะถูกแบ่งกระจายไปยัง Spark แต่ละเครื่อง และแต่ละเครื่องจะอ่านเฉพาะส่วนของตัวเองจากหน่วยความจำของตัวเองพร้อม ๆ กัน ทำให้ความเร็วในการอ่านรวมกันเพิ่มขึ้น (ผลการทดสอบ scaling ของ NVIDIA เอง):

• 546 GB/s สำหรับ Spark สองเครื่อง
• 819 GB/s สำหรับสามเครื่อง
• 1,092 GB/s สำหรับสี่เครื่อง

การขยายขนาดนี้ทำได้ใกล้เคียงเชิงเส้น (linear) ในการทดสอบของ NVIDIA เอง ความเร็วในการเขียนเพิ่มขึ้น 2 เท่าเมื่อใช้ Spark สองเครื่อง และเร็วขึ้น 3.7 เท่าเมื่อใช้สี่เครื่อง (ตารางที่ 3) ที่มันทำงานได้ดีขนาดนี้เพราะลิงก์ ConnectX-7 มี latency ต่ำมาก และ CUDA สามารถย้ายข้อมูลระหว่าง Spark จากภายในโค้ด GPU ได้เลย (อ่านเหตุผลเพิ่มเติม

หน่วยความจำก็รวมกันได้แบบเดียวกัน: เครื่องละ 128 GB สี่เครื่องก็ได้ 512 GB โดยแต่ละ Spark จะมีพื้นที่ให้ใช้งานจริงสำหรับงาน AI ประมาณ 120 GB

ความสามารถในการต่อพ่วง Spark หลายเครื่องช่วยแก้ปัญหาใหญ่ที่สุดของมัน นั่นคือ memory bandwidth ที่ต่ำกว่ารุ่นอื่น การกินไฟต่ำจนใช้กับเต้ารับปกติได้ ทำให้มันเป็นตัวเลือกที่ยอดเยี่ยมมากสำหรับผู้ใช้คนเดียวหรือครัวเรือนขนาดเล็ก

DGX Spark ที่เชื่อมต่อกันในชีวิตจริง

Dense vs MoE

ปัจจุบันสถาปัตยกรรมโมเดลหลัก ๆ มีสองแบบคือ sparse และ dense โมเดลแบบ Mixture-of-experts อย่าง Qwen3.6-35B จะเรียกใช้พารามิเตอร์เพียง 3B ต่อการสร้างหนึ่ง token ซึ่งน้อยกว่า Qwen3.8-27B ถึง 9 เท่า

สิ่งนี้ทำให้ sparse LLM เหมาะสมกับ DGX Spark เป็นพิเศษ เพราะเข้ากันได้ดีกับ memory bandwidth ที่ต่ำกว่า ช่วยให้ผู้ใช้ได้รับประสบการณ์ที่รวดเร็วแม้โมเดลจะมีขนาดใหญ่ก็ตาม

MoE ไม่ได้ดีแค่กับ DGX Spark แต่มันยังเป็นสถาปัตยกรรมที่ดีกว่าในดาต้าเซ็นเตอร์ด้วย สิ่งที่เปลี่ยนไปสำหรับการใช้งานแบบ local คือเรื่องของขีดจำกัด: เราคาดหวังความเร็วระดับหนึ่ง และโมเดลแบบ dense ที่ฉลาดพอกลับมีขนาดใหญ่เกินกว่าจะรันได้เร็วขนาดนั้นที่บ้าน แต่โมเดล MoE ข้ามขีดจำกัดนั้นมาแล้ว ตอนนี้มันจึงทั้งมีประโยชน์และทำงานได้เร็วบนฮาร์ดแวร์ local ส่วนโมเดล dense วันข้างหน้าก็อาจจะทำได้เช่นกัน

Dense LLMs vs MoEs

Speculative Decoding

LLM ตัวไหนที่มี MTP, DSpark หรือ DFlash จะเหมาะกับการใช้งานมากกว่า เพราะ draft models มักจะมีขนาดเล็กจิ๋วและไม่ต้องการพลังประมวลผลมากนักในการสร้าง token ที่ถูกต้อง

เทคนิคนี้ช่วยเพิ่ม throughput ที่ Spark ทำได้อย่างชัดเจน โดยแลกกับหน่วยความจำเพียง 1 ถึง 2 GB ซึ่ง Spark มีเหลือเฟืออยู่แล้ว

เช่นเดียวกับ MoE speculative decoding ช่วยได้ทุกที่ ไม่ใช่แค่การใช้งานที่บ้าน แต่เมื่อนำทั้งสองอย่างมาใช้ร่วมกัน มันคือสิ่งที่ผลักดัน AI แบบ local ให้ข้ามขีดจำกัดไปได้ เมื่อก่อนโมเดล open source ที่ดีที่สุดมักจะ รันช้าจนน่าปวดหัวบนฮาร์ดแวร์ที่บ้าน

วิธีที่ Speculative decoding ช่วยเพิ่ม throughput

ใช้งานหลาย agent พร้อมกัน

Spark เครื่องเดียวสามารถรองรับคำขอพร้อมกันได้แปดรายการขึ้นไป โดยแต่ละรายการยังทำงานได้เร็วระดับสนทนาปกติ ตัวอย่างเช่น Qwen3.6-35B ที่เขียนโค้ดพื้นฐาน ใช้คอมพิวเตอร์และเบราว์เซอร์ ตัดต่อวิดีโอและรูปภาพ รวมถึงตอบคำถามทั่วไปได้ สามารถรองรับเซสชันพร้อมกันได้สูงสุด 8 เซสชัน โดยแต่ละเซสชันทำความเร็วได้ประมาณ 40 tok/s

เพื่อให้เห็นภาพ แพ็กเกจ ChatGPT Pro ที่ใช้ GPT-6-Astra มีความเร็วเฉลี่ยอยู่ที่ 37 tok/s

ความเร็วเฉลี่ยของ Astra

ที่เป็นแบบนี้ได้เพราะ Spark มีพลังประมวลผลสูงมากเมื่อเทียบกับความเร็วหน่วยความจำ การให้บริการคนแปดคนยังหมายถึงการอ่านโมเดลเพียงครั้งเดียวต่อขั้นตอน แต่ต้องคำนวณมากขึ้นแปดเท่า ซึ่ง Spark มีพลังคำนวณเหลือเฟือ ที่ความละเอียด 16-bit มันมีประมาณ 100 TFLOPS สำหรับ bandwidth 273 GB/s คิดเป็นการคำนวณราว 370 ครั้งต่อหน่วยความจำ 1 ไบต์ที่อ่านเข้ามา ในขณะที่ M3 Ultra มีประมาณ 26 TFLOPS สำหรับ 819 GB/s คิดเป็นราว 32 ครั้ง (ตัวเลขจาก EXO) นั่นคือการคำนวณต่อไบต์ที่มากกว่าประมาณ 11 เท่า และยังไม่นับฮาร์ดแวร์ 4-bit ของ Spark ที่ Mac ไม่มี

งานจริง

Qwen3.6-35B บน Spark เครื่องเดียว สร้างวิดีโอ ที่ได้ยอดวิวมากกว่า 80,000 ครั้งภายในวันเดียว โดยใช้เวลารวมแค่ 3 นาที: มันดึงโฟลเดอร์ที่มีวิดีโอ 3 ไฟล์มาต่อกัน แล้วเร่งความเร็ววิดีโอขึ้น 4 เท่า พร้อมทั้งคุม frame rate ไม่ให้เกินลิมิตของ X

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

Marketplace ของ NVIDIA เมื่อวันที่ 21 กันยายน โพสต์

4000$ - 4700%

คำแนะนำในการซื้อ

• เครื่องที่ใช้ชิป GB10 รุ่นไหนก็ได้ ASUS, Dell, MSI และแบรนด์อื่น ๆ ล้วนขายเวอร์ชันของตัวเองที่ใช้ชิปตัวเดียวกัน รันซอฟต์แวร์เดียวกันและใช้สูตรตั้งค่าเดียวกัน อย่าลืมเช็คขนาด SSD: 1 TB เต็มเร็วมากถ้าคุณเก็บโมเดลใหญ่ ๆ ไว้สักสองสามตัว ผมแนะนำให้เอา 4 TB ไปเลย
• ซื้อสายเคเบิลมาพร้อมกับ Spark เครื่องที่สอง เพราะคุณต้องใช้มันเชื่อมสองเครื่องเข้าด้วยกัน
• OEM บางรายมีรุ่น Spark ที่ออกแบบการไหลเวียนอากาศมาดีกว่า

การใช้ไฟ เสียงรบกวน และค่าไฟของคุณ

เสียงและความร้อนที่การ์ดจอแยกสร้างขึ้นไม่ใช่เรื่องเล่น ๆ ถ้าใช้ 3090 สี่ใบ คุณอาจกินไฟถึง 1600-2000w ได้ง่าย ๆ แลกกับหน่วยความจำแค่ 1/5 ของที่ได้ ผมถึงกับต้องย้ายทาวเวอร์ RTX Pro 6000 ออกจากห้องทำงาน เพราะมันอบห้องจนอุณหภูมิแตะ 35 องศาเป็นประจำ

วงจรไฟฟ้าในบ้านทั่วไปของสหรัฐฯ สามารถรองรับการใช้ไฟได้ปลอดภัยที่ประมาณ 1,440 วัตต์ ตลอดทั้งวัน (ตามมาตรฐานไฟฟ้าของสหรัฐฯ) ถ้าใช้มากกว่านี้ต้องเดินวงจรใหม่ ซึ่งแปลว่าต้องจ้างช่างไฟ

• Spark หนึ่งเครื่อง ตอนรันโมเดลจะใช้ไฟประมาณ 90-200 วัตต์ (ServeTheHome) คิดเป็นเงิน ประมาณ $12 ต่อเดือน ถ้าคุณเปิดทิ้งไว้ตลอด 24 ชั่วโมง
• Spark สี่เครื่อง ใช้ไฟ รวมกันประมาณ 500 วัตต์ บวกกับสวิตช์อีกประมาณ 240w ตก เดือนละประมาณ $66-100 และทั้งหมดนี้เสียบรวมกันในปลั๊กพ่วงเดียวได้เลย
• เครื่องสี่การ์ดจอของผม พีคสุดที่ 1,600 วัตต์ ซึ่งเกินกว่าที่วงจรเดียวจะรับไหว และตก เดือนละประมาณ $300

ที่มาของตัวเลขเหล่านี้ แต่ละตัวเลขเป็นการวัดคนละรูปแบบ ผมเลยนำมาวางเทียบกันให้เห็นชัด ๆ ต้นทุนรายเดือนคำนวณจากการเปิดเครื่องกินไฟระดับนั้นตลอด 24 ชั่วโมง โดยคิดค่าไฟที่ 18 เซนต์ต่อ kWh:

ผลการทดสอบของผม

ทำไม Spark สี่เครื่องถึงกินไฟมากกว่า 90 W คูณสี่ ตัวเลข 90 W นั้นคือตอนที่ Spark เครื่องเดียวรันโมเดลด้วยตัวเอง แต่เมื่อโมเดลใหญ่หนึ่งตัวถูกแบ่งไปรันบนสี่เครื่อง ทุกเครื่องจะต้องทำงานในทุก ๆ คำที่สร้างขึ้น และต้องส่งข้อมูลผ่านเครือข่ายตลอดเวลา แต่ละเครื่องจึงกินไฟมากขึ้น เฉลี่ยประมาณ 125 W จากการวัดของผม ดังนั้น $12 และ $66 ต่อเดือนคือต้นทุนของการรันเต็มสปีดตลอด 24 ชั่วโมง การใช้งานจริงที่มีช่วงพักเครื่องจะเสียค่าไฟน้อยกว่านี้

ค่าไฟก็ไม่ได้ถูกลงด้วย ราคาไฟบ้านในสหรัฐฯ เพิ่มขึ้นประมาณ 5% ในปีนี้ มาอยู่ที่ราว 18 เซนต์ต่อ kWh ส่วนหนึ่งเป็นเพราะดาต้าเซ็นเตอร์เกิดใหม่เยอะมาก ในเดือนสิงหาคม ค่าไฟของผมเอง พุ่งขึ้นสองเท่าเป็นเดือนละ $1,000 จากการเปิดเครื่อง GPU rig, Spark สองเครื่อง และแอร์สี่ตัวพร้อมกัน

เสียงของ DGX Spark

แล้วเสียงล่ะ? เครื่อง GPU rig ของผมดังเหมือนเครื่องยนต์เจ็ต แต่นี่คือเสียงที่ดังที่สุดของ Spark สี่เครื่องของผม:

เกร็ดการใช้งานจริง:

• ใช้กับโมเดล AI ได้ทุกรูปแบบ ไม่ว่าจะเป็น world models, สร้างรูปภาพ ฯลฯ
• ตั้งตะแคงเครื่อง ของผมรันได้เย็นขึ้นเมื่อตั้งแบบนี้ เพราะมีพื้นที่รอบตะแกรงระบายอากาศมากขึ้น
• เข้าร่วมคอมมูนิตี้ discord/reddit/x เพื่อขอความช่วยเหลือเวลาเจอปัญหา
• ตั้งค่า tailscale ครอบคลุมทุกเครื่องที่คุณมี

หกโมเดลที่ผมใช้งานจริง

ผมลองมาหลายสิบตัว นี่คือหกตัวที่ผมกลับมาใช้ซ้ำตลอด

หนึ่ง token มีขนาดประมาณสามในสี่ของคำ และอะไรก็ตามที่เกิน 30 tok/s จะอ่านได้ลื่นไหลเหมือนคุยกับคนปกติ

ทำไมตัวเลขแต่ละตัวต้องระบุประเภทงานด้วย สูตรตั้งค่าส่วนใหญ่ใช้ speculative decoding ซึ่งมีโมเดลตัวเล็กคอยเดาคำล่วงหน้า โค้ดและ JSON นั้นเดาง่าย แต่ข้อความภาษาธรรมชาติเดายาก โมเดลเดียวกันบนเครื่องเดียวกันจึงอาจรันงานหนึ่งได้เร็วกว่าอีกงานถึงสองเท่า prompt ที่ยาวขึ้นก็ทำให้ช้าลงเช่นกัน ความเร็วแต่ละจุดที่ระบุไว้ตรงนี้จึงบอกด้วยว่ากำลังสร้างเนื้อหาแบบไหน และ prompt ยาวแค่ไหน:

วิธีวัดผลที่ถูกต้องครอบคลุมหลายงานคือ SPEED-Bench ของ NVIDIA ซึ่งจะทดสอบ speculative decoding ด้วย prompt จริงจาก 11 หมวดหมู่ และความยาว input ตั้งแต่ 1K ถึง 32K tokens ผมยังไม่ได้ลองรันบน Spark

• Spark หนึ่งเครื่อง: Qwen3.6-35B, Qwen3.8-Flash-Next, Qwen3.8-27B
• Spark สองเครื่อง: GLM-5.3-Flash
• Spark สี่เครื่อง: DeepSeek-V4.1-Flash

Qwen3.8-Flash-Next บน Spark สองเครื่อง กำลังสร้างแอนิเมชันและเกมเล็ก ๆ (21 กันยายน) โพสต์

หาดาวน์โหลดได้ที่ไหน โมเดลแต่ละตัวมีหน้าทางการของตัวเอง และในส่วนที่ 6 จะมีสูตรตั้งค่า Spark ที่ทดสอบแล้วให้ครบทุกตัว:

• Qwen3.6-35B หรือ เวอร์ชัน 4-bit ของ NVIDIA
• Qwen3.8-27B
• Qwen3.8-Flash-Next
• GLM-5.3-Flash หรือ เวอร์ชันสำหรับ Spark เครื่องเดียวของผม
• DeepSeek-V4.1-Flash
• GLM-5.3 หรือ เวอร์ชัน 3-bit ของผม

โมเดลใหญ่ยัดลงไปได้อย่างไร

คำตอบคือ quantization ครับ Quantization จะบีบอัด weight ของโมเดล ซึ่งเป็นกระบวนการที่สูญเสียข้อมูล (lossy): weight แต่ละตัวจะถูกเก็บด้วยจำนวน bit ที่น้อยลง (เช่น 4 แทนที่จะเป็น 16) ทำให้ขนาดโมเดลเล็กลงเหลือหนึ่งในสี่ แต่รายละเอียดบางส่วนจะหายไป เป้าหมายคือทำให้พฤติกรรมของโมเดลใกล้เคียงต้นฉบับมากที่สุดขณะที่ยังบีบอัด weight อยู่

ยิ่งบีบอัดมาก คุณภาพก็ยิ่งแย่ลง Turboderp เคยวัดผลเรื่องนี้ไว้กับ Qwen3.8-27B จุดแต่ละจุดคือเวอร์ชันที่ถูกบีบอัด ยิ่งไปทางซ้ายคือยิ่งเล็ก ยิ่งต่ำคือยิ่งใกล้เคียงต้นฉบับ:

Mean KL divergence เทียบกับขนาดไฟล์ของ Qwen3.6-35B-A3B เวอร์ชันบีบอัดจากผู้ให้บริการหลายราย แกนเป็น Log scale แผนภูมิจาก: https://huggingface.co/turboderp/Qwen3.8-27B-exl3

มีสองฟอร์แมตที่สำคัญบน Spark:

• NVFP4 คือฟอร์แมต 4-bit ของ NVIDIA ซึ่งชิปของ Spark อ่านได้โดยตรง Qwen3.6-35B จะลดจาก 72 GB เหลือ 24 GB และใส่ลงใน Spark เครื่องเดียวได้โดยยังมีที่เหลืออีก
• EXL3 ให้คุณเลือกได้เป๊ะ ๆ ว่าจะใช้กี่ bit GLM-5.3-Flash ที่ 4 bit มีขนาด 176 GB ใส่ลงใน Spark สองเครื่องได้พอดี ถ้าลดเหลือ 2 bit จะเหลือ 85 GB ใส่เครื่องเดียวได้ แต่ความคมชัดจะลดลงนิดหน่อย

เคล็ดลับ:

4 bit คือจุดที่ลงตัวที่สุดสำหรับโมเดลขนาดเล็ก ส่วนโมเดลขนาดใหญ่ควรใช้ 3 bit

จะรู้ได้อย่างไรว่าโมเดลที่ถูกบีบแล้วยังดีอยู่ model card ที่ดีจะรายงานไว้ว่าเวอร์ชันย่อส่วนยังคงความใกล้เคียงต้นฉบับแค่ไหน ตัวเลขที่ต้องมองหา:

• Top-1 agreement: ความถี่ที่โมเดลขนาดเล็กเลือกคำถัดไปได้ตรงกับต้นฉบับ ยิ่งสูงยิ่งดี GLM-5.3-Flash สำหรับ Spark เครื่องเดียวของผม ตรงกันประมาณ 80%
• KL divergence: ระดับที่การคาดเดาเบี่ยงเบนไปจากต้นฉบับ ยิ่งต่ำยิ่งดี GLM-5.3 แบบ unpruned ที่ 3 bit ของผม ได้คะแนน 0.089 ส่วน เวอร์ชัน pruned ขนาด 197 GB ได้ 0.511 นั่นคือราคาที่ต้องจ่ายเพื่อให้รันบน Spark น้อยเครื่องลงได้

6. จาก Spark เครื่องเดียวสู่สี่เครื่อง: คู่มือแบบทีละขั้น

นี่คือส่วนที่คนถามผมบ่อยที่สุด ค่อย ๆ ทำไปทีละขั้น แต่ละขั้นใช้งานได้สมบูรณ์ในตัวเอง ดังนั้นพอใจตรงไหนก็หยุดตรงนั้นได้เลย

สูตรตั้งค่าด้านล่างส่วนใหญ่มาจาก MiaAI Lab ที่รวบรวมการตั้งค่า Spark ดี ๆ มาใส่ไว้ใน repo ให้คุณ clone แล้วเริ่มใช้งานได้ด้วยสคริปต์เดียว บางอันก็เป็นของผมเอง ทุกสูตรจะระบุไว้ชัดเจนว่าทดสอบบนอะไรและวิ่งได้เร็วแค่ไหน

ทำสิ่งเหล่านี้ครั้งเดียว บน Spark ทุกเครื่อง:

1. อัปเดตเครื่อง รันอัปเดตใน DGX Dashboard แล้วรีสตาร์ท
2. เข้าถึงเครื่องจากแล็ปท็อปของคุณ ใช้ NVIDIA Sync หรือ SSH ธรรมดา ถ้าอยากเข้าถึงจากนอกบ้าน NVIDIA มี Tailscale playbook ให้ใช้
3. สมัครบัญชี Hugging Face และสร้าง token สูตรตั้งค่าส่วนใหญ่ใช้มันดาวน์โหลดโมเดล เก็บไว้ในไฟล์ .env ห้ามใส่ไว้ใน repo เด็ดขาด
4. เช็คพื้นที่ดิสก์ โมเดลมีขนาดใหญ่ สูตรสำหรับ Spark เครื่องเดียวต้องการพื้นที่ว่างประมาณ 25 ถึง 130 GB ส่วนสูตร DeepSeek สำหรับสี่เครื่องต้องการพื้นที่ประมาณ 476 GB บน Spark เครื่องแรก
5. Docker มีมาให้แล้ว DGX OS ติดตั้งมาให้พร้อมใช้งาน และสูตรตั้งค่าแทบทั้งหมดรันอยู่ในนั้น คุณจึงไม่ต้องมานั่งลง Python package เอง

ขั้นที่ 1: Spark เครื่องเดียว

เริ่มด้วย LM Studio ทำตาม คู่มือทีละขั้นของ NVIDIA ดาวน์โหลด Qwen3.6-35B แล้วเริ่มแชทได้เลย ใช้เวลาประมาณชั่วโมงนึง ขั้นตอนนี้จะช่วยยืนยันว่าเครื่องทำงานปกติก่อนที่คุณจะไปยุ่งกับอะไรที่ยากกว่านี้

จากนั้นขยับไปใช้สูตรตั้งค่า สูตรพวกนี้จะใช้ vLLM หรือ SGLang ซึ่งเร็วกว่า LM Studio และรองรับหลาย agent พร้อมกันได้ เลือกมาสักอัน:

1. Qwen3.6-35B (4-bit NVFP4) MiaAI Lab 95 tok/s สำหรับผู้ใช้คนเดียว รวม 317 สำหรับแปดคน ~50 GB
2. Qwen3.8-27B (4-bit NVFP4) MiaAI Lab ~51 tok/s สำหรับงานโค้ดเมื่อใช้ DSpark ช่วย ~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) ของผม หรือ เวอร์ชัน Spark เครื่องเดียวจากสูตรของ Mia 10 ถึง 25 tok/s, context 262K, รองรับ 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

พอมันรันขึ้นมา คุณจะได้ address สไตล์ OpenAI บน Spark เอาไปใส่ใน Pi, opencode, Open WebUI หรือเครื่องมืออะไรก็ตามที่คุณใช้ได้เลย

เคล็ดลับ:

ถ้าโมเดลไม่ยอมเริ่มทำงาน เกือบทุกครั้งเป็นเพราะหน่วยความจำเต็ม ปิดโมเดลอื่นก่อน Spark เครื่องเดียวรันโมเดลใหญ่ได้ทีละตัวเท่านั้น

ขั้นที่ 2: Spark สองเครื่อง

นี่คือการตั้งค่าที่ผมแนะนำมากที่สุด อย่างที่ผมเคยพูดไว้ตอนเดือนสิงหาคม: "มี DGX Spark 2 เครื่องก็จบแล้ว"

dgx spark 2 เครื่อง

สายเคเบิล คุณต้องใช้สาย QSFP เส้นสั้น ๆ หนึ่งเส้นเชื่อมระหว่างพอร์ต QSFP สองพอร์ต สายรุ่นไหนก็ได้ (คู่มือเลือกสาย):

• ของ NVIDIA เอง: สาย QSFP 0.4 m สำหรับ DGX Spark ราคา $99.99 มักจะหมดสต็อก
• รุ่นที่เอกสารของ NVIDIA แนะนำ: Amphenol NJAAKK-N911 หรือ Luxshare LMTQF022-SD-R ความยาว 0.5 m ราคาประมาณ $159 ถึง $187
• ตัวเลือก 200G ที่ถูกกว่า: NVIDIA MCP1650-V00AE30 ราคาประมาณ $84

ไม่ว่าคุณจะซื้อรุ่นไหน ลิงก์ก็จะวิ่งที่ 200 Gb/s เหมือนกัน อย่าใช้ USB-C หรือพอร์ต 10 GbE เด็ดขาด เพราะมันช้าเกินไปมาก

ตั้งค่าการเชื่อมต่อ ทำตาม playbook การเชื่อมต่อ Spark สองเครื่องของ NVIDIA มันจะกำหนด address ให้แต่ละพอร์ตและตรวจสอบความเร็ว จากนั้นตั้งค่า SSH แบบไม่ต้องใช้รหัสผ่านจาก Spark เครื่องแรก (เรียกว่า "head") ไปยังเครื่องที่สอง (เรียกว่า "worker") สูตรตั้งค่าแบบสองเครื่องทุกสูตรต้องใช้ขั้นตอนนี้

ผมแนะนำให้บอก claude หรือ gpt ให้ตั้งค่าส่วนนี้ให้คุณ จะง่ายกว่าเยอะ

เลือกสูตรตั้งค่า:

1. Qwen3.8-Flash-Next (4-bit NVFP4) MiaAI Lab 52.1 tok/s สำหรับผู้ใช้คนเดียวเมื่อใช้ MTP, context สูงสุด 1M
2. GLM-5.3-Flash (4-bit EXL3) MiaAI Lab 62.9 tok/s สำหรับผู้ใช้คนเดียว รวม 146.5 สำหรับสี่คน, context 850K
3. DeepSeek-V4.1-Flash (2.9-bit EXL3) MiaAI Lab 38.8 ถึง 43.0 tok/s สำหรับงานโค้ด, context 600K
4. GLM-5.3 (3-bit EXL3, pruned เหลือ 197 GB) model card ของผม ใส่ได้พอดี; ยังไม่ได้วัดความเร็ว

สูตรตั้งค่าแบบสองเครื่องส่วนใหญ่หน้าตาคล้ายกัน: คัดลอกตัวอย่างการตั้งค่า ใส่ address ของ Spark ทั้งสองเครื่อง ดาวน์โหลด แล้วเริ่มรัน นี่คือตัวอย่างของ GLM-5.3-Flash:

1cp .env.example .env     # ตั้งค่า HEAD_IP และ WORKER_IP
2./download.sh
3./start.sh

เตือนไว้ก่อน:

การเชื่อมต่อ Spark ทำได้จริง แต่นี่คือจุดที่ซอฟต์แวร์ยังไม่เนี้ยบที่สุด ควรทำตามสูตรที่ทดสอบมาแล้ว และเผื่อเวลาไว้สักบ่ายสำหรับครั้งแรก

ขั้นที่ 3: Spark สามเครื่อง

Spark สามเครื่อง ไม่ต้องใช้สวิตช์ แต่ละเครื่องมีพอร์ต QSFP สองพอร์ต คุณจึงต่อสายเป็นรูปสามเหลี่ยมได้เลย: A ไป B, B ไป C, C ไป A ใช้สายทั้งหมดสามเส้น NVIDIA รองรับรูปแบบนี้ในชื่อ switchless ring

Spark สามเครื่องจะให้หน่วยความจำประมาณ 384 GB ซึ่งเพียงพอสำหรับโมเดลที่สองเครื่องรับไม่ไหว:

• DeepSeek-V4.1-Flash ที่ความละเอียดดั้งเดิม สูตรของ MiaAI Lab รันบนสามเครื่องแบบสามเหลี่ยมได้ 51.0 tok/s สำหรับผู้ใช้คนเดียว พร้อม context 256K มันมีคำสั่ง doctor ที่ช่วยเช็ค SSH, Docker และลิงก์เครือข่ายให้คุณก่อนเริ่มรัน
• GLM-5.3-Flash ที่มีพื้นที่เหลือเฟือขึ้น สูตร EXL3 แบบสองเครื่อง มีไฟล์ start-tp3.sh สำหรับสามเครื่องเตรียมไว้ให้
• GLM-5.3 แบบ unpruned เวอร์ชัน 293 GB ของผม ต้องการหน่วยความจำประมาณเท่ากับ Spark สามเครื่องพอดี

สูตร DeepSeek เป็นตัวอย่างที่ดีว่าโมเดลใหญ่ทำงานอย่างไร มันมีหลายขั้นตอน ไม่ใช่สั่งทีเดียวจบ:

1./start.sh doctor    # ตรวจสอบ ssh, docker, ลิงก์เครือข่าย, ดิสก์
2./start.sh share     # แชร์โฟลเดอร์โมเดลให้กับ Spark เครื่องอื่น
3./start.sh serve     # เริ่ม worker ก่อน แล้วค่อยเริ่ม head

เคล็ดลับ:

บางโมเดลแบ่งได้ลงตัวเฉพาะ 2 หรือ 4 เครื่องเท่านั้น เช็คให้ชัวร์ว่าสูตรนั้นระบุว่า "3x" ได้ก่อนตัดสินใจซื้อเครื่องที่สาม

ขั้นที่ 4: Spark สี่เครื่อง

Spark สี่เครื่องจะให้หน่วยความจำประมาณ 512 GB มีวิธีเชื่อมต่อสองแบบ

ทางเลือก A: ใช้สวิตช์ (แบบที่ผมใช้) Spark ทุกเครื่องต่อสายหนึ่งเส้นเข้ากับสวิตช์ 200 GbE ทำให้แต่ละเครื่องห่างกันแค่ hop เดียว NVIDIA มี playbook สำหรับวิธีนี้ สวิตช์ที่คนนิยมใช้:

• MikroTik CRS812-8DS-2DQ-2DDQ-RM. พอร์ต 400G แต่ละพอร์ตแยกออกเป็นลิงก์ 200G ได้สองลิงก์
• MikroTik CRS804-4DDQ-hRM ตัวเลือกที่เล็กกว่า (บันทึกการประกอบแบบสี่เครื่อง
• Exxact มี รายการของที่จำเป็นสำหรับคลัสเตอร์สี่เครื่อง ที่ดีมาก: สวิตช์ สายเคเบิล และระบบไฟ

อย่างที่ผมพูดไว้ตอนเดือนกันยายน: "ผมคิดว่าในตลาดนี้ไม่มีดีลไหนคุ้มไปกว่า Spark 4 เครื่องคู่กับสวิตช์ microtik อีกแล้ว"

ทางเลือก B: ไม่ใช้สวิตช์ ต่อสายสี่เครื่องเป็นวงแหวน โดยแต่ละเครื่องต่อสายเข้ากับเครื่องข้างเคียงสองเครื่อง เครื่องที่ไม่ได้อยู่ติดกันจะคุยกันผ่านเครื่องที่อยู่ตรงกลาง วิธีนี้ประหยัดค่าสวิตช์ แต่ตั้งค่าได้ยากกว่า:

• SparkRing คือซอฟต์แวร์สแต็กแบบครบวงจรสำหรับการทำงานแบบ switchless pairs และวงแหวน Spark 4 ตัว (four-Spark rings) เนื่องจากยังเป็นเวอร์ชันอัลฟ่า จึงควรล็อกเวอร์ชันไว้ใช้งาน
• รีซีปี GLM-5.3-Flash นี้ รันบนวงแหวน Spark 4 ตัว โดยใช้สายเคเบิล 100G สั้นๆ 4 เส้นร่วมกับ NCCL ที่แพตช์แล้ว ความเร็วทั่วไปอยู่ที่ประมาณ 45 tok/s และอาจพุ่งถึงราว 100 tok/s เมื่อเครื่องวอร์มจนพร้อม

เลือกรีซีปีที่ต้องการ:

• DeepSeek-V4.1-Flash (เนทีฟ) MiaAI Lab, start-tp4.sh 45.4 tok/s สำหรับผู้ใช้ 1 คน รวม 134.2 tok/s สำหรับ 16 คน รองรับคอนเทกซ์ 1M
• GLM-5.3-Flash (4-bit NVFP4) switchless ring ทั่วไป ~45 tok/s, วอร์มแล้ว ~100 tok/s

รอบการรันที่ดีที่สุดของผมเองบน Spark 4 ตัวคือ 118 tok/s สำหรับ GLM-5.3-Flash เมื่อใช้ DFlash2 เป็นผู้ช่วย และ 83.8 ถึง 95.3 tok/s สำหรับ DeepSeek-V4.1-Flash กับพรอมต์สั้นๆ (โพสต์

เครื่องมือที่ช่วยได้ในทุกขั้นตอน

• \\sparkDash:\\ เว็บแดชบอร์ดที่รวมข้อมูลของ Spark ทุกตัวไว้ในหน้าต่างเดียว ดู GPU, หน่วยความจำ, เครือข่าย และจำนวนโทเค็นต่อวินาทีแบบเรียลไทม์ได้ ความเร็วหลายค่าในคู่มือนี้วัดด้วยเครื่องมือนี้
• \\Spark playbooks ของ NVIDIA:\\ คู่มืออย่างเป็นทางการสำหรับ LM Studio, Ollama, vLLM, การเชื่อมต่อ Spark เข้าด้วยกัน และอื่นๆ
• \\local-ai-registry:\\ รีซีปีของผมและผลการทดสอบความเร็วทั้งหมดที่ผมเคยทำมา
• \\b12x:\\ ระบบคำนวณเบื้องหลังที่ทำให้รีซีปี Spark หลายตัวทำงานได้รวดเร็ว คุณไม่ต้องติดตั้งเอง เพราะรีซีปีจะจัดการให้ ดูรายละเอียดเพิ่มเติมในหัวข้อขั้นสูงด้านล่าง

บทสรุป

Spark คือกล่องเก็บหน่วยความจำ มันบรรจุโมเดลขนาดใหญ่ รันอย่างเงียบๆ ด้วยไฟบ้าน และยิ่งเพิ่มจำนวนเครื่องก็ยิ่งทำงานได้ดีขึ้นเรื่อยๆ

หากคุณเพิ่งเริ่มต้นวันนี้:

1. ซื้อหนึ่งเครื่อง แล้วลองรัน Qwen3.6-35B จาก LM Studio ตั้งแต่วันแรก
2. เปลี่ยนมาใช้รีซีปี เมื่อคุณต้องการความเร็วที่สูงขึ้น หรือต้องรันเอเจนต์หลายตัว
3. ซื้อ Spark เครื่องที่สองพร้อมสายเคเบิล เมื่อคุณอยากใช้ GLM-5.3-Flash หรือ DeepSeek-V4.1-Flash สำหรับคนส่วนใหญ่ แค่จุดนี้ก็เพียงพอแล้ว
4. ขยับไปใช้สามหรือสี่เครื่อง เฉพาะเมื่อคุณต้องการโมเดลที่ใหญ่ที่สุด หรือต้องการรันหลายโมเดลพร้อมกันเท่านั้น

ถ้าถามว่าจะซื้ออีกไหม? ซื้อแน่นอน และถ้าเริ่มใหม่ได้ ผมจะซื้อสองเครื่องตั้งแต่วันแรกเลย

ขั้นสูง: การเชื่อมต่อ Spark ช่วยเพิ่มประสิทธิภาพได้อย่างไร

คุณไม่จำเป็นต้องรู้เรื่องนี้เพื่อใช้งาน Spark แต่มีไว้สำหรับคนที่อยากรู้ว่าทำไมตัวเลขผลลัพธ์ถึงออกมาเป็นแบบนี้

เกือบเป็นเส้นตรงสำหรับการเขียน

ทุกคำที่โมเดลเขียนขึ้นมา หมายถึงการอ่าน active weights ของโมเดลจากหน่วยความจำ หากแบ่งโมเดลกระจายไปยัง Spark หลายตัว แต่ละตัวก็จะอ่านส่วนของตัวเองพร้อมกัน ทำให้ความเร็วในการอ่านรวมกันเพิ่มขึ้น

NVIDIA ได้ทำการวัดผลเรื่องนี้ไว้แล้ว เมื่อเพิ่มจาก 1 เป็น 2 และ 4 ตัว เวลาที่ใช้เขียนแต่ละคำลดลงจาก 269 ms เหลือ 133 ms และ 72 ms ตามลำดับ นั่นคือเร็วขึ้น 2.0 เท่าเมื่อใช้ 2 ตัว และ 3.7 เท่าเมื่อใช้ 4 ตัว (บล็อกของ NVIDIA, ตารางที่ 3

ที่ทำได้ใกล้เคียงขนาดนั้นเพราะลิงก์ ConnectX-7 มี latency ต่ำมาก และการแลกเปลี่ยนข้อมูลระหว่าง Spark สามารถเกิดขึ้นภายในโค้ดของ GPU ได้เลย คำอธิบายสำหรับ Mac นี้ อธิบายแนวคิดเดียวกันไว้อย่างละเอียดมากขึ้น

หลังจากจบแต่ละเลเยอร์ Spark จะแลกเปลี่ยนผลลัพธ์บางส่วน (partial results) ก่อนที่จะเริ่มเลเยอร์ถัดไปได้ ข้อมูลที่แลกกันนั้นมีขนาดเล็ก แต่เกิดขึ้นในทุกเลเยอร์และทุกคำ ซึ่งแต่ละครั้งจะกินเวลาเล็กน้อยที่ไม่ได้ลดลงตามจำนวน Spark ที่เพิ่มเข้ามา

• ลิงก์มีความเร็ว 200 Gb/s หรือประมาณ 25 GB/s คิดเป็นหนึ่งในสิบของความเร็วหน่วยความจำในตัว Spark เอง ซึ่งถือว่าไม่มีปัญหาเพราะข้อมูลที่แลกกันมีขนาดเล็ก
• ใช้ RDMA ข้อมูลจะถูกส่งตรงจากหน่วยความจำของ Spark ตัวหนึ่งไปยังอีกตัว โดย CPU ไม่ต้องคัดลอกให้ พอร์ต QSFP แต่ละพอร์ตจะแสดงเป็นสองส่วน ส่วนละ 100 Gb/s และซอฟต์แวร์ต้องใช้ทั้งสองส่วนจึงจะได้ความเร็วเต็ม 200 (รายละเอียด) โดยมี NCCL ซึ่งเป็นไลบรารีของ NVIDIA สำหรับงานนี้คอยจัดการให้
• การอ่านขยายประสิทธิภาพได้ไม่ดีเท่าการเขียน ในการทดสอบเดียวกันของ NVIDIA การอ่านพรอมต์ขนาด 32K โทเค็น เร็วขึ้น 1.6 เท่าเมื่อใช้ Spark 2 ตัว และ 2.1 เท่าเมื่อใช้ 4 ตัว เพราะการอ่านต้องย้ายข้อมูลระหว่าง Spark มากกว่าในแต่ละขั้นตอน
• การจัดแบบวงแหวน (Rings) เพิ่มจำนวนฮอป ในรูปแบบสามเหลี่ยมที่ใช้ Spark 3 ตัว ทุกตัวจะต่อสายถึงกันหมด แต่ในวงแหวน 4 ตัว บางคู่ต้องสื่อสารผ่านตัวกลางที่อยู่ติดกัน การใช้สวิตช์จะทำให้ทุกตัวห่างกันแค่ฮอปเดียว SparkRing เขียนโค้ดแลกเปลี่ยนข้อมูลของตัวเอง (SIRCL) เพื่อให้วงแหวนทำงานได้เร็วขึ้น
• โมเดลแบบ Mixture-of-experts มีการแบ่งส่วนที่สองเพิ่มเข้ามา รีซีปีต่างๆ มักผสมผสาน tensor parallel เข้ากับ "expert parallel" ซึ่ง Spark แต่ละตัวจะเก็บ expert ที่แตกต่างกันไว้

อีกสองวิธีในการเร่งความเร็ว

• รองรับผู้ใช้หลายคนพร้อมกัน Spark จะอ่านโมเดลเพียงครั้งเดียวต่อหนึ่งขั้นตอน แล้วตอบทุกคนจากการอ่านครั้งนั้น ดังนั้นความเร็วรวมจึงเพิ่มขึ้นเร็วกว่าความเร็วของผู้ใช้คนเดียวมาก
• ใช้โมเดล speculative decoder ที่เดาคำล่วงหน้า ทั้ง MTP, DSpark และ DFlash2 ทำงานด้วยหลักการนี้ โมเดลผู้ช่วยขนาดเล็กและรวดเร็วจะร่างคำมาหลายคำ แล้วให้โมเดลใหญ่ตรวจสอบทั้งหมดในการอ่านครั้งเดียว ถ้าเดาถูก คุณจะได้หลายคำในราคาของการประมวลผลเพียงคำเดียว นี่คือวิธีที่ GLM-5.3-Flash กระโดดจาก 27 tok/s ในงานเขียนข้อความทั่วไป ไปเป็น 65 tok/s ใน structured output ภายใต้รีซีปีเดียวกัน

Qwen3.6-35B-A3B แบบ 4 บิต บน Spark 1 ตัว พร้อมเปิดใช้งานตัวช่วยเร่งความเร็ว ที่มา: ผลทดสอบความเร็วจาก local-ai-registry, สิงหาคม 2026

Cloud AI และ Local AI นั้นต่างกัน

GPU บนคลาวด์เร็วกว่า Spark มาก แต่ผู้ให้บริการคลาวด์จะแชร์ GPU แต่ละตัวให้ผู้ใช้หลายคน และเลือกจุดสมดุลระหว่างการลดต้นทุนต่อโทเค็นกับการเพิ่มความเร็วต่อผู้ใช้ ซึ่งส่วนใหญ่เลือกเน้นเรื่องต้นทุน ทำให้ผู้ใช้แต่ละคนได้โทเค็นต่อวินาทีน้อยกว่าที่ฮาร์ดแวร์จะมอบให้คนๆ เดียวได้ InferenceX ได้ทำแผนภูมิแสดงจุดสมดุลนี้ไว้สำหรับ Qwen3.8-Flash-Next

แต่เมื่อใช้งานที่บ้าน ข้อจำกัดเรื่องการแบ่งปันนี้ไม่มีอยู่จริง กล่องนี้เป็นของคุณ ดังนั้นคุณจะทุ่มทรัพยากรทั้งหมดให้คนๆ เดียวก็ได้ นี่คือเหตุผลที่ Spark ให้ความรู้สึกเร็วเทียบเท่าบริการคลาวด์ แม้ฮาร์ดแวร์จะไม่แรงเท่าก็ตาม

sm_121: ทำไมซอฟต์แวร์ของ Spark ถึงเป็นโลกของมันเอง

GPU ของ NVIDIA ทุกตัวจะมีหมายเลข "compute capability" เพื่อบอกซอฟต์แวร์ว่ามีชุดคำสั่งใดบ้าง GPU ของ Spark คือ 12.1 หรือ sm_121 (รีวิวแรกโดย Simon Willison) ส่วน RTX 5090 และ RTX PRO 6000 เป็น sm_120 ซึ่งถือเป็นญาติสนิท ขณะที่ชิประดับดาต้าเซ็นเตอร์ของ NVIDIA อย่าง B200 และ B300 เป็น sm_100 และ sm_103 ซึ่งจัดอยู่ในตระกูลที่ต่างออกไป

เรื่องนี้สำคัญเพราะโค้ด AI ที่เร็วที่สุดจะถูกเขียนขึ้นมารองรับทีละตระกูล ตอนที่ Spark เปิดตัวใหม่ๆ โค้ดจำนวนมากจึงรันไม่ได้หรือรันได้ช้า (ฟอรัม NVIDIA, issue ของ vLLM

ทางออกคือการที่มีคนหันมาเขียนโค้ดเฉพาะสำหรับ Spark:

• b12x จาก Local Inference Lab คือ kernel library สำหรับ sm_120 และ sm_121 ได้แก่ DGX Spark, RTX Spark, RTX 5090 และ RTX PRO 6000 รองรับคณิตศาสตร์เมทริกซ์แบบ 4 บิต (NVFP4, MXFP4), attention สำหรับโมเดลสไตล์ DeepSeek, เลเยอร์แบบ mixture-of-experts และตัวโหลดโมเดลที่รวดเร็ว ติดตั้งได้ด้วยคำสั่ง pip install b12x และรีซีปีของ vLLM จะเปิดใช้งานผ่านแฟล็กอย่าง flashinfer_b12x โดยรีซีปี Qwen3.6-35B ก็ใช้ไลบรารีนี้เช่นกัน
• SparkInfer คือชื่อเดิมของ b12x ลิงก์เก่าตอนนี้รีไดเรกต์ไปที่ b12x แล้ว รีซีปี DeepSeek แบบใช้ Spark ตัวเดียวของผม ใช้โค้ด attention ของมันทั้งในการอ่านและเขียน อย่าสับสนกับ gittensor's sparkinfer ซึ่งเป็นรันไทม์แยกต่างหากสำหรับการ์ด RTX (รองรับเฉพาะ sm_120)
• ExLlamaV3 คือสิ่งที่ใช้รันโมเดล EXL3 ทาง MiaAI Lab ดูแลฟอร์กนี้ไว้ ซึ่งมีการพอร์ต Arm (GB10) และรองรับ helper-model
• lil คือ launcher ของ Local Inference Lab ซึ่งจะอ่านเลย์เอาต์ของเครื่องแล้วสร้างคำสั่ง vLLM ที่เหมาะสมสำหรับ Spark ตัวเดียวหรือกลุ่มที่เชื่อมต่อกัน

ขั้นสูง: Spark ในฐานะเครื่องมือวิจัย

นี่คือส่วนที่ผมคาดไม่ถึงเลย Spark อาจเขียนได้ช้า แต่กลับอ่านได้เก่งมาก และงานวิจัยเกี่ยวกับโมเดลส่วนใหญ่ก็คือการอ่านนั่นเอง

สิ่งที่ Spark ทำได้ดีที่สุด: prefill

โมเดลมีหน้าที่หลัก 2 อย่าง:

• Prefill คือการอ่านพรอมต์ของคุณ พรอมต์ทั้งหมดจะถูกประมวลผลรวดเดียว ขีดจำกัดจึงอยู่ที่พลังการคำนวณดิบๆ ซึ่ง GB10 มีเหลือเฟือ: สูงสุดถึง 1 petaflop สำหรับคณิตศาสตร์ 4 บิต
• Decode คือการเขียนคำตอบทีละคำ แต่ละคำหมายถึงการดึงโมเดลจากหน่วยความจำมาอ่านใหม่อีกครั้ง ขีดจำกัดจึงอยู่ที่ความเร็วของหน่วยความจำ ซึ่งนี่คือจุดอ่อนของ Spark

ดังนั้น Spark จึงอ่านพรอมต์ได้เร็วกว่าการเขียนถึง 13 ถึง 41 เท่า:

DeepSeek-V4.1-Flash บน Spark 4 ตัว: อ่านพรอมต์ 32K โทเค็นได้ 3,360 tok/s, ที่ 131K ได้ 3,273 tok/s ในขณะที่การเขียนยังคงอยู่ที่ราว 70 ถึง 95 (20 กันยายน) โพสต์

ทำไมสิ่งนี้จึงตอบโจทย์งานวิจัย

แทบทุกอย่างที่ผมทำเพื่อย่อขนาดโมเดลคือการอ่าน ไม่ใช่การเขียน:

• Quantisation (ลดจำนวนบิต) การบิลด์ EXL3 และ NVFP4 เกิดจากการป้อนข้อความตัวอย่างผ่านโมเดล แล้ววัดว่าแต่ละเลเยอร์สูญเสียข้อมูลไปเท่าไรในแต่ละ bit width นั่นคือการอ่าน
• Pruning (ลดจำนวน experts) REAP ป้อนข้อความตัวอย่างผ่านโมเดลแบบ mixture-of-experts แล้วบันทึกว่า expert แต่ละตัวถูกใช้งานมากน้อยแค่ไหน expert ที่มีประโยชน์น้อยที่สุดจะถูกตัดทิ้ง GLM-5.3 ขนาด 197 GB ของผม เก็บไว้ 168 จาก 256 experts นี่ก็เป็นการอ่านเช่นกัน
• การตรวจสอบคุณภาพ ค่า Top-1 agreement และ KL divergence มาจากการอ่านข้อความชุดเดียวกันผ่านโมเดลดั้งเดิมและโมเดลย่อส่วน แล้วนำผลลัพธ์มาเปรียบเทียบกัน ก็คือการอ่านอีกครั้ง
• การทดสอบ Long-context การเช็คว่าโมเดลสามารถค้นหาข้อเท็จจริง 1 อย่างใน 262,000 โทเค็นได้หรือไม่ ส่วนใหญ่ก็คือการอ่านที่ยาวมากๆ เพียงครั้งเดียว

เวิร์กโฟลว์ของผมเองก็ปรับเปลี่ยนมาด้วยเหตุผลนี้โดยตรง ["ตอนนี้ผมรันงาน pruning/exl3/benchmarking ทั้งหมดบน DGX Sparks แล้ว เก็บ 6000s ไว้ใช้ inference แทน ช้ากว่าก็จริง แต่ 2-3 วันเทียบกับ 12 ชั่วโมงถือว่ารับได้"] (https://x.com/0xSero/status/2102433323536527698 โมเดล DeepSeek แบบใช้ Spark ตัวเดียวที่ยอดดาวน์โหลดทะลุ 100,000 ครั้ง ก็คือโมเดลที่ถูก prune ด้วย REAP และบีบอัดด้วย EXL3

สิ่งนี้เชื่อมโยงกับเป้าหมายด้านการวิจัยอย่างไร

หากเป้าหมายของคุณคือการทำความเข้าใจบางอย่างเกี่ยวกับโมเดล Spark ถือว่าตอบโจทย์ได้ดี:

• มันจุโมเดลใหญ่ได้ คุณสามารถวัดผลโมเดล 300B บนเครื่องเพียงหนึ่งหรือสองตัว แทนที่จะต้องเช่าคลัสเตอร์
• รันต่อเนื่องได้หลายวันด้วยไฟบ้าน งาน calibration และ evaluation ที่ใช้เวลานานสามารถปล่อยรันทิ้งไว้ได้เลยโดยไม่ต้องกังวลเรื่องค่าไฟบานปลาย
• ปลดปล่อยฮาร์ดแวร์ตัวแรงของคุณ GPU ของผมเอาไว้เสิร์ฟโมเดล ในขณะที่ Spark รับหน้าที่งานที่ต้องใช้เวลาและความละเอียดรอบคอบ
• คุณสามารถ calibrate ด้วยข้อมูลของตัวเองได้ ผมเคย prune โมเดลด้วยเซสชันการใช้งานเอเจนต์และงานเขียนของผมเอง ซึ่งเป็นข้อมูลส่วนตัวและเก็บอยู่บนโต๊ะทำงานของผมตลอด
• เป็นโฮสต์ที่ดีสำหรับ research agents ผมเคยให้เอเจนต์ 4 ตัวทำงานวิจัยพร้อมกันบน Spark โดยแต่ละตัวทำความเร็วได้ราว 120 tok/s
• การเทรนขยายประสิทธิภาพข้าม Spark ได้ดี ในการทดสอบของ NVIDIA การ fine-tuning เร็วขึ้น 2 เท่าบน Spark 2 ตัว และ 4 เท่าบน 4 ตัว เพราะ Spark ซิงค์ข้อมูลกันเพียงครั้งเดียวต่อหนึ่งขั้นตอน (ตารางที่ 5Playbooks ของ NVIDIA มีครอบคลุมถึงการ fine-tuning ด้วย PyTorch ส่วนตัวผมยังไม่ได้จับเวลาการเทรนด้วยตัวเอง

ขั้นสูง: GB10, GB300 และ Spark ในฐานะหน่วยความจำเสริม

"GB" ย่อมาจาก Grace Blackwell: สถาปัตยกรรมที่รวม Arm CPU และ Blackwell GPU ไว้ในแพ็กเกจเดียวกัน แชร์หน่วยความจำผ่านลิงก์ความเร็วสูงที่เรียกว่า NVLink-C2C โดย GB10 ใน Spark คือเวอร์ชันที่เล็กที่สุดของแนวคิดนี้ มาพร้อม Arm CPU 20 คอร์ที่พัฒนาร่วมกับ MediaTek

ส่วน GB300 คือเวอร์ชันสำหรับดาต้าเซ็นเตอร์: Grace CPU จับคู่กับ GPU รุ่น Blackwell Ultra (B300) ถูกติดตั้งในแร็ค GB300 NVL72 ของ NVIDIA และ GB300 เพียงตัวเดียวก็ขับเคลื่อน DGX Station ได้ทั้งเครื่อง GB10 ไม่ใช่ชิ้นส่วนที่ตัดมาจาก GB300 แต่มันคือการออกแบบเดียวกันที่ย่อขนาดลงมา นั่นจึงเป็นเหตุผลที่ซอฟต์แวร์เดียวกันรันได้บนทั้งสองรุ่น

บทสรุป

DGX Spark ได้สร้างพื้นที่ของตัวเองในบ้านของผมเรียบร้อยแล้ว และกำลังเติบโตขึ้นทุกวันทั้งในด้านซัพพอร์ต ประโยชน์การใช้งาน และขีดความสามารถ

แหล่งข้อมูลและเนื้อหาอ่านเพิ่มเติม

• โพสต์ของผม: ทุกอย่างที่ระบุวันที่ไว้ด้านบนอยู่ใน โปรไฟล์ X ของผม ตัวเลขความเร็วมาจากการทดสอบของผมเอง ซึ่งเผยแพร่ไว้ใน local-ai-registry
• รีซีปี: MiaAI Lab บน GitHub, โมเดล Hugging Face ของผม
• ฮาร์ดแวร์และราคา: หน้า DGX Spark ของ NVIDIA, เอกสารฮาร์ดแวร์ของ NVIDIA, VideoCardz เรื่องการปรับขึ้นราคา, VideoCardz เรื่องราคาในเดือนกันยายน, pi3g price tracker
• การเชื่อมต่อ Spark: เอกสาร clustering ของ NVIDIA, บล็อก scaling ของ NVIDIA, switch playbook, คู่มือสายเคเบิล, คู่มือ benchmarking สำหรับ Spark 2 ตัวของ NVIDIA
• พลังงาน: รีวิวจาก ServeTheHome, Tom's Hardware เรื่องการใช้ไฟตอน idle, ราคาค่าไฟฟ้าในสหรัฐฯ (EIA ผ่าน Utility Dive), มาตรฐานระบบไฟฟ้าของสหรัฐฯ เรื่อง continuous loads
• ฟอร์แมตและซอฟต์แวร์: NVIDIA เรื่อง NVFP4, ExLlamaV3, b12x, REAP, compute capabilities
• ความเร็วบนคลาวด์: InferenceX โดย SemiAnalysis
• GB300: สเปก GB300 NVL72, สเปก DGX Station, EXO เรื่อง Spark ร่วมกับ Mac Studio
• เริ่มต้นใช้งาน: Spark playbooks ของ NVIDIA
• ภาพรวมทั้งหมด: State of Local AI: 2026