TurboFieldfare ทำให้โมเดลภาษาที่มีพารามิเตอร์ 26 พันล้านตัว ทำงานได้ในหน่วยความจำเพียงราว 2 GB บนเครื่อง MacBook Air ที่มี RAM ทั้งเครื่อง 8 GB

ตัวเลขชุดนี้อ่านแล้วขัดความรู้สึก เพราะไฟล์โมเดลที่ติดตั้งเสร็จแล้วกินพื้นที่ดิสก์ราว 14.3 GB ใหญ่กว่า RAM ทั้งเครื่องเกือบเท่าตัว

คนที่ทำคือ Andrey Mikhaylov วิศวกรสาย iOS และ Metal ซึ่งเป็นเทคโนโลยีที่ให้โปรแกรมสั่งงานชิปกราฟิกของ Mac ได้โดยตรง

เขาเขียนของชิ้นนี้ขึ้นมาเองด้วย Swift กับ Metal แล้วเปิดโค้ดไว้ในฐานะโปรเจกต์วิจัยส่วนตัว ไม่ได้เกี่ยวข้องกับ Google ซึ่งเป็นเจ้าของโมเดล Gemma 4 ที่มันรัน

เหตุผลที่เขาลงมือทำก็ตรงไปตรงมา คือหน่วยความจำมันแพงขึ้น เขาเลยตั้งงบไว้ที่ราว 2 GB แล้วหาทางทำให้มันทำงานได้จริงในงบเท่านั้น

สำหรับคนที่มี Mac อยู่แล้วและเคยคิดอยากลองรันโมเดลเองในเครื่อง เหตุผลเดิมที่ว่า RAM ในเครื่องไม่พอ ใช้ไม่ได้กับโมเดลตัวนี้แล้ว

TurboFieldfare เขียนมาเพื่อโมเดลตัวเดียว

TurboFieldfare ทำหน้าที่โหลดโมเดลขึ้นมาแล้วสั่งให้มันสร้างคำตอบทีละคำ งานแบบนี้เรียกว่ารันไทม์ และมีเครื่องมือกลางอย่าง llama.cpp หรือ MLX ทำอยู่ก่อนแล้ว

แต่ TurboFieldfare ไม่ได้เอาสองตัวนั้นมาเป็นฐานแล้วสร้างทับ เขาเขียนขึ้นใหม่ทั้งหมดให้เข้ากับโมเดล Gemma 4 26B-A4B ตัวเดียวเท่านั้น

ของที่ได้มามีสามทางให้ใช้ ทางแรกคือแอปบน Mac ที่มีหน้าต่างพิมพ์คำถามของตัวเอง ทางที่สองคือคำสั่งบนเทอร์มินัล สำหรับคนที่อยากสั่งงานเป็นสคริปต์

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

ทั้งสามตัวใช้โฟลเดอร์โมเดลชุดเดียวกัน แต่ควรเปิดทีละตัว เพราะแต่ละตัวจองโมเดลไว้เป็นของตัวเอง

โค้ดกับเอกสารทั้งหมดเปิดอยู่ที่ drumih/turbo-fieldfare บน GitHub ภายใต้ Apache License 2.0

ส่วนไฟล์โมเดลไม่ได้อยู่ในนั้น ตัวติดตั้งจะไปดึงมาจาก Hugging Face ให้เอง โดยยึดกับเวอร์ชันที่ปักหมุดไว้ และไฟล์ชุดนั้นยังอยู่ใต้เงื่อนไขการใช้งานของ Gemma เอง

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

26 พันล้านพารามิเตอร์ แต่หนึ่งคำใช้จริงราว 3.88 พันล้าน

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

ตัวเลข 26 พันล้านคือจำนวนค่าที่โมเดลเก็บไว้ข้างใน และมันคือเหตุผลที่ไฟล์ใหญ่ถึง 14.3 GB

แต่ Gemma 4 26B-A4B ไม่ได้เป็นก้อนตัน ข้างในมันซอยเป็นชิ้นส่วนย่อยจำนวนมาก

เวลาสร้างคำออกมาหนึ่งคำ มันไม่ได้ใช้ทุกชิ้น เพราะมีตัวคัดอยู่ข้างในคอยเลือกว่าคำนี้ต้องใช้ชิ้นไหน แล้วเรียกใช้แค่นั้น

พอนับดู จาก 26 พันล้าน เหลือส่วนที่ทำงานจริงต่อหนึ่งคำราว 3.88 พันล้าน หรือประมาณหนึ่งในเจ็ด

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

TurboFieldfare ทำแบบเดียวกันกับไฟล์ 14.3 GB มันเก็บแกนกลางที่ทุกคำต้องใช้ร่วมกันขนาด 1.35 GB ไว้ใน RAM พร้อมกับ KV cache ที่คอยจำเนื้อหาที่คุยกันมาแล้วในรอบนั้น

ส่วนชิ้นที่เหลือยังนอนอยู่บน SSD แล้วค่อยอ่านขึ้นมาเฉพาะชิ้นที่คำนั้นเรียกใช้ ของที่ค้างอยู่ใน RAM จริงๆ จึงรวมกันได้ราว 2 GB

การวิ่งไปอ่านดิสก์ทุกคำฟังดูช้า ตัวรันไทม์เลยกันช่องไว้ให้โมเดลแต่ละชั้น ชั้นละ 16 ช่อง สำหรับพักชิ้นที่เรียกใช้บ่อยเอาไว้ก่อน

ชิ้นไหนอยู่ในช่องแล้วก็ไม่ต้องอ่านซ้ำ ส่วนชิ้นที่ยังไม่มีก็สั่งอ่านขึ้นมาพร้อมกันทีละหลายชิ้น แล้วให้ชิปกราฟิกคำนวณส่วนแกนกลางไปพลางๆ ระหว่างที่รออ่าน

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

เร็วแค่ไหนบน MacBook Air 8 GB ต้องบอกกันตรงๆ

ตัวเลขที่วัดได้บน MacBook Air ชิป M2 ที่มี RAM 8 GB อยู่ที่ 5.1 ถึง 6.3 คำในหนึ่งวินาที และเครื่องรุ่นนี้คือเป้าหมายหลักที่โปรเจกต์ใช้ทดสอบ

พอย้ายไปเครื่องแรงขึ้นอย่าง M5 Pro ที่มี RAM 24 GB ตัวเลขขยับไปที่ 31 ถึง 35 คำต่อวินาที

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

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

เบื้องหลังของมันคือบันทึกการทดลองที่โปรเจกต์รวบรวมไว้ 103 ผลลัพธ์ ตั้งแต่เรื่องการอ่านดิสก์ การพักชิ้นส่วนไว้ในช่อง ไปจนถึงขั้นตอนสร้างคำตอบ

อยากลอง TurboFieldfare ต้องมีอะไรบ้าง

ข้อแรกตัดคนออกไปก่อนเลย คือเครื่องต้องเป็น Mac ที่ใช้ชิป Apple เท่านั้น เครื่อง Intel ใช้ไม่ได้

ถัดมาคือฝั่งระบบ ต้องเป็น macOS 26 ที่มี Metal 4 ส่วนใครจะสร้างโปรแกรมขึ้นมาเองจากโค้ดก็ต้องมี Xcode 26 กับ Swift 6.2 ขึ้นไป

แล้วก็ต้องมีพื้นที่ว่างในเครื่องราว 14.3 GB สำหรับโมเดลที่ติดตั้งเสร็จ กับอินเทอร์เน็ตสำหรับการโหลดครั้งแรกอีกราว 15 GB ซึ่งกินเวลาพอสมควร

จุดเริ่มต้นจริงๆ คือสี่บรรทัดนี้

git clone https://github.com/drumih/turbo-fieldfare.git
cd turbo-fieldfare
swift build -c release
.build/release/TurboFieldfareMac

พอแอปเปิดขึ้นมา มันจะเช็กที่ว่างในเครื่องแล้วบอกทั้งขนาดที่ต้องโหลดและขนาดหลังติดตั้ง เลือก Download เพื่อเริ่ม พอเสร็จก็เลือก Load Model พิมพ์คำถามลงช่อง แล้วกด Generate

ตัวติดตั้งเองก็ทำต่างจากที่คุ้นกัน มันไม่ได้โหลดไฟล์ต้นทางลงมาทั้งก้อนก่อนแล้วค่อยแปลง แต่ขอข้อมูลเป็นช่วงๆ จาก Hugging Face แล้วจัดลงรูปแบบของตัวเองตั้งแต่ระหว่างที่ข้อมูลทยอยมาถึง

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

ข้อจำกัดที่ต้องรู้ก่อนลง 15 GB

ตอนนี้มันทำงานกับข้อความล้วนเท่านั้น ส่วนรูป เสียง และวิดีโอ ยังไม่รองรับ

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

เซิร์ฟเวอร์ตัวนั้นยังอยู่ในสถานะทดลอง มันเปิดรออยู่ที่ http://127.0.0.1:8080/v1 ซึ่งเป็นที่อยู่ภายในเครื่องตัวเอง และไม่มีระบบยืนยันตัวตนหรือการเข้ารหัสสำหรับการเชื่อมจากข้างนอก เอกสารจึงบอกให้เปิดไว้เฉพาะในเครื่องเท่านั้น

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

และข้อที่ต้องย้ำ คือมันรันได้แค่โมเดลตัวเดียว ถ้าอยากลองโมเดลอื่นก็ต้องกลับไปใช้เครื่องมือกลางอยู่ดี

ใครได้ประโยชน์จากมันจริง

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

อีกกลุ่มคือคนที่มีข้อมูลซึ่งส่งออกไปข้างนอกไม่ได้ ทั้งร่างสัญญา ข้อมูลลูกค้า หรือเอกสารภายใน

ที่ผ่านมางานพวกนี้ติดอยู่ตรงที่ว่าจะให้ AI ช่วยอ่านสักที ก็ต้องอัปโหลดไฟล์ขึ้นไปก่อน

ข้อควรระวังคือคำว่ารันบนเครื่องตัวเองไม่ได้แปลว่าปิดตายจากข้างนอกโดยอัตโนมัติ เหมือนกรณีของ Rowboat ที่ชูคำว่า local-first แต่คำนั้นการันตีแค่ว่าข้อมูลอยู่บนเครื่อง ไม่ได้แปลว่าไม่มีอะไรออกไปข้างนอก

ส่วน TurboFieldfare นั้น คำตอบทุกคำเกิดขึ้นบนเครื่องเรา มีแค่ตอนโหลดโมเดลรอบแรกเท่านั้นที่ต้องต่อเน็ต

โมเดลไม่ได้เล็กลงเลยสักนิด ไฟล์ยังหนัก 14.3 GB เท่าเดิม สิ่งที่เปลี่ยนคือมีคนเลิกยอมรับกติกาที่ว่าต้องยกมันขึ้น RAM ทั้งก้อนพร้อมกัน

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

ที่มา: โปรเจกต์ drumih/turbo-fieldfare บน GitHub