เปิดตัว LiteRT Tensor API สร้าง AI โมเดลแบบ Native บน Edge

19 ต.ค. 2026

การส่งมอบ AI บนอุปกรณ์ (On-device AI) ต้องเผชิญกับข้อจำกัดด้านความหน่วง (latency) และหน่วยความจำที่เข้มงวด ปกติแล้วนักพัฒนามักใช้วิธีแปลงโมเดลที่ฝึกสอนมาแล้ว เช่น การแปลงโมเดล PyTorch ด้วย LiteRT Torch และรันผ่าน LiteRT runtime ซึ่งเป็นวิธีที่รวดเร็วและแนะนำสำหรับโครงการทั่วไป

อย่างไรก็ตาม ในบางกรณีนักพัฒนาต้องการการควบคุมอย่างเต็มที่เพื่อรองรับสถาปัตยกรรมใหม่ๆ หรือทดลองตรรกะ lowering แบบใหม่โดยไม่ต้องรอการอัปเดตเฟรมเวิร์ก เพื่อการควบคุมสูงสุดนี้ นักพัฒนาจึงต้องเขียนการคำนวณด้วยภาษา C++ ดั้งเดิมหรือภาษา shader ซึ่งแม้แนวทาง code-first นี้จะได้รับความนิยมผ่าน Apple's MLX หรือ llama.cpp แต่ก็แลกมาด้วยต้นทุนที่สูง เพราะการพัฒนาจะผูกติดกับ backend เฉพาะ (เช่น Metal หรือ Vulkan) และต้องเขียนใหม่ทุกครั้งเมื่อเปลี่ยนฮาร์ดแวร์ เพื่อแก้ปัญหานี้ เราขอแนะนำ LiteRT Tensor API เลเยอร์สร้างโมเดลน้ำหนักเบาใน LiteRT stack ที่รวมความยืดหยุ่นของการสร้างโมเดลแบบ native เข้ากับความสามารถในการใช้งานข้ามแพลตฟอร์ม คุณสามารถสร้างกราฟการคำนวณทีละ op ใน C++ และรันผ่าน CPU, GPU (ขับเคลื่อนโดย ML Drift) หรือ NPU ได้ทันทีโดยไม่ต้องเขียนโค้ดใหม่

จุดเด่นสำคัญคือการเชื่อมต่อการประมวลผลก่อน/หลังการอนุมานผ่าน API เดียวกันและใช้บัฟเฟอร์ตัวเร่งความเร็วร่วมกัน ทำให้ข้อมูลไม่จำเป็นต้องเดินทางไป-กลับผ่าน CPU ช่วยเพิ่มประสิทธิภาพการทำงานแบบ end-to-end นอกจากนี้ LiteRT Tensor API ยังทำหน้าที่เป็นรากฐานทางโปรแกรมที่เหมาะสำหรับ AI coding agents ในการสร้างและปรับแต่งกราฟโมเดลโดยอัตโนมัติอีกด้วย เพื่อให้เห็นภาพการใช้งาน เราได้พัฒนาแอป Segment Anything App ที่รันบนเบราว์เซอร์ผ่าน WebGPU โดยใช้โมเดล Segment Anything Model 2 (SAM 2) ของ Meta และ Gemma 4 E2B ซึ่งช่วยให้ติดตามวัตถุได้แบบเรียลไทม์

โมเดล SAM 2 นี้ถูกเขียนขึ้นด้วย C++ ผ่าน LiteRT Tensor API ทั้งหมด โดยมี AI coding agent ช่วยพัฒนาจนความเร็วเพิ่มจากไม่ถึง 10 FPS เป็นมากกว่า 30 FPS บน WebGPU ผู้สนใจสามารถดูตัวอย่างโค้ดได้ที่ LiteRT Samples

LiteRT Tensor API มีคุณสมบัติหลัก 4 ประการ:

• การควบคุมโครงสร้างกราฟอย่างเต็มรูปแบบ: กำหนดทุก op และการเชื่อมต่อได้เอง ตั้งแต่คณิตศาสตร์พื้นฐานไปจนถึงเลเยอร์ซับซ้อนของ LLM
• การนำเข้า weight โดยตรง: โหลด weight จากไฟล์ .safetensors ได้ทันทีโดยไม่ต้องใช้สคริปต์แปลงไฟล์
• การทำงานร่วมกันของบัฟเฟอร์เน้น Tensor: ข้อมูลระหว่างขั้นตอนจะอยู่บนตัวเร่งความเร็วตลอดเวลาแบบ zero copies
• ส่วนประกอบพื้นฐานสำหรับ AI agents: เปิดโอกาสให้เอเจนต์สร้างและทดสอบประสิทธิภาพของโมเดลในแต่ละอุปกรณ์ได้โดยอัตโนมัติ

จากการทดสอบรันโมเดล SAM 2 บน GPU ของอุปกรณ์ต่างๆ พบว่าบน MacBook Pro สามารถทำงานได้เร็วกว่า Apple MLX ประมาณ 1.5 เท่า โดยความแม่นยำของมาสก์ที่ได้นั้นตรงกับข้อมูลอ้างอิง PyTorch ของ Meta แบบพิกเซลต่อพิกเซล ดูรายละเอียดผลทดสอบได้ที่ ตัวอย่าง SAM 2.1

ในด้านการเขียนโปรแกรม แต่ละเลเยอร์คือฟังก์ชัน C++ เหนือค่า Tensor ตัวอย่างเช่นเลเยอร์ multi-head self-attention สามารถเขียนได้ดังนี้:

// Multi-head self-attention over x: [batch, tokens, dim].
Tensor Attention(const Tensor& x, const WeightMap& w, int heads) {
std::vector<int> s = x.GetShape();
int b = s[0], n = s[1], dim = s[2], d = dim / heads;
Tensor q = FullyConnected(x, w.at("q_proj.weight"), w.at("q_proj.bias"));
Tensor k = FullyConnected(x, w.at("k_proj.weight"), w.at("k_proj.bias"));
Tensor v = FullyConnected(x, w.at("v_proj.weight"), w.at("v_proj.bias"));
// Split heads: [b, n, dim] -> [b, heads, n, d].
q = Transpose(Reshape(q, {b, n, heads, d}), {0, 2, 1, 3});
k = Transpose(Reshape(k, {b, n, heads, d}), {0, 2, 1, 3});
v = Transpose(Reshape(v, {b, n, heads, d}), {0, 2, 1, 3});
// softmax(q * k^T / sqrt(d)) * v, for all heads at once.
Tensor scores = BatchMatMul(q, k, /*adj_x=*/false, /*adj_y=*/true);
Tensor attn = Softmax(Mul(scores, 1.0f / std::sqrt(static_cast<float>(d))));
Tensor out = BatchMatMul(attn, v);
// Merge heads: [b, heads, n, d] -> [b, n, dim], then project.
out = Reshape(Transpose(out, {0, 2, 1, 3}), {b, n, dim});
return FullyConnected(out, w.at("out_proj.weight"), w.at("out_proj.bias"));
}

คุณสามารถรันกราฟผ่านไฟล์ .tflite หรือรันตรงบน CPU ผ่าน XNNPACK ด้วยโค้ดชุดเดียวกัน ดังตัวอย่าง:

// Tag tensors for both backends; ops record one graph either can run.
using T = Tensor<TfLiteMixinTag, XnnpackMixinTag>;
T y = Attention(x, w, /*heads=*/8); // The layer above, over T values.
// Export a .tflite and run it with LiteRT on CPU, GPU, or NPU.
Save({y}, "attention.tflite");
// Or run the same graph directly on the CPU with XNNPACK.
auto runner = XnnpackRunner::Create({y});
runner->Run();

สำหรับแอป SAM 2 เราใช้เส้นทาง .tflite เพื่อรันบน WebGPU ส่วน ตัวอย่าง Gemma 4 จะรันตรงบน CPU ซึ่งให้ประสิทธิภาพสูงสุด

ความล้ำหน้าอีกประการคือการทำให้ไปป์ไลน์ทั้งหมด ตั้งแต่การประมวลผลก่อนการอนุมาน (Pre-processing) ไปจนถึงหลังการอนุมาน (Post-processing) รันอยู่บน GPU ทั้งหมดโดยไม่ต้องส่งข้อมูลกลับมาที่ CPU ซึ่งช่วยลดคอขวดได้อย่างมหาศาล:

// Pre-processing and model connection example
auto pre_runner = CreateLambdaRunner(...);
auto model = LitertDynamicRunner::Create(env, "sam2_image.tflite", options);
// Connect once: neighboring steps share buffers, so nothing is copied.
pre_runner.SetOutput("pixels", model.GetInput("encode_image", "pixels"));

นอกจากนี้ AI coding agent อย่าง Antigravity ยังเข้ามาช่วยปรับแต่งกราฟให้เป็นมิตรกับ GPU มากขึ้น เช่น การเปลี่ยนเงื่อนไขการตรวจสอบวัตถุจากการใช้คำสั่ง CPU เป็นเลขคณิตบน GPU ซึ่งช่วยเพิ่มเฟรมเรตได้กว่า 3 เท่า

ในอนาคต เรามีแผนจะพัฒนา backend สำหรับ ML Drift โดยตรง เพิ่มการรองรับ NPU และระบบ quantization อัตโนมัติ รวมถึงการสร้างโมเดลด้วย Python เพื่อการพัฒนาที่สะดวกยิ่งขึ้น

ผู้ที่สนใจสามารถเริ่มต้นศึกษาได้จาก LiteRT Tensor API guide และดูตัวอย่างการใช้งานจริงของ SAM 2 และ Gemma 3/4 ได้ที่ GitHub ของโครงการ