การติดตั้ง Qwen3.8-27B ตั้งแต่เริ่มต้น: คู่มือการใช้งานบน Mac และการปรับแต่งประสิทธิภาพ

Qwen3.8-27B มาแล้ว

Mac ทั่วไปมีโอกาสได้ใช้งานมัน

หน่วยความจำ ความเร็ว บริบท—

คู่มือนี้จะอธิบายทั้งหมดในครั้งเดียว

ข่าวสองชิ้นเพิ่งชนกัน

เมื่อวันที่ 14 สิงหาคม Qwen3.8-27B เปิดเผยน้ำหนักอย่างเป็นทางการ หลังจากนั้นไม่ถึงสองสัปดาห์ Apple ก็เปิดตัว Mac Studio ใหม่ที่มาพร้อมกับ M5 Max และ M5 Ultra โดยเน้นประสิทธิภาพ AI ในเครื่องและหน่วยความจำแบบรวมสูงสุด 512GB

หลังจากอ่านข้อมูลเหล่านี้แล้ว มันง่ายที่จะเกิดภาพลวงตา: การจะรัน Qwen3.8-27B บน Mac คุณต้องซื้อ Mac Studio รุ่นล่าสุด หรือแม้แต่ตรงไปที่ Ultra เลยหรือ?

จริงๆ แล้ว มันไม่ได้เกินจริงขนาดนั้น

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

ในทางตรงกันข้าม โมเดล MoE เช่น 35B-A3B แม้จะมีพารามิเตอร์รวมมากกว่า แต่จะเปิดใช้งานเพียงประมาณ 3B พารามิเตอร์ต่อการสร้างหนึ่งครั้ง ทำให้อาจเร็วกว่าหลายเท่า สำหรับ Agent ที่ต้องอ่านโค้ด เรียกใช้เครื่องมือ และแก้ไขไฟล์ซ้ำๆ อย่างต่อเนื่อง ไม่ว่าโมเดลจะมีความสามารถแค่ไหน ถ้าทุกรอบใช้เวลานาน ก็ยากที่จะเป็นเครื่องมือประจำวัน ดังนั้น ผู้เล่นในเครื่องหลายคนก่อนหน้านี้จึงให้ความสำคัญกับ MoE

ตอนนี้สถานการณ์เริ่มเปลี่ยนไปแล้ว

รูปแบบการควอนไทซ์ เฟรมเวิร์กการอนุมานของ Apple Silicon และวิธีการเร่งความเร็วการถอดรหัสรุ่นใหม่กำลังค่อยๆ เติบโตเต็มที่ ทำให้โมเดล Dense ขนาด 27B มีโอกาสครั้งแรกที่จะสร้างสมดุลระหว่างความสามารถและความเร็ว คุณไม่จำเป็นต้องมี Ultra รุ่นล่าสุด: Mac ขนาด 24GB และ 32GB สามารถเริ่มต้นด้วยเวอร์ชัน 4-bit ในขณะที่ผู้ที่มี 48GB หรือมากกว่ามีตัวเลือกที่ยืดหยุ่นกว่า

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

บทความนี้จะทำการปรับใช้ที่สามารถทำซ้ำได้ตั้งแต่เริ่มต้น: ขั้นแรกคำนวณความต้องการหน่วยความจำ จากนั้นรันความเร็วพื้นฐานโดยไม่มีการเร่งความเร็ว สุดท้ายทำการทดสอบ A/B ด้วยงานเดียวกัน และเปิดตัวโมเดลเป็น API ในเครื่องที่ไคลเอนต์ OpenAI และ Anthropic สามารถเรียกใช้ได้

หากคุณไม่ได้วางแผนจะปรับใช้ตอนนี้ ฉันแนะนำให้บุ๊กมาร์กไว้ก่อน เมื่อคุณอัปเกรดเป็น Mac ที่มีหน่วยความจำมากขึ้นในภายหลัง หรือเตรียมเชื่อมต่อโมเดลในเครื่องเข้ากับโค้ด Agent ฐานความรู้ และเวิร์กโฟลว์อัตโนมัติ เพียงทำตามคู่มือนี้

สรุปก่อน: Mac ของคุณรันได้ไหม?

ดูเฉพาะหน่วยความจำแบบรวม คุณสามารถใช้ตารางนี้เพื่อตัดสินใจ:

ตารางนี้ไม่ใช่ขอบเขตที่แน่นอนของ "โมเดลสามารถเปิดใช้งานได้" แต่เป็นคำแนะนำสำหรับ "สามารถทำงานได้อย่างเสถียร"

Mac ขนาด 24GB บางรุ่นสามารถโหลด 4-bit ได้จริง แต่การโหลดสำเร็จไม่ได้หมายความว่าเหมาะสำหรับการใช้งานระยะยาว macOS เบราว์เซอร์ เครื่องมือพัฒนา บัฟเฟอร์การรันโมเดล แคชบริบท และโมเดลร่าง DFlash 2 ทั้งหมดแข่งขันกันเพื่อหน่วยความจำแบบรวมเดียวกัน โมเดลอาจดูปกติดีเมื่อเริ่มต้น แต่ความล้มเหลวที่พบบ่อยที่สุดเกิดขึ้นเมื่อมันเริ่มสว็อปหลังจากป้อนโค้ดยาวๆ

นอกจากนี้ บทช่วยสอนนี้ใช้ได้กับ Apple Silicon เท่านั้น ซึ่งรวมถึง Mac ซีรีส์ M1, M2, M3, M4 และ M5 Mac ที่ใช้ Intel ไม่เป็นไปตามเส้นทาง 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 ไม่ใช่โมเดล "attention เต็มรูปแบบในทุกเลเยอร์" แบบดั้งเดิม การ์ดโมเดลอย่างเป็นทางการ แสดงว่าประกอบด้วย 64 เลเยอร์ โดยใช้สถาปัตยกรรมแบบไฮบริดของ Gated DeltaNet และ Gated Attention: ประมาณทุกๆ 3 เลเยอร์ของ linear attention จะสลับกับ 1 เลเยอร์ของ standard attention รองรับบริบท 262,144 โทเค็นโดยกำเนิด มีความสามารถในการเข้าใจภาพและวิดีโอ มีโหมดการคิดเปิดใช้งานโดยค่าเริ่มต้น และอนุญาตให้ปรับความลึกของการใช้เหตุผลผ่าน reasoning_effort

ความสามารถเหล่านี้อธิบายว่าทำไมมันถึงเหมาะสำหรับโค้ด งานวิจัย งานยาว และ Agent; พวกมันยังอธิบายว่าทำไมคุณไม่สามารถดูแค่ "27B" เมื่อปรับใช้

ความสามารถของมันอยู่ในระดับไหน?

หากเราจัดหมวดหมู่โมเดลในเครื่องบนคอมพิวเตอร์ส่วนบุคคลอย่างคร่าวๆ:

• 3B–8B: เริ่มต้นเร็ว ใช้พื้นที่น้อย เหมาะสำหรับ Q&A ทั่วไป การแยกข้อมูลอย่างง่าย และการเรียกใช้เครื่องมือแบบเบา; งานที่ซับซ้อนมีแนวโน้มที่จะหลุดประเด็น
• 14B–30B: ปัจจุบันเป็นช่วงคุณภาพสูงที่ใช้งานได้จริงที่สุด เริ่มจัดการกับการสร้างโค้ด การประมวลผลข้อความยาว การวิเคราะห์เชิงโครงสร้าง และงาน Agent ได้อย่างน่าเชื่อถือ
• 70B ขึ้นไป Dense: ความเสถียรโดยรวมมักจะแข็งแกร่งกว่า แต่ความต้องการความจุหน่วยความจำและแบนด์วิธเพิ่มขึ้นอย่างมาก และต้นทุนการปรับใช้ส่วนบุคคลสูงกว่ามาก

Qwen3.8-27B อยู่ในตำแหน่งที่ "อุปกรณ์ส่วนตัวสามารถปรับใช้ได้จริง และความสามารถเพียงพอที่จะเข้าสู่เวิร์กโฟลว์การผลิต"

ในการ์ดโมเดลอย่างเป็นทางการ มันได้คะแนน 61.7 ใน SWE-bench Pro และ 73.0 ใน Terminal Bench 2.1; ในตารางเดียวกัน Opus 4.6 Max ได้ 53.4 และ 78.2 ตามลำดับ ผลลัพธ์นี้บ่งชี้ว่าในงานโค้ดและ Terminal Agent บางอย่าง Qwen3.8-27B มีคุณสมบัติที่จะถูกพูดถึงในตารางเดียวกันกับเรือธงแบบปิด

แต่อย่าเขียนใหม่ว่า "27B เอาชนะเรือธงแบบปิดได้อย่างสมบูรณ์"

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

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

ปัจจัยชี้ขาดที่แท้จริงคือการคำนวณหน่วยความจำ

หลายคนเทียบ "จำนวนพารามิเตอร์โมเดล" โดยตรงกับ "หน่วยความจำที่ใช้รัน": 27B ดังนั้นต้องใช้ 27GB

การคำนวณนี้ผิด ต้องคูณจำนวนพารามิเตอร์ด้วยจำนวนบิตที่แต่ละพารามิเตอร์ใช้

คำนวณคร่าวๆ สำหรับ 27 พันล้านพารามิเตอร์:

• BF16: 2 ไบต์ต่อพารามิเตอร์ น้ำหนักเดิมประมาณ 54GB
• 8-bit: ประมาณ 1 ไบต์ต่อพารามิเตอร์ ค่าทางทฤษฎีประมาณ 27GB
• 4-bit: ประมาณ 0.5 ไบต์ต่อพารามิเตอร์ ค่าทางทฤษฎีประมาณ 13.5GB

ค่าทางทฤษฎีนับเฉพาะน้ำหนักหลักเท่านั้น พื้นที่เก็บโมเดลจริงยังรวมถึงสเกลการควอนไทซ์ การกำหนดค่า คำศัพท์ ส่วนประกอบภาพ ฯลฯ เวอร์ชันชุมชน MLX บน Hugging Face มีขนาดประมาณ 16.1GB สำหรับ 4-bit และ 29.5GB สำหรับ 8-bit การแปลง BF16 ข้อความของชุมชนระบุอย่างชัดเจนว่าประมาณ 54GB

นี่เป็นเพียง "ไฟล์มีขนาดเท่าไหร่" ไม่ใช่ "ใช้พื้นที่เท่าไหร่หลังจากเริ่มต้น" โมเดลจะใช้พื้นที่อย่างน้อยสี่ประเภทเมื่อทำงาน

1. แคชบริบท

โมเดลต้องจำสิ่งที่อ่านไปแล้ว มิฉะนั้นจะต้องคำนวณทุกอย่างใหม่ตั้งแต่ต้นสำหรับทุกโทเค็นใหม่ ส่วน standard attention ใช้ KV Cache และเลเยอร์ linear attention มีสถานะของตัวเอง

ยิ่งบริบทยาว แคชก็ยิ่งใหญ่ การทดสอบจากโปรเจกต์ mlx-dspark แสดงว่าสำหรับ Qwen3.8-27B ที่บริบท 128K แคชอาจเพิ่มประมาณ 11GB; บริบท 256K เต็มอาจเพิ่มประมาณ 23GB

นี่คือสาเหตุที่ "โมเดลรองรับ 262K" ไม่ได้หมายความว่า Mac ขนาด 24GB ควรเปิด 262K ขีดจำกัดความสามารถคือสิ่งที่โมเดลสามารถจัดการได้ ไม่ใช่ค่าเริ่มต้นที่สะดวกสบายของเครื่องคุณ

2. บัฟเฟอร์การรันและ Activations ชั่วคราว

ขั้นตอนที่โมเดลอ่านพรอมพ์ยาวเรียกว่า Prefill ในระหว่างขั้นตอนนี้ ต้องประมวลผลอินพุตจำนวนมากในครั้งเดียว และความดันหน่วยความจำและการคำนวณอาจเพิ่มขึ้นอย่างกะทันหัน ภาพหน้าจอหน่วยความจำเมื่อคุณเพิ่งพูดว่า "สวัสดี" ไม่ได้แสดงถึงสถานการณ์หลังจากวางโค้ด 20,000 โทเค็น

3. macOS และแอปพลิเคชันอื่นๆ

CPU และ GPU ของ Apple Silicon แชร์หน่วยความจำแบบรวม ซึ่งเป็นพื้นฐานของประสิทธิภาพของ MLX และเป็นสาเหตุที่ต้องจัดสรรงบประมาณหน่วยความจำอย่างอนุรักษ์นิยม โมเดล ระบบ Chrome Cursor Docker และโปรแกรมอื่นๆ ทั้งหมดแข่งขันกันเพื่อพื้นที่ในพูลเดียวกัน

4. โมเดลร่าง DFlash 2

DFlash 2 ไม่ใช่สวิตช์ฟรี มันต้องโหลดโมเดลร่างเพิ่มเติมและแคชที่เกี่ยวข้อง โปรเจกต์ให้ข้อมูลอ้างอิงความยาวแชทสูงสุด: ประมาณ 18GB สำหรับโมเดลเป้าหมาย 4-bit บวกร่าง และประมาณ 29GB สำหรับ 8-bit ซึ่งยังไม่ได้สำรองพื้นที่สำหรับ 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 จะเหมาะสำหรับการใช้งานประจำวันมากกว่า

อย่าแค่เพิ่มบริททยาวพิเศษและ DFlash 2 ซ้อนกันเพราะ 24GB "โหลดได้" ทำให้มันทำงานได้อย่างเสถียรก่อน แล้วค่อยเพิ่มตัวแปรทีละตัว

48GB / 64GB: พิจารณา 8-bit

พื้นที่เก็บโมเดล:

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

ไฟล์ 8-bit มีขนาดประมาณ 29.5GB 48GB เป็นจุดเริ่มต้นที่สมจริง และ 64GB จะสบายกว่า หากคุณให้ความสำคัญกับความเร็ว พื้นที่บริบท และส่วนต่างของระบบมากกว่า 64GB สามารถใช้ 4-bit ต่อไปได้; ไม่จำเป็นต้องบังคับใช้ 8-bit เพียงเพื่อ "ความแม่นยำที่สูงขึ้น"

BF16: อย่าถือว่า "พอดี" เป็น "เหมาะสำหรับการใช้งาน"

น้ำหนักข้อความ BF16 มีขนาดประมาณ 54GB แล้ว Mac ขนาด 64GB ในทางทฤษฎีใกล้เคียงที่จะใส่ได้ แต่หลังจากเพิ่มระบบ แคช และบัฟเฟอร์ ส่วนต่างจะน้อยมาก สำหรับการใช้งานระยะยาวจริง ควรพิจารณา 96GB ขึ้นไป

สำหรับคนส่วนใหญ่ ความแตกต่างของประสบการณ์ระหว่าง 4-bit และ 8-bit นั้นน้อยกว่าความแตกต่างที่เกิดจาก "เริ่มสว็อปเนื่องจากหน่วยความจำไม่เพียงพอ" มาก เมื่อเกิดการสว็อปอย่างต่อเนื่อง ไม่มีความแม่นยำในการควอนไทซ์ใดจะช่วยประหยัดความเร็วในการตอบสนองได้

การเตรียมตัวก่อนปรับใช้: ตรวจสอบชิป หน่วยความจำ และดิสก์

ขั้นแรก เปิดเทอร์มินัลและยืนยันข้อมูลเครื่อง:

1system_profiler SPHardwareDataType

คุณต้องเห็นชิป Apple M-series และความจุหน่วยความจำแบบรวม

จากนั้นตรวจสอบดิสก์:

1df -h .

ขอแนะนำให้เว้นพื้นที่ว่างอย่างน้อยสองเท่าของขนาดโมเดล กระบวนการดาวน์โหลดอาจสร้างแคช ตามด้วยโมเดลร่าง เวอร์ชันควอนไทซ์หลายเวอร์ชัน และบันทึก ควรเตรียมพื้นที่ว่างมากกว่า 35GB สำหรับ 4-bit และมากกว่า 60GB สำหรับ 8-bit

บทช่วยสอนนี้ใช้ uv เพื่อจัดการสภาพแวดล้อม Python หากยังไม่ได้ติดตั้ง:

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 ที่เหมาะสมโดยอัตโนมัติ

ดาวน์โหลดโมเดล: อย่าคลิกไฟล์ทีละไฟล์ในเบราว์เซอร์

โมเดลขนาดใหญ่มักจะถูกแบ่งออกเป็นชิ้นส่วนน้ำหนักหลายชิ้น การดาวน์โหลดทีละไฟล์ในเบราว์เซอร์มีแนวโน้มที่จะถูกขัดจังหวะ ไฟล์หาย และไม่สะดวกในการ resume วิธีการที่เชื่อถือได้มากกว่าคือการใช้คำสั่ง hf อย่างเป็นทางการของ Hugging Face

คำสั่งดาวน์โหลด 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

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

ลำดับที่ถูกต้องคือรัน baseline ก่อน

เตรียมพรอมพ์ที่ตายตัว โดยควรใกล้เคียงกับงานจริงของคุณ ตัวอย่างเช่น หากคุณใช้มันสำหรับการเขียนโค้ดเป็นหลัก คุณสามารถใช้:

1กรุณา implement cache ที่ปลอดภัยต่อเธรดใน Python ที่รองรับเวลาหมดอายุและการขับไล่แบบ LRU อธิบายการออกแบบก่อน จากนั้นให้โค้ดเต็มและการทดสอบ

การทดสอบ baseline:

1mlx-dspark generate \
2  --model "$MODEL_DIR" \
3  --mode baseline \
4  --prompt "กรุณา implement cache ที่ปลอดภัยต่อเธรดใน Python ที่รองรับเวลาหมดอายุและการขับไล่แบบ LRU อธิบายการออกแบบก่อน จากนั้นให้โค้ดเต็มและการทดสอบ" \
5  --max-new-tokens 600

บันทึกตัวเลขสี่ตัว:

1. เวลาโหลดโมเดล
2. ความเร็วในการประมวลผลพรอมพ์ (Prefill tok/s)
3. เวลาจนถึงโทเค็นแรก (TTFT)
4. ความเร็วในการสร้างจริง (generation tok/s)

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

ระหว่างการทดสอบ ให้เปิด "Activity Monitor → Memory" เพื่อสังเกตความดันหน่วยความจำและ Swap สีเหลืองไม่ได้หมายถึงปัญหาทันทีเสมอไป แต่ถ้า Swap เพิ่มขึ้นอย่างต่อเนื่อง แสดงว่าการกำหนดค่านี้ไม่มีส่วนต่างที่เสถียร

อย่าเพิ่งรันแค่ 50 โทเค็น คำตอบสั้นๆ จะทำให้เวลาโหลดและ warm-up คิดเป็นสัดส่วนสูงเกินไป และจะไม่แสดงความเร็วที่แท้จริงระหว่างการสร้างอย่างต่อเนื่อง แนะนำให้สร้างอย่างน้อย 400–1000 โทเค็น

DFlash 2 ทำให้ 27B ทำงานเร็วขึ้นได้อย่างไร?

การถอดรหัสทั่วไปเป็นแบบอนุกรม Qwen3.8-27B สร้างหนึ่งโทเค็น โมเดลเป้าหมายเต็มรันหนึ่งครั้ง; สร้างถัดไป และรันอีกครั้ง การสร้าง 1,000 โทเค็นต้องใช้ประมาณ 1,000 รอบติดต่อกัน

DFlash 2 เพิ่มโมเดลร่างที่เบากว่า โมเดลร่างเสนอชุดโทเค็นตัวเลือกแบบขนานก่อน จากนั้นโมเดลหลัก 27B จะตรวจสอบร่วมกัน การเดาที่ถูกต้องสามารถยอมรับได้หลายครั้งในครั้งเดียว ในขณะที่การเดาที่ผิดจะถูกแก้ไขโดยโมเดลหลัก

คุณสามารถคิดว่ามันเป็น:

• โมเดลร่างเป็นผู้ช่วยที่รับผิดชอบการร่างอย่างรวดเร็ว
• โมเดลหลัก 27B เป็นบรรณาธิการบริหารที่มีอำนาจตัดสินใจขั้นสุดท้าย
• ยิ่งผู้ช่วยเดาถูกต้องติดต่อกันมากเท่าไหร่ บรรณาธิการบริหารก็ยิ่งต้องทำงานน้อยลงเท่านั้น

โมเดลร่างไม่ได้ตัดสินใจเอาต์พุตอย่างอิสระ การ์ดโมเดล DFlash 2 ระบุว่าภายใต้การถอดรหัสแบบ greedy เอาต์พุตจะสอดคล้องกับโมเดลเป้าหมาย; ระหว่างการสุ่มตัวอย่างแบบสุ่ม มันจะรักษาการกระจายของโมเดลเป้าหมาย

มันไม่ได้รับประกันว่าจะเร่งความเร็วในทุกสถานการณ์

หากงานทำให้โมเดลร่างคาดเดาได้ง่าย เช่น การเติมโค้ดให้สมบูรณ์หรือข้อความยาวที่มีรูปแบบคงที่ ความยาวการยอมรับมักจะสูงกว่า; หากเนื้อหากระโดดอย่างมีนัยสำคัญ คำตอบสั้นมาก หรือความสุ่มในการสุ่มตัวอย่างสูง ร่างมักจะถูกปฏิเสธ และการคำนวณพิเศษอาจกินกำไร

การเปิดใช้งาน DFlash 2: ปล่อยให้เครื่องมือปรับเทียบตัวเอง อย่าคัดลอกพารามิเตอร์ของคนอื่น

รัน benchmark ในตัวของโปรเจกต์ก่อน:

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

ระบุ --modes dflash อย่างชัดเจนที่นี่ เนื่องจาก benchmark เวอร์ชันปัจจุบันค่าเริ่มต้นจะทดสอบ DSpark และ lookup และจะไม่สลับไปยัง DFlash 2 ของ Qwen3.8-27B โดยอัตโนมัติ การรันครั้งแรกจะดาวน์โหลดโมเดลร่างที่ตรงกัน; --caps auto จะทดสอบ draft caps ที่เหมาะสมตาม Mac โมเดลเป้าหมาย และเวอร์ชันควอนไทซ์ของคุณ M1 Max, M4 Pro และ M5 Max มีแบนด์วิธหน่วยความจำและต้นทุนการคำนวณที่แตกต่างกัน ดังนั้นพารามิเตอร์ที่เหมาะสมที่สุดไม่ควรเหมือนกันทุกประการ

ดังนั้น ไม่แนะนำให้คัดลอก --max-draft 7 อย่างถาวรเพียงเพราะคุณเห็นคนอื่นเขียน ปล่อยให้การปรับเทียบอัตโนมัติให้คำตอบก่อน จากนั้นทดสอบซ้ำกับงานจริง

ใช้พรอมพ์เดียวกันเพื่อเปิดใช้งานโหมดอัตโนมัติ:

1mlx-dspark generate \
2  --model "$MODEL_DIR" \
3  --mode auto \
4  --prompt "กรุณา implement cache ที่ปลอดภัยต่อเธรดใน Python ที่รองรับเวลาหมดอายุและการขับไล่แบบ LRU อธิบายการออกแบบก่อน จากนั้นให้โค้ดเต็มและการทดสอบ" \
5  --max-new-tokens 600

ตอนนี้เปรียบเทียบกับ baseline:

• ข้อความเอาต์พุตสอดคล้องกันหรือไม่?
• TTFT ยาวขึ้นอย่างมีนัยสำคัญหรือไม่?
• generation tok/s ดีขึ้นเท่าไหร่?
• mean accept length คืออะไร?
• หน่วยความจำสูงสุดและ Swap แย่ลงหรือไม่?

คำสั่งเหล่านี้ใช้ greedy decoding โดยค่าเริ่มต้น ดังนั้นข้อความเอาต์พุตของ baseline และ auto ควรสอดคล้องกัน ยกเว้นในกรณีที่จุดทศนิยมเสมอกันน้อยมาก หากคำตอบแตกต่างกันอย่างมีนัยสำคัญ ให้ตรวจสอบว่าพรอมพ์ โหมดการคิด พารามิเตอร์การสุ่มตัวอย่าง และเวอร์ชันซอฟต์แวร์เหมือนกันก่อนที่จะพูดถึงความเร็ว ระหว่างการสุ่มตัวอย่างแบบสุ่ม 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 เท่า

สิ่งเหล่านี้เป็นผลลัพธ์ภายใต้เวอร์ชันเฉพาะ เครื่อง สถานะ hot-start และพรอมพ์ทดสอบ ไม่ใช่คำมั่นสัญญา ข้อมูลแยกของโปรเจกต์ยังแสดงว่าอัตราส่วนการเร่งความเร็วแตกต่างกันสำหรับงานแชท โค้ด และคณิตศาสตร์

เกณฑ์ที่มีประโยชน์อย่างแท้จริงไม่ใช่ "คนอื่นถึง 30 tok/s" แต่เป็นว่างานที่คุณทำบ่อยๆ เร็วขึ้นหรือไม่

หากคุณปกติให้โมเดลแก้ไขโค้ด ให้ทดสอบกับงานแก้ไขในพื้นที่เก็บข้อมูลจริง; หากคุณใช้มันเพื่อเขียนบทความ ให้สร้าง 1500 โทเค็นอย่างต่อเนื่อง; หากคุณต้องการเชื่อมต่อ Agent ให้รันการเรียกใช้เครื่องมือแบบเต็ม เฉพาะเมื่อเวลาทั้งหมดสำหรับงานจริงลดลง DFlash 2 จึงคุ้มค่าที่จะเปิดไว้

เปิดตัวโมเดลเป็น API ในเครื่อง

หลังจากยืนยันว่าทั้งโหมดพื้นฐานและโหมดอัตโนมัติทำงานได้อย่างเสถียรแล้ว คุณสามารถทำให้โมเดลเป็นบริการที่อยู่ถาวร สำหรับ Mac ขนาด 24GB ให้จำกัดบริบทไว้ที่ 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 ไคลเอนต์แชท เครื่องมือโค้ด และ Agent ที่รองรับ Base URL แบบกำหนดเองสามารถเชื่อมต่อได้โดยปกติ

ทำการทดสอบการสนทนาด้วย curl ต่อไปนี้ใช้ ID โมเดลที่ส่งคืนสำหรับ 4-bit เป็นตัวอย่าง; หากคุณดาวน์โหลด 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 ไว้ System prompts และ tool definitions สำหรับโค้ด Agent มักจะยาวมาก การนำ prefix มาใช้ซ้ำระหว่างหลายรอบสามารถลดการ Prefill ซ้ำซ้อนได้อย่างมาก

จะเลือกโหมดการคิดอย่างไร? ตัวแปรที่ถูกมองข้ามมากที่สุดในการทดสอบ

Qwen3.8 จะคิดก่อนตอบโดยค่าเริ่มต้น สำหรับการแก้ไขโค้ดที่ซับซ้อน การใช้เหตุผลทางคณิตศาสตร์ การวิเคราะห์งานวิจัย และงาน Agent แบบหลายรอบ คุณสามารถใช้โหมดการคิดเริ่มต้นได้ สำหรับการแชททั่วไป การแปล การสรุปความ และการแปลงรูปแบบ กระบวนการคิดมักจะเพิ่มเฉพาะเวลารอและจำนวน token เอาต์พุต

หากต้องการให้คิดแต่ลดระดับการใช้เหตุผล ให้ใช้คำสั่งเต็ม:

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 ต้องลองซ้ำหลายครั้งเนื่องจากการวิเคราะห์ไม่เพียงพอ ทำให้งานโดยรวมช้าลง วิธีที่น่าเชื่อถือที่สุดคือการคำนวณเวลาทั้งหมดของงานทั้งหมด แทนที่จะเปรียบเทียบเฉพาะคำตอบในรอบแรก

กฎข้อหนึ่งที่ต้องจำไว้: เมื่อทำ A/B ทดสอบระหว่าง baseline กับ DFlash 2 โหมดการคิดต้องเหมือนกัน ถ้าตัวหนึ่งเปิดคิดและอีกตัวปิด จำนวน token และเส้นทางของงานจะเปลี่ยนไป และความเร็วที่คำนวณได้จะไม่มีความหมายในการเปรียบเทียบ พารามิเตอร์การสุ่มตัวอย่าง พรอมต์ ความยาวเอาต์พุตสูงสุด บริบท และสถานะ cold/hot start ก็ต้อง保持一致ด้วย

เส้นทางปรับใช้ที่สั้นที่สุด: รวมคำสั่งที่จำเป็นเข้าด้วยกัน

สิ่งที่พูดถึงก่อนหน้านี้คือเหตุผลของแต่ละขั้นตอน หากคุณเข้าใจหลักการแล้วและต้องการทำซ้ำอย่างรวดเร็ว คุณสามารถดำเนินการตามลำดับต่อไปนี้ ตัวอย่างเลือก 4-bit และบริบท 8K เหมาะสำหรับการเริ่มต้นแบบอนุรักษ์นิยมบน Mac 24GB เวลาจริงสำหรับการดาวน์โหลดและ benchmark ขึ้นอยู่กับเครือข่ายและชิป และไม่รวมอยู่ใน "เส้นทางที่สั้นที่สุด":

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 อย่างแรกเพื่อยืนยันว่าไม่มีคำเตือนด้านหน่วยความจำและโหมดที่คาดหวังเปิดใช้งานจริง อย่างหลังเพื่อยืนยันรหัสโมเดล จากนั้นให้ตอบยาวประมาณ 400 token และสังเกตความดันหน่วยความจำและ Swap ใน Activity Monitor หากทั้งสี่อย่างปกติ ให้ใส่ 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

หลังจากอัปเกรด ให้รัน baseline สั้นๆ และ /health ก่อนเพื่อยืนยันว่าโมเดลยังโหลดได้ จากนั้นจึงเริ่มบริการระยะยาว เครื่องมือ Inference อัปเดตบ่อย และพารามิเตอร์ที่ใช้ได้กับเวอร์ชันเก่าไม่จำเป็นต้องดีที่สุดเสมอไป ดังนั้นการบันทึก baseline ของตัวเองจึงมีค่า

การเข้าถึง LAN: อย่างน้อยต้องเพิ่มการล็อกก่อน

ค่าเริ่มต้น 127.0.0.1 สามารถเข้าถึงได้เฉพาะเครื่องท้องถิ่นเท่านั้น หากต้องการให้ Mac หรือ iPad เครื่องอื่นบน Wi-Fi เดียวกันเรียกใช้ได้ คุณสามารถฟังบนการ์ดเครือข่ายทั้งหมดและตั้งค่า 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 ด้วย IP LAN ของ Mac เครื่องนี้และส่ง Authorization: Bearer your_key ในคำขอ นอกจากนี้ ให้ตรวจสอบไฟร์วอลล์ macOS เพื่ออนุญาตให้เฉพาะเครือข่ายที่เชื่อถือได้เข้าถึงพอร์ต 8080

นี่ยังเป็นเพียงโซลูชัน LAN หากต้องการเข้าถึงผ่านอินเทอร์เน็ต คุณต้องมี TLS, reverse proxy, access control และ rate limiting อย่าแมปพอร์ต 8080 โดยตรงบนเราเตอร์ วิธีที่ง่ายที่สุดคือกลับไปยังเครือข่ายภายในบ้านผ่าน VPN ที่เชื่อถือได้ จากนั้นจึงเข้าถึงบริการภายในเครื่อง

การแก้ไขปัญหาทั่วไป

1. โมเดลถูกระบบฆ่าระหว่างโหลดครึ่งทาง

ก่อนอื่นให้ยืนยันว่าคุณเลือกเวอร์ชัน quantization ที่ถูกต้อง 24GB และ 32GB ไม่ควรดาวน์โหลด 8-bit โดยไม่ได้ตั้งใจ และห้ามแตะ BF16 เด็ดขาด ปิด Docker, เครื่องเสมือน, แท็บเบราว์เซอร์จำนวนมาก และโมเดลท้องถิ่นอื่นๆ จากนั้นลอง 4-bit อีกครั้ง

2. รันได้ แต่ Mac ทั้งเครื่องช้าลงมาก

เปิด Activity Monitor ดู Swap หาก Swap เพิ่มขึ้นเรื่อยๆ ให้ลดบริบทลงก่อน จากนั้นปิด DFlash 2 อย่ามองแค่ตัวเลขของกระบวนการโมเดลเพียงอย่างเดียว เพราะความดันหน่วยความจำแบบรวมนั้นเกิดจากทั้งระบบร่วมกัน

3. DFlash 2 ช้าลงจริง

ยืนยันเงื่อนไขการเปรียบเทียบเหมือนกัน: พรอมต์เดียวกัน ความยาวเอาต์พุตเดียวกัน โหมดการคิดเดียวกัน สถานะ cold start หรือ hot start เหมือนกัน คำตอบสั้นๆ ไม่เหมาะสำหรับการตัดสินประสิทธิภาพของ speculative decoding รันมากกว่าสามรอบและทดสอบกับงานจริงที่ยาว

หากยังช้าอยู่ แสดงว่าอัตราการยอมรับของงานปัจจุบันต่ำ หรือหน่วยความจำที่เพิ่มขึ้นจาก draft model ทำให้ระบบเริ่ม Swap การปิดไม่ใช่ความล้มเหลว baseline ที่เสถียรก็เป็นโซลูชันที่มีประสิทธิภาพอยู่แล้ว

4. Token แรกช้ามาก แต่การสร้างต่อเนื่องใช้ได้

นี่คือคอขวดของ Prefill ตรวจสอบว่าอินพุตยาวเกินไปหรือไม่ มีไฟล์ที่ไม่เกี่ยวข้องจำนวนมากถูกยัดเยียดซ้ำในทุกๆ รอบหรือไม่ และ Prefix Cache ทำงานหรือไม่ สำหรับ Agent การปรับความยาว prompt ให้เหมาะสมมักจะมีประสิทธิภาพมากกว่าการไล่ตาม 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"

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

ลำดับการปรับใช้ที่มีโอกาสล้มเหลวน้อยที่สุด

รายการตรวจสอบการดำเนินการ:

1. ยืนยันว่าเป็น Mac Apple Silicon
2. ยกเลิก 27B สำหรับ 16GB; เลือก 4-bit สำหรับ 24GB/32GB; พิจารณา 8-bit สำหรับ 48GB/64GB
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. เปรียบเทียบ baseline และ auto ด้วยงานจริงที่เหมือนกันทุกประการ
9. เปิด DFlash 2 ในระยะยาวก็ต่อเมื่อความเร็วดีขึ้นอย่างมีนัยสำคัญและความดันหน่วยความจำคงที่
10. สุดท้าย เริ่ม API ท้องถิ่นและเชื่อมต่อเครื่องมือโค้ด, ฐานความรู้ หรือ Agent

ความสำคัญของการปรับใช้ในเครื่องไม่ได้มีแค่การประหยัดค่า API

เมื่อ Qwen3.8-27B กลายเป็นบริการท้องถิ่นบน Mac ที่สามารถเรียกใช้ได้ตลอดเวลา คุณสามารถเก็บโค้ดและเอกสารที่ละเอียดอ่อนไว้ในเครื่องของคุณเอง ประมวลผลสื่อแบบออฟไลน์ และเชื่อมต่อเข้ากับงานอัตโนมัติ ฐานความรู้ส่วนบุคคล และเวิร์กโฟลว์ Agent ที่ทำงานระยะยาว

เส้นผ่านของฉันเองนั้นง่าย: งานทั่วไปไม่ Swap ความเร็วในการตอบรับพอรับได้ และฉันจะเปิดใช้งานอย่างกระตือรือร้นในวันถัดไป เมื่อตรงตามสามข้อนี้เท่านั้น การปรับใช้จึงจะประสบความสำเร็จอย่างแท้จริง

หากคุณรันได้แล้ว โปรดแสดงความคิดเห็นพร้อม "รุ่นชิป, หน่วยความจำแบบรวม, 4/8-bit, ความยาวบริบท, baseline และ DFlash 2 tok/s" หากมีข้อมูลเพียงพอ ฉันสามารถรวบรวมเป็นตารางทดสอบการกำหนดค่า Mac ต่อไปได้

หากคุณยังคงคิดว่าการปรับใช้ยุ่งยาก

ฉันได้รวบรวมคำสั่งติดตั้ง การดาวน์โหลดโมเดล การทดสอบความเร็ว การเร่งความเร็ว DFlash 2 การเริ่ม API ท้องถิ่น และการแก้ไขปัญหาทั่วไปที่กล่าวถึงในบทความนี้เป็นรายการตรวจสอบการปรับใช้ที่สามารถทำตามได้โดยตรง:

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

คุณสามารถคัดลอกและดำเนินการตามลำดับด้วยตัวเอง หรือให้ที่เก็บ GitHub นี้แก่ Codex หรือ Claude Code โดยตรง ให้มันอ่าน README.md ตรวจสอบการกำหนดค่า Mac ของคุณ และติดตั้งตามรายการตรวจสอบ วิธีนี้คุณไม่ต้องค้นหาคำสั่งซ้ำจากบทความยาวๆ และการอัปเดตและการแก้ไขปัญหาภายหลังก็สะดวกยิ่งขึ้น