Zinc คืออะไร? มันคือเครื่องมือประมวลผล LLM ใน Zig สำหรับ AMD และ Apple

Zinc คือเอนจินอนุมานเฉพาะที่สำหรับโมเดลภาษาขนาดใหญ่ (LLM) ที่ออกแบบมาเพื่อใช้ประโยชน์สูงสุดจาก GPU สำหรับผู้บริโภคของ AMD (RDNA3 และ RDNA4) และชิป Apple Silicon โดยใช้ Zig เป็นภาษาและ Vulkan/Metal เป็นแบ็กเอนด์กราฟิก หากคุณมีการ์ดกราฟิกที่ทันสมัยและรู้สึกหงุดหงิดกับการใช้งาน vLLM, ROCm หรือโซลูชันอื่นๆ ที่ปรับแต่งได้ไม่ดีเท่าที่ควร โครงการนี้ได้รับการออกแบบมาเพื่อเติมเต็มช่องว่างนั้น

เป้าหมายของ Zinc นั้นชัดเจนมาก คือการนำเสนอวิธีที่ง่าย รวดเร็ว และไม่ขึ้นอยู่กับการพึ่งพาซอฟต์แวร์อื่น ในการรันโมเดล GGUF ในเครื่องของคุณเอง ด้วยการสร้างเพียงครั้งเดียว ไฟล์ไบนารีเดียว และเซิร์ฟเวอร์ที่เข้ากันได้กับ API ของ OpenAI พร้อมด้วยอินเทอร์เฟซแชทในเบราว์เซอร์แบบบูรณาการ ทั้งหมดนี้ทำได้ด้วยเชเดอร์ที่สร้างขึ้นด้วยมือสำหรับแต่ละแพลตฟอร์ม การออกแบบระดับต่ำ และประสบการณ์ผู้ใช้ที่ปรับแต่งมาสำหรับนักพัฒนาและผู้ใช้ขั้นสูง

Zinc (Zig inference engine) คืออะไร และมันแก้ปัญหาอะไร?

Zinc เป็นเอนจินอนุมาน LLMที่เขียนขึ้นโดยใช้ภาษา Zig เป็นหลัก และได้รับการออกแบบตั้งแต่เริ่มต้นเพื่อใช้ประโยชน์จากฮาร์ดแวร์ของ GPU สองตระกูลที่แพร่หลายแต่โดยทั่วไปแล้วไม่ค่อยได้รับการสนับสนุนอย่างเต็มที่ ได้แก่ GPU สำหรับผู้บริโภคของ AMD ที่ใช้สถาปัตยกรรม RDNA3/RDNA4 และ Apple Silicon SoCs (M1, M2, M3, M4, M5) แทนที่จะใช้ ROCm, CUDA หรือ MLX Zinc ใช้ Vulkan 1.3 บน Linux และ Metal บน macOS แทน

โครงการนี้เริ่มต้นจากข้อร้องเรียนที่เกิดขึ้นซ้ำๆในชุมชน: ผู้ที่มีการ์ดกราฟิก AMD ประสิทธิภาพสูงพบว่า ROCm ไม่รองรับการ์ดสำหรับผู้บริโภคได้ดี vLLM ใช้งานไม่ได้เลยหากไม่มี ROCm และวิธีการใช้ Vulkan ใน llama.cpp นั้นมอง GPU เป็นเพียงส่วนประกอบรอง โดยใช้ shaders ทั่วไป ไม่มีการปรับแต่งเฉพาะสำหรับสถาปัตยกรรม และไม่มีประวัติการใช้งานบนเซิร์ฟเวอร์ที่น่าเชื่อถือ

แนวคิดหลักของ Zinc คือฮาร์ดแวร์นั้นพร้อมใช้งานอยู่แล้วการ์ด RDNA3 และ RDNA4 มีหน่วยความจำ หน่วยประมวลผล และแบนด์วิดท์ VRAM มากเกินพอที่จะรันโมเดลขนาดใหญ่ และชิป Apple Silicon ก็มีหน่วยความจำแบบรวมและหน่วยประมวลผลที่ทรงพลัง ปัญหาคอขวดที่แท้จริงอยู่ที่ซอฟต์แวร์ ดังนั้นจึงมีการสร้างเอนจินเฉพาะสำหรับแพลตฟอร์มเหล่านี้ โดยใช้แนวทางระบบระดับต่ำมาก

ในทางปฏิบัติ ปัจจุบัน Zinc สามารถโหลดโมเดล GGUF ขนาดใหญ่ได้ (น้ำหนัก VRAM ประมาณ 21 GB สำหรับโมเดลที่มีพารามิเตอร์ 35 พันล้านตัว) สร้างกราฟการคำนวณที่มีโหนดหลายร้อยโหนด (ตัวอย่างเช่น สำหรับทรานส์ฟอร์เมอร์แบบไฮบริดที่มีเลเยอร์ MoE และ SSM) และสร้างข้อความที่สอดคล้องกันได้ด้วยความเร็วที่แข่งขันได้ โดยเฉพาะอย่างยิ่งบนฮาร์ดแวร์ RDNA4 ที่ได้รับการปรับแต่งอย่างละเอียด

เหตุใดซิกจึงได้รับเลือกให้สร้างสังกะสี?

Zig เหมาะอย่างยิ่งสำหรับงานประเภทที่จำเป็นสำหรับเอนจิ้นการประมวลผลกราฟิกบน GPU ที่เน้น Vulkan และ Metal: การเรียกใช้ API กราฟิกอย่างเข้มข้น การจัดการหน่วยความจำ GPU ด้วยตนเอง การบันทึกบัฟเฟอร์คำสั่ง และไปป์ไลน์การสร้างเชเดอร์แบบบูรณาการ มันคือโค้ดระบบบริสุทธิ์ และ Zig ก็มีชุดเครื่องมือที่เหมาะสมกับความเป็นจริงนั้นอย่างสมบูรณ์แบบ

คุณสมบัติสำคัญอย่างหนึ่งคือ `@cImport`ซึ่งช่วยให้เข้าถึง C ABI ของ Vulkan ได้โดยตรงโดยไม่ต้องสร้างการเชื่อมโยงที่ซับซ้อนหรือเลเยอร์เพิ่มเติม ทำให้ง่ายต่อการเรียกใช้ฟังก์ชัน API ระดับต่ำตามที่กำหนดไว้ ลดความยุ่งยากและภาระงานเมื่อโต้ตอบกับไดรเวอร์และรันไทม์กราฟิก

การใช้ comptime ใน Zigมีประโยชน์อย่างมากในการสร้างตารางการส่งคำสั่งตามประเภทการควอนไทเซชัน และสำหรับการกำหนดเส้นทางการทำงานของโค้ดเฉพาะที่ในระหว่างการคอมไพล์ ซึ่งส่งผลให้มีการแตกแขนงน้อยลงในระหว่างการทำงาน และมีการเลือกเคอร์เนลและรูปแบบต่างๆ ได้อย่างมีประสิทธิภาพมากขึ้น เช่น Q4_K, Q5_K, Q6_K, Q8_0 หรือ F16 ขึ้นอยู่กับโมเดล GGUF ที่โหลด

การจัดการข้อผิดพลาดและทรัพยากรด้วย errdeferช่วยให้การล้างทรัพยากร GPU เป็นไปอย่างมีประสิทธิภาพ: บัฟเฟอร์ รูปภาพ ตัวอธิบาย และวัตถุ Vulkan/Metal อื่นๆ จะถูกปล่อยอย่างเหมาะสมแม้จะมีข้อผิดพลาดเกิดขึ้นระหว่างทาง ซึ่งจะช่วยป้องกันการรั่วไหลของ VRAM และสถานะที่ไม่สอดคล้องกันหลังจากความล้มเหลวในระหว่างการเริ่มต้นหรือลูปการถอดรหัส

ระบบการสร้างของ Zig เองช่วยลดความซับซ้อนของการรวมการคอมไพล์เชเดอร์ได้อย่างมาก: คำสั่ง `zig build` สามารถเชื่อมโยงขั้นตอนต่างๆ เข้าด้วยกันเพื่อเรียกใช้ glslc บน Linux วางเชเดอร์ SPIR-V ที่คอมไพล์แล้วไว้ใน `zig-out/share/zinc/shaders/` และสร้างไบนารีเดียวใน `zig-out/bin/zinc` ที่รวมทุกอย่างเข้าด้วยกัน ส่วนบน macOS เชเดอร์ Metal (MSL) จะถูกคอมไพล์ในขณะรันไทม์

สถาปัตยกรรมโดยทั่วไป: Vulkan ใน AMD และ Metal ใน Apple Silicon

Zinc ถูกออกแบบมาให้มีเส้นทางการทำงานที่แตกต่างกันสองแบบแบบหนึ่งสำหรับ Linux ที่ใช้ GPU ของ AMD โดยใช้ Vulkan 1.3 และอีกแบบสำหรับ macOS ที่ใช้ Apple Silicon โดยใช้ Metal แม้ว่าจากมุมมองของผู้ใช้แล้ว ประสบการณ์จะแทบจะเหมือนกัน กล่าวคือ สร้างไบนารี เลือกโมเดล GGUF ที่ผ่านการตรวจสอบแล้ว และเริ่มการอนุมานผ่าน CLI เซิร์ฟเวอร์ HTTP หรืออินเทอร์เฟซแชทบนเว็บ

แนวทางของ AMD ใช้ประโยชน์จากความสามารถของ RDNA3 และ RDNA4 อย่างเต็มที่โดยใช้เชเดอร์ประมวลผล GLSL ที่เขียนขึ้นเอง พร้อมด้วย wave64, เมทริกซ์แบบร่วมมือ และกลยุทธ์การจัดเรียงภาพเฉพาะสถาปัตยกรรม ทำงานบน Vulkan นี่ไม่ใช่แบ็กเอนด์ทั่วไปที่ "ใช้งานได้กับ AMD ด้วย" แต่เป็นเคอร์เนลที่ปรับแต่งมาโดยเฉพาะเพื่อใช้ประโยชน์จากฮาร์ดแวร์อย่างเต็มที่

บน Apple Silicon นั้น Zinc ใช้ shaders ดั้งเดิมใน Metal (MSL) ร่วมกับการดำเนินการ simdgroup โดยใช้หน่วยความจำแบบรวมและ mmap แบบ zero-copy เพื่อโหลดโมเดลโดยตรงโดยไม่ต้องมีขั้นตอนการคัดลอกระดับกลางที่สิ้นเปลือง ซึ่งสอดคล้องกับปรัชญา SoC ของ Apple ที่ CPU และ GPU ใช้พื้นที่หน่วยความจำร่วมกัน

การเลือกแบ็กเอนด์จะดำเนินการโดยอัตโนมัติในระหว่างการคอมไพล์ : Zig จะตรวจจับว่ากำลังสร้างในสภาพแวดล้อม Linux ที่รองรับ Vulkan หรือบน macOS ที่รองรับ Metal และเปิดใช้งานเส้นทางที่เกี่ยวข้อง จากมุมมองของคำสั่งสร้าง ผู้ใช้เพียงแค่เรียกใช้ `zig build -Doptimize=ReleaseFast` และจะได้ไบนารีที่พร้อมใช้งานสำหรับแพลตฟอร์มของตน

การออกแบบนี้หลีกเลี่ยงการพึ่งพาไดรเวอร์เฉพาะอย่างเช่น ROCm หรือ MLX รวมถึงรันไทม์อย่าง CUDA หรือ Python Zinc ถูกสร้างขึ้นมาให้เป็น "ไบนารีเดียว โดยไม่ต้องใช้สแต็ก ML ขนาดใหญ่" ซึ่งเป็นสิ่งที่น่าสนใจอย่างยิ่งสำหรับผู้ที่ต้องการตั้งค่าเซิร์ฟเวอร์ LLM ในเครื่องเดสก์ท็อปหรือแล็ปท็อปโดยไม่ต้องติดตั้งที่ซับซ้อน

แพลตฟอร์ม, GPU และรุ่นที่รองรับ

ปัจจุบัน Zinc มุ่งเน้นไปที่สองสภาพแวดล้อมหลักได้แก่ Linux กับ GPU AMD RDNA3/RDNA4 ผ่าน Vulkan 1.3 และ macOS กับ Apple Silicon ตั้งแต่ M1 ถึง M5 ผ่าน Metal ซึ่งครอบคลุมทั้งการ์ดกราฟิกสำหรับเดสก์ท็อปและการ์ดที่เน้น AI (เช่น Radeon AI PRO) รวมถึงชิปแบบรวมในแล็ปท็อปและเดสก์ท็อปของ Apple ด้วย

บนระบบ Linux ได้มีการตรวจสอบความเข้ากันได้กับกราฟิกการ์ด เช่น AMD Radeon AI PRO R9700 (RDNA4, 32 GB) และกราฟิกการ์ด RDNA3 เช่น RX 7900 XTX สำหรับ RDNA4 ขอแนะนำให้เปิดใช้งานการเพิ่มประสิทธิภาพเมทริกซ์แบบร่วมมือกันโดยใช้ตัวแปรสภาพแวดล้อม RADV_PERFTEST=coop_matrix ก่อนเรียกใช้ Zinc เนื่องจากจะช่วยให้เส้นทางการคำนวณในไดรเวอร์ RADV มีประสิทธิภาพมากขึ้น

บน macOS, Zinc ทำงานบน Apple Siliconตั้งแต่ M1 รุ่นแรกๆ ไปจนถึงรุ่นใหม่ๆ เช่น M4 และรุ่นต่อๆ มา โดยใช้ Metal เป็นแบ็กเอนด์และเชเดอร์ MSL ที่เขียนขึ้นเอง ตัวอย่างเช่น มีการทดสอบบน M1 Pro ที่มีหน่วยความจำแบบรวม 32GB ซึ่งเพียงพอสำหรับโมเดลที่มีพารามิเตอร์หลายพันล้านตัว และยังทดสอบกับรุ่น 35GB บางรุ่นที่มีข้อกำหนดด้านหน่วยความจำเฉพาะอีกด้วย

ในแง่ของโมเดล Zinc จำกัดตัวเองไว้เฉพาะชุด GGUF ที่ผ่านการตรวจสอบแบบครบวงจรแล้วเท่านั้น แทนที่จะแสดงรายการแคตตาล็อกทางทฤษฎีขนาดใหญ่ ซึ่งรวมถึง Qwen3.5 รุ่นต่างๆ ที่มีพารามิเตอร์ 2B และ 35B พร้อมด้วยการควอนไทเซชัน เช่น Q4_K_M หรือ Q4_K_XL ที่ออกแบบมาเพื่อสร้างสมดุลระหว่างการใช้ VRAM และประสิทธิภาพการประมวลผลแบบอนุมาน

รูปแบบการควอนไทเซชันที่รองรับ ได้แก่ Q4_K, Q5_K, Q6_K, Q8_0 และ F16 ซึ่งช่วยให้สามารถปรับคุณภาพและความเร็วได้ตามฮาร์ดแวร์ที่มีอยู่ ตัวอย่างเช่น ในการทดสอบประสิทธิภาพปัจจุบัน โมเดล Qwen3.5 2B Q4_K_M ทำได้ประมาณ 27 โทเค็นต่อวินาทีบน RDNA4 และประมาณ 17 โทเค็นต่อวินาทีบน Apple Silicon ในการถอดรหัสสตรีมเดียว

ผลการดำเนินงานปัจจุบันและสถานะโครงการ

Zinc ยังคงเป็นซอฟต์แวร์ทดลองที่อยู่ระหว่างการพัฒนาอย่างต่อเนื่อง แต่ก็มีประสิทธิภาพที่น่าประทับใจและมีไปป์ไลน์ที่เสถียรสำหรับการอนุมานผ่าน CLI และเซิร์ฟเวอร์ HTTP ในสภาพแวดล้อมการทดสอบด้วย Radeon AI PRO R9700 (RDNA4, 32 GB, 576 GB/s) สามารถวัดความเร็วได้ประมาณ 38 tok/s บนโมเดล Qwen3.5 35B-A3B UD ที่ควอนไทซ์เป็น Q4_K_XL

ในการทดสอบการถอดรหัสแบบง่ายๆ ผ่านบรรทัดคำสั่งกรณีทั่วไปคือการป้อนข้อความสั้นๆ เช่น "เมืองหลวงของฝรั่งเศสคือ" และสร้างโทเค็นได้ 128 โทเค็น ภายใต้เงื่อนไขเหล่านี้ พบอัตราการประมวลผลใกล้เคียง 37,95 โทเค็น/วินาที โดยใช้เวลาประมาณ 26,3 มิลลิวินาที/โทเค็น ในโมเดล 35B และประมาณ 26,71 โทเค็น/วินาที (37,4 มิลลิวินาที/โทเค็น) ในโมเดล 2B Q4_K_M บนโหนด RDNA4 เดียวกัน

เป็นที่น่าสังเกตว่าโมเดล 35Bสามารถทำงานได้ดีกว่าโมเดล 2B บนฮาร์ดแวร์นี้ ซึ่งแสดงให้เห็นว่าคอขวดไม่ได้อยู่ที่จำนวนพารามิเตอร์เพียงอย่างเดียว แต่เป็นรูปร่างของกราฟ ประเภทของเคอร์เนลที่ใช้ และประสิทธิภาพของเส้นทางการถอดรหัส เอนจินนี้สามารถทำแบนด์วิดท์ได้ประมาณ 112,5 GB/s สำหรับเส้นทางโทเค็นทั้งหมด ซึ่งคิดเป็นประมาณ 19,5% ของค่าสูงสุดตามทฤษฎีของชิป

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

เมื่อเทียบกับเอนจิ้นอื่นๆ เช่น llama.cppประสิทธิภาพพื้นฐานปัจจุบันของ Zinc บน RDNA4 สำหรับโมเดล 35B และการถอดรหัสพื้นฐานอยู่ที่ประมาณ 40 tok/s ในขณะที่ llama.cpp สามารถทำได้เกิน 100 tok/s บนโหนดและโมเดลเดียวกัน แผนงานของ Zinc คือการลดช่องว่างนี้โดยการเพิ่มประสิทธิภาพ hot kernels ลด overhead ของ Vulkan และปรับปรุงเส้นทางการแชทแบบมีเหตุผล (/v1/chat/completions) เพื่อให้มีประสิทธิภาพใกล้เคียงกับเส้นทางการถอดรหัสแบบบริสุทธิ์

ปรับแต่งกลไกภายในและเชเดอร์

เอนจิน Zinc ประกอบด้วยส่วนประกอบพื้นฐานหลายอย่างที่สร้างเสร็จแล้ว ได้แก่ โครงสร้างพื้นฐาน Vulkan, ตัวแยกวิเคราะห์ GGUF และตัวโหลดโมเดล, การตรวจจับ GPU RDNA3/RDNA4, ตัวแยกโทเค็น BPE ดั้งเดิม (จากเมตาเดตา GGUF), ชุดของเชเดอร์คำนวณ GLSL 16 ตัว, ตัวสร้างกราฟคำนวณและสถาปัตยกรรม และลูปการส่งผ่านไปข้างหน้าสำหรับการถอดรหัส

เชเดอร์ของ AMD ถูกเขียนขึ้นมาโดยเฉพาะสำหรับสถาปัตยกรรม RDNAโดยใช้ wave64, cooperative matrix และรูปแบบการจัดเรียงภาพแบบไทล์ที่ปรับให้เข้ากับลำดับชั้นของหน่วยความจำและหน่วยประมวลผลของสถาปัตยกรรมนี้ ซึ่งแตกต่างจากโซลูชันทั่วไปที่ใช้เชเดอร์เดียวกันสำหรับทุกอย่าง ส่งผลให้ประสิทธิภาพต่ำกว่าศักยภาพของกราฟิกการ์ดมาก

ใน Apple Silicon เส้นทางเหล่านี้ได้รับการสนับสนุนโดยเคอร์เนล MSL ดั้งเดิมที่ใช้ประโยชน์จากการดำเนินการ simdgroup และการเข้าถึงโดยตรงไปยังโมเดลที่แมปไว้ในหน่วยความจำรวม ลดการคัดลอกให้น้อยที่สุด และใช้ประโยชน์จากลักษณะการทำงานแบบบูรณาการของชิป การปรับปรุงประสิทธิภาพของเส้นทางนี้ยังล้าหลังกว่า RDNA4 เล็กน้อย แต่กำลังได้รับการพัฒนาอย่างต่อเนื่อง

กราฟการคำนวณที่ Zinc สร้างขึ้นสำหรับโมเดลที่ซับซ้อนอย่าง Qwen3.5 35B-A3B-UD อาจมีโหนดมากกว่า 700 โหนด รวมถึงเลเยอร์ MoE (Mixture of Experts), SSM และการฉายภาพคำศัพท์ กราฟทั้งหมดนี้กำลังมุ่งไปสู่กลยุทธ์ที่การถอดรหัสจะถูกบันทึกเป็นคำสั่ง Vulkan เดียวต่อโทเค็น ซึ่งจะช่วยลดการเดินทางไปมาระหว่าง GPU และ CPU จำนวน 120 ครั้งต่อโทเค็นที่ปัจจุบันส่งผลเสียต่อประสิทธิภาพ

นอกจากแกนประมวลผลการอนุมานแล้ว Zinc ยังมีเซิร์ฟเวอร์ HTTP ในตัวพร้อม API ที่เข้ากันได้กับ OpenAI ภายใต้ /v1 รวมถึงอินเทอร์เฟซแชทบนเว็บเบราว์เซอร์ที่ให้บริการจาก / API รองรับการสตรีมโทเค็น และมีเอนด์พอยต์ตรวจสอบสถานะที่ /health สำหรับการผสานรวมกับระบบจัดการและระบบตรวจสอบต่างๆ

ติดตั้งส่วนประกอบที่จำเป็นและคอมไพล์ Zinc

ในการใช้งาน Zinc คุณไม่จำเป็นต้องใช้เครื่องมือภายนอกมากนักโดยเฉพาะอย่างยิ่งหากคุณใช้ macOS ที่มี Apple Silicon ในสภาพแวดล้อมนั้น เพียงแค่ติดตั้ง Zig (เวอร์ชัน 0.15.2 หรือสูงกว่า) และเครื่องมือบรรทัดคำสั่ง Xcode โดยใช้คำสั่ง `xcode-select --install` Vulkan, glslc, Python และ MLX ไม่จำเป็น เนื่องจากกระบวนการทั้งหมดอาศัย Metal และระบบสร้างของ Zig เพียงอย่างเดียว

บนระบบ Linux ที่ใช้การ์ดจอ AMD การตั้งค่าก็ง่ายดายเช่นกันแนะนำให้ทำการอัปเดตแพ็กเกจด้วยคำสั่ง `apt update` และติดตั้ง `libvulkan-dev`, `vulkan-tools` และ `glslc` รวมถึง `git` เพื่อโคลน repository ต้องดาวน์โหลด Zig เวอร์ชัน 0.15.2 ขึ้นไปจากเว็บไซต์ทางการและเพิ่มลงใน PATH เพื่อให้สามารถเรียกใช้ `zig build` ได้โดยไม่มีปัญหา

เมื่อติดตั้งส่วนประกอบที่จำเป็นแล้ว ขั้นตอนการสร้างจะเหมือนกันทั้งสองแพลตฟอร์ม: โคลนที่เก็บ GitHub อย่างเป็นทางการด้วยคำสั่ง `git clone https://github.com/zolotukhin/zinc.git` ไปยังไดเร็กทอรี และเรียกใช้คำสั่ง `zig build -Doptimize=ReleaseFast` ตัวเลือก `ReleaseFast` มีความสำคัญเพื่อให้ได้ไบนารีที่ได้รับการปรับแต่งอย่างเหมาะสมและหลีกเลี่ยงการวัดประสิทธิภาพที่อาจทำให้เข้าใจผิด

ไฟล์ไบนารีที่ได้จะถูกบันทึกไว้ใน ./zig-out/bin/ zinc บนระบบ Linux กระบวนการสร้างจะคอมไพล์เชเดอร์ GLSL เป็น SPIR-V และวางไว้ใน zig-out/share/zinc/shaders/ ด้วยเช่นกัน แต่บน macOS เชเดอร์ Metal จะถูกคอมไพล์ในระหว่างการทำงานจากโค้ด MSL ที่รวมอยู่ในโปรเจ็กต์

สิ่งสำคัญที่ควรทราบในรายละเอียดสำคัญอย่างหนึ่งของ Linux RDNA4คือ glslc เวอร์ชันใหม่บางเวอร์ชันอาจทำให้ประสิทธิภาพในการคอมไพล์เชเดอร์ลดลงอย่างมาก โครงการแนะนำให้ใช้ glslc เวอร์ชันที่มีอยู่ในที่เก็บของระบบแทนที่จะใช้เวอร์ชันใหม่ที่ได้มาจากแหล่งอื่น

การตรวจสอบเบื้องต้นและขั้นตอนแรกกับสังกะสี

ก่อนที่จะแสดงข้อความแจ้งเตือนใดๆ ขอแนะนำให้ทำการตรวจสอบเบื้องต้นด้วยคำสั่ง `./zig-out/bin/zinc –check` คำสั่งนี้จะตรวจสอบว่าสภาพแวดล้อมโฮสต์ GPU และสินทรัพย์ที่จำเป็นอยู่ในสภาพเรียบร้อย และไม่มีเชเดอร์ ความสามารถ Vulkan/Metal หรือเมตาเดต้าของโมเดลใดๆ ขาดหายไป

ในเครื่องที่ใช้ RDNA4 การส่งออกตัวแปร RADV_PERFTEST=coop_matrix ก่อนเริ่มเซสชันการตรวจสอบและการอนุมานนั้นมีประโยชน์อย่างยิ่งจากนั้นจึงเรียกใช้ ./zig-out/bin/zinc –check อีกครั้ง เป้าหมายคือการยืนยันว่า GPU ถูกตรวจพบอย่างถูกต้อง การเพิ่มประสิทธิภาพเมทริกซ์แบบร่วมมือกันทำงานอยู่ และไม่มีคำเตือนที่สำคัญเกิดขึ้น

หากการตรวจสอบเสร็จสิ้นโดยแสดงผล READY [OK]แสดงว่าสภาพแวดล้อมอยู่ในสถานะที่เหมาะสมสำหรับการทดสอบการอนุมาน หากมีคำเตือนปรากฏขึ้น ขอแนะนำให้แก้ไขปัญหาเหล่านั้นก่อน (เช่น ไดรเวอร์ เวอร์ชัน Vulkan เชเดอร์ที่ยังไม่ได้คอมไพล์ หน่วยความจำ VRAM ไม่เพียงพอสำหรับโมเดลที่เลือก ฯลฯ) ก่อนที่จะตัดสินประสิทธิภาพหรือความเสถียรของเอนจิน

การตรวจสอบนี้ยังตรวจสอบความถูกต้องของแง่มุมต่างๆ เช่นการค้นหาอุปกรณ์ Vulkan การเลือก GPU ที่ใช้งานอยู่ ความเข้ากันได้ของโมเดลที่จัดการเมื่อส่งค่า –model-id เมตาเดต้า GGUF และการประเมินว่าโมเดลนั้นเหมาะสมกับ VRAM ที่มีอยู่บน GPU ที่เลือกหรือไม่

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

แคตตาล็อกของโมเดล การดาวน์โหลดและการจัดการ

Zinc มีระบบจัดการโมเดลที่ตรวจจับโปรไฟล์ GPU (เช่น amd-rdna4-32gb หรือ apple-silicon) และแสดงโมเดลที่ผ่านการตรวจสอบแล้วซึ่งตรงกับหน่วยความจำและความจุที่ต้องการมากที่สุด คำสั่ง `./zig-out/bin/zinc model list` ใช้สำหรับเรียกดูแคตตาล็อกนี้

ในการดาวน์โหลดโมเดล จะใช้คำสั่ง `model pull`ตัวอย่างเช่น `./zig-out/bin/zinc model pull qwen35-2b-q4k-m` คำสั่งนี้จะดาวน์โหลดไฟล์ GGUF ที่ตรงกับโมเดล Qwen3.5 2B ที่มีการควอนไทเซชัน Q4_K_M และบันทึกไว้ในแคชภายในเครื่อง พร้อมทั้งตรวจสอบความถูกต้องของไฟล์ดาวน์โหลดด้วยแฮช SHA-256

เมื่อดาวน์โหลดเสร็จแล้ว คุณสามารถตั้งค่าโมเดลเริ่มต้นสำหรับการใช้งานครั้งต่อไปได้ด้วยคำสั่ง `./zig-out/bin/zinc model use qwen35-2b-q4k-m` และตรวจสอบว่าโมเดลใดกำลังใช้งานอยู่ด้วยคำสั่ง `./zig-out/bin/zinc model active` ด้วยวิธีนี้ การเรียกใช้งานในครั้งต่อๆ ไปจึงไม่จำเป็นต้องระบุ `--model-id` อย่างชัดเจนอีกต่อไป

เมื่อคุณไม่ต้องการใช้งานโมเดลอีกต่อไป คุณสามารถลบออกจากแคชได้ด้วยคำสั่ง ./zig-out/bin/zinc model rm qwen35-2b-q4k-m ซึ่งจะช่วยจัดการพื้นที่ดิสก์หากคุณทดลองใช้เวอร์ชันการควอนไทเซชันหลายเวอร์ชันหรือโมเดลทางเลือกอื่นๆ

แคตตาล็อกนี้ถูกจำกัดขอบเขตไว้โดยเจตนาโดยเน้นที่โมเดลที่ทีมงานโครงการได้ตรวจสอบความถูกต้องครบถ้วนแล้ว มากกว่าที่จะรับประกันความเข้ากันได้ทางทฤษฎีกับ GGUF หลายร้อยแบบ สำหรับรายละเอียดเพิ่มเติมเกี่ยวกับขั้นตอนการทำงานของโมเดลและตัวเลือกการแคช โปรดดูเอกสารประกอบ Zinc บนเว็บโดยเฉพาะ

การอนุมาน CLI, เซิร์ฟเวอร์ HTTP และแชทบนเว็บ

วิธีที่ตรงไปตรงมาที่สุดในการทดสอบ Zinc คือการใช้ Command-Line Interface (CLI)เมื่อคอมไพล์ไบนารีเสร็จแล้ว ดาวน์โหลดโมเดลเสร็จ และตรวจสอบผ่านแล้ว คุณสามารถทำการทดสอบเบื้องต้นง่ายๆ ด้วยคำสั่งเช่น `./zig-out/bin/zinc --model-id qwen35-2b-q4k-m --prompt "The capital of France is"` บน Linux RDNA4 อย่าลืมเปิดใช้งาน `export RADV_PERFTEST=coop_matrix` เพื่อใช้ประโยชน์จากเมทริกซ์แบบร่วมมือกัน

หากทุกอย่างได้รับการตั้งค่าอย่างถูกต้อง บันทึกควรแสดงข้อความจากตัวโหลดโมเดล การเสร็จสิ้นการเติมข้อมูลเบื้องต้น และจำนวนโทเค็นที่สร้างขึ้นพร้อมกับอัตราในหน่วยโทเค็นต่อวินาที โดยจบลงด้วยข้อความเอาต์พุตที่เข้าใจได้ ซึ่งโดยทั่วไปจะเป็นคำว่า “Paris” ในตัวอย่างข้างต้น การเห็นลำดับนี้แสดงว่าเส้นทางการอนุมานหลักทำงานได้แล้ว

นอกเหนือจากโหมด CLI บริสุทธิ์แล้ว Zinc ยังมีโหมดเซิร์ฟเวอร์ที่สามารถเข้าถึงได้ด้วย `./zig-out/bin/zinc chat` ซึ่งจะเริ่มเซิร์ฟเวอร์ HTTP (โดยค่าเริ่มต้นที่พอร์ต 9090) และเปิดอินเทอร์เฟซแชทในตัวในเบราว์เซอร์ของคุณ จากนั้นคุณสามารถโต้ตอบกับโมเดลในลักษณะที่คล้ายกับการแชทออนไลน์ รวมถึงการรองรับโหมด "การให้เหตุผล" ที่ยาวขึ้นด้วย

นอกจากนี้ ยังสามารถเรียกใช้งานเซิร์ฟเวอร์ด้วยตนเองได้โดยใช้คำสั่ง `./zig-out/bin/zinc --model-id qwen35-2b-q4k-m -p 8080` ซึ่งจะช่วยให้คุณเลือกพอร์ตที่เหมาะสมกับความต้องการของคุณได้ จากนั้น เพียงเปิด `http://localhost:8080/` ในเบราว์เซอร์ของคุณเพื่อเข้าถึงอินเทอร์เฟซแชทเดียวกันกับที่สร้างไว้ในไบนารี

Zinc มี API HTTP ที่เปิดเผยซึ่งรองรับ OpenAIภายใต้เส้นทาง /v1 ทำให้คุณสามารถชี้ไคลเอ็นต์หรือ SDK ที่ทำงานร่วมกับ API ของ OpenAI อยู่แล้วไปยังอินสแตนซ์ Zinc ของคุณได้โดยตรง นอกจากนี้ยังมีเอนด์พอยต์ /health สำหรับตรวจสอบสถานะในสภาพแวดล้อมการใช้งานจริงหรือสภาพแวดล้อมที่มีการจัดการ

ข้อจำกัดและแผนงานปัจจุบัน

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

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

ทีมพัฒนาได้ทำงานในหลายด้านสำคัญเพื่อเปลี่ยนจากการ "ถอดรหัสข้อมูลดิบที่ความเร็วมากกว่า 30 โทเค็นต่อวินาที" ไปสู่การรองรับเวิร์กโหลดการให้เหตุผลที่ยาวนานขึ้น ในขณะที่ยังคงรักษาความเร็วและปรับปรุงการใช้งาน GPU โดยรวมให้ดีขึ้น ซึ่งรวมถึงการเชื่อมช่องว่างระหว่าง /v1/completions และ /v1/chat/completions ที่เทมเพลตแชทและเวลาในการส่งโทเค็นแรก (TTFT) เพิ่มภาระเพิ่มเติม

อีกด้านหนึ่งที่กำลังได้รับการพัฒนาอย่างต่อเนื่องคือการลดการเปลี่ยนแปลงตัวอธิบาย (descriptor churn) ในส่วนที่มีการใช้งานบ่อยของ Vulkan: แนวคิดคือการนำการเชื่อมโยง (bindings) กลับมาใช้ใหม่และลดปริมาณงานต่อโทเค็นในลูปการถอดรหัสให้น้อยที่สุด เพื่อให้เวลาการใช้งาน CPU และความหน่วงแฝงต่อการทำงานของ Vulkan อยู่ในระดับต่ำที่สุดเท่าที่จะเป็นไปได้

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

สำหรับผู้ที่ต้องการศึกษาโค้ดให้ลึกซึ้งยิ่งขึ้นก็มีพื้นฐานที่จัดการได้ค่อนข้างง่าย: โค้ด Zig ประมาณ 5.000 บรรทัด และ GLSL ประมาณ 2.000 บรรทัด พร้อมด้วยเชเดอร์ MSL สำหรับ Apple เครื่องมือวิเคราะห์ประสิทธิภาพ (--profile ซึ่งยังอยู่ระหว่างการปรับปรุงเพื่อไม่ให้การวัดผิดเพี้ยน) และคู่มือการพัฒนาโดยละเอียดในเอกสารบนเว็บ

โดยรวมแล้ว Zinc นำเสนอภาพที่น่าสนใจสำหรับผู้ที่มี GPU AMD หรือระบบ Apple Silicon รุ่นใหม่ ที่ต้องการใช้ประโยชน์จากฮาร์ดแวร์ของตนอย่างแท้จริงสำหรับการประมวลผล LLM ในเครื่อง โดยไม่ต้องพึ่งพา ROCm, CUDA หรือรันไทม์ Python ขนาดใหญ่ การผสมผสานระหว่าง Zig, Vulkan และ Metal พร้อมด้วยชุดเชเดอร์ที่ปรับแต่งให้เหมาะกับสถาปัตยกรรมแต่ละแบบ ทำให้ Zinc เป็นตัวเลือกที่น่าสนใจหากคุณสนใจในการตั้งค่าสภาพแวดล้อมการอนุมานที่มีประสิทธิภาพบนเครื่องของคุณเอง ไม่ว่าจะเป็นเพื่อการทดลอง การให้บริการ API ที่เข้ากันได้กับ OpenAI หรือการทำความเข้าใจอย่างลึกซึ้งเกี่ยวกับวิธีการสร้างเอ็นจิ้นการอนุมานระดับต่ำ