LiteRT สำหรับ Android

LiteRT ช่วยให้คุณเรียกใช้โมเดล TensorFlow, PyTorch และ JAX ในแอป Android ได้ ระบบ LiteRT มีสภาพแวดล้อมการดำเนินการที่สร้างไว้ล่วงหน้าและปรับแต่งได้สำหรับ การเรียกใช้โมเดลใน Android อย่างรวดเร็วและมีประสิทธิภาพ รวมถึงตัวเลือกสำหรับ การเร่งด้วยฮาร์ดแวร์

เช่น แอปพลิเคชัน Android ที่ใช้ LiteRT โปรดดูที่ที่เก็บตัวอย่าง LiteRT

โมเดลแมชชีนเลิร์นนิง

LiteRT ใช้โมเดล TensorFlow, PyTorch และ JAX ที่แปลงเป็นรูปแบบโมเดลแมชชีนเลิร์นนิงที่มีขนาดเล็กลง พกพาสะดวก และมีประสิทธิภาพมากขึ้น คุณสามารถใช้ โมเดลที่สร้างไว้ล่วงหน้ากับ LiteRT ใน Android หรือสร้างโมเดลของคุณเองและแปลง เป็นรูปแบบ LiteRT

หน้านี้จะอธิบายการใช้โมเดลแมชชีนเลิร์นนิงที่สร้างไว้แล้ว และไม่ได้กล่าวถึงการสร้าง การฝึก การทดสอบ หรือการแปลงโมเดล ดูข้อมูลเพิ่มเติมเกี่ยวกับ การเลือก การแก้ไข การสร้าง และการแปลงโมเดลแมชชีนเลิร์นนิงสําหรับ LiteRT ในหน้าโมเดล

เรียกใช้โมเดลบน Android

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

รูปที่ 1 โฟลว์การดำเนินการที่ใช้งานได้สำหรับโมเดล LiteRT ในแอป Android

ที่ระดับการออกแบบฟังก์ชัน แอป Android ของคุณต้องมีองค์ประกอบต่อไปนี้เพื่อ เรียกใช้โมเดล LiteRT

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

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

สร้างแอปด้วย LiteRT

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

ตัวเลือกสภาพแวดล้อมรันไทม์

คุณเปิดใช้สภาพแวดล้อมรันไทม์เพื่อเรียกใช้โมเดลในแอป Android ได้หลายวิธี ซึ่งตัวเลือกที่แนะนำมีดังนี้

• LiteRT ในสภาพแวดล้อมรันไทม์ของบริการ Google Play (แนะนำ)
• สภาพแวดล้อมรันไทม์ LiteRT แบบสแตนด์อโลน

โดยทั่วไป คุณควรใช้สภาพแวดล้อมรันไทม์ที่ Google Play services จัดเตรียมให้ เนื่องจากมีประสิทธิภาพด้านพื้นที่มากกว่าสภาพแวดล้อมมาตรฐานเพราะ โหลดแบบไดนามิก ทำให้แอปมีขนาดเล็กลง นอกจากนี้ บริการ Google Play ยังใช้รันไทม์ LiteRT เวอร์ชันล่าสุดที่มีความเสถียรโดยอัตโนมัติ ซึ่งจะช่วยให้คุณมีฟีเจอร์เพิ่มเติมและประสิทธิภาพที่ดีขึ้นเมื่อเวลาผ่านไป หากคุณให้บริการแอปในอุปกรณ์ที่ไม่มีบริการ Google Play หรือต้องการจัดการสภาพแวดล้อมรันไทม์ ML อย่างใกล้ชิด คุณควรใช้รันไทม์ LiteRT มาตรฐาน ตัวเลือกนี้จะรวมโค้ดเพิ่มเติมไว้ในแอป ซึ่งช่วยให้คุณควบคุมรันไทม์ ML ในแอปได้มากขึ้น แต่จะทำให้ขนาดการดาวน์โหลดของแอปเพิ่มขึ้น

คุณเข้าถึงสภาพแวดล้อมรันไทม์เหล่านี้ในแอป Android ได้โดยการเพิ่มไลบรารีการพัฒนา LiteRT ลงในสภาพแวดล้อมการพัฒนาแอป ดูข้อมูลเกี่ยวกับ วิธีใช้สภาพแวดล้อมรันไทม์มาตรฐานในแอปได้ที่ส่วนถัดไป

ห้องสมุด

คุณเข้าถึง Interpreter API ได้โดยใช้ Google Play services คุณใช้ไลบรารี LiteRT core และsupport ในแอป Android ได้ ดูรายละเอียดการเขียนโปรแกรมเกี่ยวกับการใช้ไลบรารีและสภาพแวดล้อมรันไทม์ของ LiteRT ได้ที่เครื่องมือพัฒนาสำหรับ Android

รับโมเดล

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

จัดการข้อมูลอินพุต

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

เรียกใช้การอนุมาน

การประมวลผลข้อมูลผ่านโมเดลเพื่อสร้างผลการคาดการณ์เรียกว่าการอนุมาน การเรียกใช้การอนุมานในแอป Android ต้องใช้สภาพแวดล้อมรันไทม์ LiteRT โมเดล และข้อมูล อินพุต

ความเร็วที่โมเดลสร้างการอนุมานในอุปกรณ์หนึ่งๆ ขึ้นอยู่กับขนาดของข้อมูลที่ประมวลผล ความซับซ้อนของโมเดล และ ทรัพยากรการประมวลผลที่มีอยู่ เช่น หน่วยความจำและ CPU หรือโปรเซสเซอร์เฉพาะทาง ที่เรียกว่าตัวเร่ง โมเดลแมชชีนเลิร์นนิงสามารถทำงานได้เร็วขึ้นในโปรเซสเซอร์เฉพาะทางเหล่านี้ เช่น หน่วยประมวลผลกราฟิก (GPU) และหน่วยประมวลผล Tensor (TPU) โดยใช้ไดรเวอร์ฮาร์ดแวร์ LiteRT ที่เรียกว่าDelegates ดูข้อมูลเพิ่มเติมเกี่ยวกับตัวแทนและการเร่งฮาร์ดแวร์ของ การประมวลผลโมเดลได้ที่ภาพรวมการเร่งฮาร์ดแวร์

จัดการผลลัพธ์เอาต์พุต

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

เส้นทางการพัฒนาขั้นสูง

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

สภาพแวดล้อมรันไทม์ขั้นสูง

นอกจากสภาพแวดล้อมรันไทม์มาตรฐานและรันไทม์ของบริการ Google Play สำหรับ LiteRT แล้ว ยังมีสภาพแวดล้อมรันไทม์เพิ่มเติมที่คุณใช้กับแอป Android ได้ โดยสภาพแวดล้อมเหล่านี้มักใช้ในกรณีที่คุณมีโมเดลแมชชีนเลิร์นนิงที่ใช้การดำเนินการ ML ที่สภาพแวดล้อมรันไทม์มาตรฐานสำหรับ LiteRT ไม่รองรับ

• รันไทม์ Flex สำหรับ LiteRT
• รันไทม์ LiteRT ที่สร้างขึ้นเอง

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

API ของ C และ C++

นอกจากนี้ LiteRT ยังมี API สำหรับเรียกใช้โมเดลโดยใช้ C และ C++ ด้วย หากแอปของคุณใช้ Android NDK คุณควรพิจารณาใช้ API นี้ นอกจากนี้ คุณอาจต้องพิจารณาใช้ API นี้หากต้องการแชร์โค้ดระหว่างแพลตฟอร์มต่างๆ ได้ ดูข้อมูลเพิ่มเติมเกี่ยวกับตัวเลือกการพัฒนา นี้ได้ที่หน้าเครื่องมือ การพัฒนา

การดำเนินการโมเดลบนเซิร์ฟเวอร์

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

Google Cloud มีชุดบริการครบวงจรสำหรับการเรียกใช้โมเดล AI ดูข้อมูลเพิ่มเติมได้ที่หน้าผลิตภัณฑ์ AI และแมชชีนเลิร์นนิงของ Google Cloud

การพัฒนาและการเพิ่มประสิทธิภาพโมเดลที่กำหนดเอง

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

เวอร์ชัน Android ที่รองรับ

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

Compiled Model API กับ Interpreter API

• Compiled Model API - การดำเนินการที่คอมไพล์ AOT/JIT ที่มีตัวเร่งเป็นอันดับแรก พร้อมการทำงานร่วมกันของบัฟเฟอร์แบบรวมและการทำงานแบบไปป์ไลน์แบบไม่พร้อมกัน
• Interpreter API - เข้ากันได้แบบย้อนหลังกับโค้ดสไตล์ TensorFlow Lite ที่มีอยู่

คุณเลือก API ใดก็ได้ในรันไทม์ โดยฟีเจอร์ด้านประสิทธิภาพและตัวเร่งใหม่ส่วนใหญ่จะอยู่ใน Compiled Model API

ดูตัวอย่างการใช้งานได้ที่

• การแบ่งกลุ่มรูปภาพ (Kotlin, CPU/GPU)
• การแบ่งกลุ่มแบบไม่พร้อมกัน (C++, CPU/GPU/NPU)
• ความคล้ายคลึงกันเชิงความหมาย (C++) - ตัวอย่างในเครื่อง

Common และ CPU

GPU

NPU

คู่มือเริ่มใช้งานฉบับย่อ (Compiled Model API)

การเรียกใช้การอนุมานด้วย Compiled Model API มีขั้นตอนสำคัญต่อไปนี้

1. โหลดโมเดลที่เข้ากันได้
2. จัดสรรบัฟเฟอร์ Tensor อินพุตและเอาต์พุต
3. เรียกใช้โมเดลที่คอมไพล์แล้ว
4. อ่านการอนุมานลงในบัฟเฟอร์เอาต์พุต

ข้อมูลโค้ดต่อไปนี้แสดงการติดตั้งใช้งานพื้นฐานของกระบวนการทั้งหมดใน Kotlin และ C++

// Load model and initialize runtime
LITERT_ASSIGN_OR_RETURN(auto model, Model::CreateFromFile("mymodel.tflite"));
LITERT_ASSIGN_OR_RETURN(auto env, Environment::Create({}));
LITERT_ASSIGN_OR_RETURN(auto compiled_model,
    CompiledModel::Create(env, model, kLiteRtHwAcceleratorCpu));

// Preallocate input/output buffers
LITERT_ASSIGN_OR_RETURN(auto input_buffers, compiled_model.CreateInputBuffers());
LITERT_ASSIGN_OR_RETURN(auto output_buffers, compiled_model.CreateOutputBuffers());

// Fill the first input
float input_values[] = { /* your data */ };
input_buffers[0].Write<float>(absl::MakeConstSpan(input_values, /*size*/));

// Invoke
compiled_model.Run(input_buffers, output_buffers);

// Read the output
std::vector<float> data(output_data_size);
output_buffers[0].Read<float>(absl::MakeSpan(data));

// Load model and initialize runtime
val  model =
    CompiledModel.create(
        context.assets,
        "mymodel.tflite",
        CompiledModel.Options(Accelerator.CPU)
    )

// Preallocate input/output buffers
val inputBuffers = model.createInputBuffers()
val outputBuffers = model.createOutputBuffers()

// Fill the first input
inputBuffers[0].writeFloat(FloatArray(data_size) { data_value /* your data */ })

// Invoke
model.run(inputBuffers, outputBuffers)

// Read the output
val outputFloatArray = outputBuffers[0].readFloat()

ดูข้อมูลเพิ่มเติมได้ที่คำแนะนำเริ่มต้นใช้งาน Kotlin และ เริ่มต้นใช้งาน C++

ความสามารถหลัก (Compiled Model API)

• การเลือกตัวเร่งความเร็วแบบสำเร็จรูปและแบบอะซิงโครนัส - เลือก CPU/GPU/NPU ในเวลาที่สร้างและเรียกใช้แบบอะซิงโครนัสโดยไม่ต้องใช้การเชื่อมต่อแบบมีตัวแทน
• บัฟเฟอร์แบบไม่มีการคัดลอกที่รวมเป็นหนึ่งเดียว - แชร์บัฟเฟอร์ AHWB/GL/OpenCL/WebGPU/Metal ในการประมวลผลก่อน/หลัง และการอนุมาน
• ปริมาณงานที่พร้อมใช้งาน Generative AI - เพิ่มประสิทธิภาพสำหรับโมเดลขนาดใหญ่ด้วยการแคชหน่วยความจำและการสำรองข้อมูล GPU/NPU

Interpreter API ยังคงเป็นเส้นทางการทำงานร่วมกันสำหรับฐานโค้ด TensorFlow Lite ที่มีอยู่ ใช้เมื่อคุณต้องการลักษณะการทำงานของ Delegate ที่เสถียรหรือ Wrapper ของบุคคลที่สามที่คาดหวัง Interpreter แบบคลาสสิก

Accelerator

• CPU (ค่าเริ่มต้น): รองรับรูปร่างแบบไดนามิกที่เพิ่มประสิทธิภาพ XNNPACK
• GPU: แบ็กเอนด์ OpenCL ในปัจจุบัน ส่วนแบ็กเอนด์ WebGPU และ Metal พร้อมใช้งานผ่าน Compiled Model API
• NPU: รองรับ Qualcomm AI Engine Direct และ MediaTek NeuroPilot สำหรับ AOT/JIT, มี Pixel AOT และมีแผนที่จะรองรับ NPU ของ Apple/Intel

กรณีที่ควรเลือก API

• ใช้ Compiled Model API เมื่อต้องการเส้นทางที่เร็วที่สุดไปยัง GPU/NPU, บัฟเฟอร์แบบไม่คัดลอก หรือการดำเนินการแบบไม่พร้อมกัน
• ใช้ Interpreter API เมื่อต้องการความเข้ากันได้สูงสุดกับโค้ด เครื่องมือ หรือ Delegate ของ TensorFlow Lite ที่มีอยู่