การใช้ประโยชน์จากระบบอัจฉริยะในอุปกรณ์ด้วย ML Kit และ LiteRT ในบริการ Google Play

สวัสดีตอนเย็นทุกคน

เรากำลังจะเริ่มการพูดคุย

ดังนั้นเมื่อผู้คนพูดถึง "AI ในอุปกรณ์" ในปัจจุบัน มักจะหมายถึง LLM

และเมื่อช่วงเช้าที่ผ่านมา คุณได้เห็นการพูดคุยหลายเรื่องเกี่ยวกับ Gemini Nano ที่ครอบคลุมทั้ง ML Kit, Firebase และผลิตภัณฑ์อื่นๆ อีกมากมายของ Google

เซสชันนี้จะพูดถึงอีกครึ่งหนึ่ง ซึ่งก็คือ ML แบบคลาสสิกและโมเดลที่คุณนำมาเอง

คุณอาจใช้ฟีเจอร์นี้ไปแล้ว 2-3 ครั้งในวันนี้โดยไม่รู้ตัว

ลองนึกถึงการใช้แอปที่คุณเบลอพื้นหลังหรือใช้เครื่องสแกนบาร์โค้ดหรือใช้การแก้ไขรูปภาพบางประเภท

ซึ่งส่วนใหญ่เป็น ML แบบคลาสสิก และมักจะทำงานในอุปกรณ์ด้วยซ้ำ

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

คุณอาจสงสัยว่าขนาดแอปจะได้รับผลกระทบอย่างไร

วันนี้คุณจะเห็นว่าไม่จำเป็นต้องเลือกระหว่างโซลูชันแบบเบ็ดเสร็จหรือการนำโมเดลของคุณมาเอง

คุณสามารถทำทั้ง 2 อย่างได้ด้วยรันไทม์แบบ Lean เพียงรายการเดียว

ฉันชื่อ Chintan Parikh

ผมเป็นผู้จัดการผลิตภัณฑ์ของ LiteRT และ Fergus ซึ่งเป็นหัวหน้าฝ่ายวิศวกรรมของบริการ Android ML ก็อยู่กับผมด้วย

สวัสดี

และในตอนท้าย คุณจะได้เห็นวิธีสร้างแอปเดียวที่เรียกใช้โมเดล 2 โมเดลในทุกเฟรมกล้องที่ความเร็วประมาณ 30 เฟรมต่อวินาที

การพูดคุยครั้งนี้มี 4 ส่วนด้วยกัน

ส่วนแรก เราจะพูดถึงโซลูชัน AI ในอุปกรณ์ของ Google ที่มุ่งเน้น ML แบบคลาสสิก ซึ่งก็คือ ML Kit และ LiteRT

ประการที่ 2 เราจะพูดถึงสิ่งใหม่ๆ ใน LiteRT และบริการ Google Play ด้วย

นอกจากนี้ เราจะพูดถึง CompiledModel API ใหม่จาก LiteRT และอุปกรณ์ที่เรารองรับด้วย

สาม เราจะแสดงวิธีสร้างแอปใหม่

Fergus จะพูดถึงการสร้างแอปด้วย ML Kit และโมเดลที่กำหนดเองทั้งหมดใน APK เดียว

และสุดท้าย เราจะแสดงวิธีอัปเกรดแอปที่มีอยู่โดยใช้โหมด Agent

นอกจากนี้ คุณยังสามารถสร้างแอปใหม่ด้วยการสนับสนุนจาก Agent นี้ได้ด้วย

โอเค

ก่อนอื่นมาเริ่มกันที่ LiteRT คืออะไร

LiteRT เป็นรันไทม์การอนุมานในอุปกรณ์ของ Google สำหรับโมเดลของคุณเอง

โดยใช้รูปแบบไฟล์ .tflite เดียวกันกับที่คุณใช้ก่อนหน้านี้กับ TensorFlow Lite

เราได้ปรับโครงสร้างใหม่เพื่อประสิทธิภาพและยังรองรับหลายเฟรมเวิร์กด้วย

ซึ่งหมายความว่าคุณสามารถนำโมเดลจาก PyTorch, TensorFlow และแม้แต่ JAX มาลดขนาดเป็นรูปแบบ Flat Buffer สำหรับ LiteRT ได้

ตั้งแต่ปี 2022 เป็นต้นมา TensorFlow Lite ในบริการ Google Play ได้กลายเป็นรันไทม์ในอุปกรณ์อย่างเป็นทางการของ Android สำหรับโมเดลที่กำหนดเอง

วันนี้เราจะอัปเกรดครั้งใหญ่ และนั่นคือสิ่งที่เราจะพูดถึงกันในวันนี้

การอัปเกรดนี้จะนำ API CompiledModel ล่าสุดของ LiteRT มาใช้ ซึ่งรวมถึงการอนุมาน GPU ที่ปรับปรุงใหม่ซึ่งจะเร็วขึ้น 1.4 เท่า และยังช่วยให้คุณสร้างแอปขนาดเล็กลงในขนาด APK ที่เล็กลงมาก

แล้วทำไมจึงต้องนำส่งผ่านบริการ Google Play

มีข้อดีอยู่ 2-3 ข้อ และนี่เป็นปัญหาใหญ่ที่ฉันเห็นจากการพูดคุยหลายครั้งที่ได้ยินมาว่าขนาดแอปและ APK ที่บวมขึ้นกำลังกลายเป็นความท้าทายที่แท้จริงใช่ไหม

ซึ่งจะทำให้รันไทม์มีขนาดเล็ก

รันไทม์ไม่ได้อยู่ใน APK ของคุณ คุณจึงต้องใช้ธินไคลเอ็นต์ ซึ่งทำให้ APK ของคุณมีขนาดเล็กลงประมาณ 8 MB

ประโยชน์ข้อที่ 2 คือมีประสิทธิภาพ

คุณมีรันไทม์เพียงสำเนาเดียว ดังนั้นรันไทม์ที่เป็นรันไทม์ LiteRT จึงใช้ร่วมกันในแอปทั้งหมด

ดังนั้น หากคุณมีแอปจำนวนมาก แอปทั้งหมดจะช่วยประหยัดพื้นที่ได้แอปละ 8 MB

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

ประการที่ 2 คือการดูแลรักษา

Google จะส่งการแก้ไขข้อบกพร่อง แก้ไขปัญหาเกี่ยวกับไดรเวอร์ GPU ที่คุณไม่ต้องดำเนินการเอง และการอัปเดตความปลอดภัยอื่นๆ ทั้งหมดจะมาพร้อมกับการอัปเดตอัตโนมัติ

และอย่างที่บอกไป GPU จะเร็วขึ้น คุณจึงได้ GPU ที่เร็วขึ้น 1.4 เท่า และเราจะพูดถึงรายละเอียดเพิ่มเติมในเรื่องนี้ด้วย

และในแง่ของความครอบคลุม เราสามารถจัดส่งไปยังอุปกรณ์ Android รุ่นเก่าได้

LiteRT ในบริการ Google Play รองรับ Android 7 ตั้งแต่ปี 2016 เป็นต้นไป

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

นี่คือเครื่องมือในการนำส่ง และเราจะพูดถึงขั้นตอนถัดไป ซึ่งก็คือรันไทม์

ดังนั้น LiteRT จึงไม่ใช่เรื่องใหม่และไม่ใช่เวอร์ชันทดลอง

ปัจจุบัน TensorFlow Lite และ LiteRT ทำงานในแอปมากกว่า 250,000 แอปแล้ว

และยังทำงานบนอุปกรณ์มากกว่า 3.8 พันล้านเครื่องในปัจจุบัน

ดังนั้น แอปจำนวนมากที่คุณอาจใช้อยู่ คุณอาจไม่รู้ด้วยซ้ำว่าแอปทั้งหมดทำงานบนระบบนี้

และยังเทียบเท่ากับการอนุมานมากกว่าล้านล้านครั้งในแต่ละวันด้วยใช่ไหม

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

LiteRT ยังเป็นสิ่งที่ Google ใช้ในแอปเรือธงของตนด้วย ทั้งในแอป แพลตฟอร์ม และแม้แต่อุปกรณ์ต่างๆ

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

ซึ่งก็สำคัญมากเช่นกัน เพราะการทำให้ Use Case น่าสนใจและดึงดูดผู้ใช้เป็นเรื่องที่สำคัญอย่างยิ่ง

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

เรามาพูดถึงเหตุผลที่ควรใช้ AI ในอุปกรณ์กันด้วย

เวลาในการตอบสนอง ความเป็นส่วนตัว การทำงานแบบออฟไลน์ หรือการมีต้นทุนต่ำ หากสิ่งเหล่านี้สำคัญสำหรับคุณ ให้เรียกใช้แบบออฟไลน์ใช่ไหม

อาจมีเหตุผลมากกว่านี้ แต่เหตุผลเหล่านี้เป็นเหตุผลที่ชัดเจนที่สุดที่เราได้ยินมาสำหรับการรันในอุปกรณ์

นอกจากนี้ การเรียกใช้ในอุปกรณ์ก็ไม่ได้ให้บริการฟรีเสมอไป

ซึ่งมีรายละเอียดปลีกย่อยและความท้าทายบางอย่าง

เราจะพูดถึงความท้าทายเหล่านี้และแนวทางแก้ไขด้วย

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

วิดีโอและเสียงแบบเรียลไทม์ต้องการประสิทธิภาพสูงสุด

แม้แต่ฟีเจอร์แบบอินเทอร์แอกทีฟที่เรียบง่ายก็ต้องทำงานได้อย่างรวดเร็ว

ไม่เช่นนั้น คุณจะสูญเสียการมีส่วนร่วมของผู้ใช้

ความหลากหลายของฮาร์ดแวร์: มี SoC หลายร้อยรายการที่มีการกำหนดค่า CPU และ GPU ที่แตกต่างกัน

คุณเขียนโค้ดสำหรับสิ่งเหล่านี้ทั้งหมดไม่ได้ใช่ไหม

คุณจะแก้ปัญหาเหล่านี้ได้อย่างไร

ขนาด APK: การรวมรันไทม์แบบเนทีฟยังทำให้การดาวน์โหลดแต่ละครั้งมีขนาดใหญ่ขึ้น ซึ่งอาจส่งผลต่ออัตรา Conversion

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

ดังนั้น การสร้างแอปในอุปกรณ์ที่ยอดเยี่ยมจึงอาจเป็นเรื่องยาก

แต่ไม่ว่าจะอยู่ในสถานการณ์ใด เราก็ต้องการให้แพลตฟอร์มทำงานแทนคุณ ไม่ใช่ให้คุณทำงานแทนแพลตฟอร์ม จริงไหม

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

วันนี้เราจะเน้นไปที่ 2 โซลูชันง่ายๆ ใช่ไหม

คุณเพิ่ม AI ในอุปกรณ์ผ่านบริการ Google Play ได้ง่ายๆ 2 วิธี

เส้นทางที่ 1 คือเส้นทางแบบเบ็ดเสร็จที่ใช้ ML Kit ใช่ไหม

ซึ่งเป็น API ด้านการมองเห็นและภาษาที่พร้อมใช้งาน โดยไม่จำเป็นต้องมีความเชี่ยวชาญด้าน ML มากนัก มีโมเดลมากมายให้เลือกใช้ และทั้งหมดนี้ให้บริการผ่านบริการ Google Play

และเราจะยกตัวอย่างของสิ่งเหล่านี้ในสไลด์ถัดไปด้วย

เส้นทางที่กำหนดเอง ซึ่งทำผ่าน LiteRT

LiteRT ช่วยให้คุณนำโมเดลของคุณเองมาใช้และเรียกใช้ใน CPU, GPU ได้

รันไทม์มาจากบริการ Google Play ด้วยเช่นกัน

ดังนั้นจึงอยู่ใน... คุณจึงไม่ต้องรวมไว้ใน APK

ซึ่งคุณไม่จำเป็นต้องเลือกอย่างใดอย่างหนึ่ง

และทั้ง 2 อย่างนี้ยังทำงานร่วมกันได้ดีขึ้นด้วย

และนั่นคือสิ่งที่เราจะสร้างในวันนี้ในอีกไม่กี่นาทีข้างหน้า

ก่อนอื่น เรามาพูดถึงสิ่งที่ ML Kit ครอบคลุมกันก่อน

ต่อไปนี้คือสิ่งที่ ML Kit ครอบคลุมตั้งแต่เริ่มต้น

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

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

ประเด็นสำคัญคือ API ด้านการมองเห็นและภาษาเหล่านี้จำนวนมากทำงานร่วมกับ LiteRT เบื้องหลัง

ดังนั้น หาก ML Kit ทำสิ่งที่คุณต้องการได้ คุณก็เริ่มต้นที่นี่ได้เลย

และเมื่อไม่เป็นเช่นนั้น คุณก็มีโอกาสที่จะนำโมเดลของคุณเองมาใช้

และประเด็นสำคัญคือ ML Kit และโมเดลที่กำหนดเองจะไม่ใช่รันไทม์ 2 รายการตามที่ได้กล่าวไปแล้ว

ซึ่งเปรียบเสมือนประตูหน้า 2 บานที่นำไปสู่ LiteRT เดียวกันซึ่งจะทำงานอยู่เบื้องหลัง

ดังนั้น LiteRT จะเป็นรันไทม์ของ Play ที่จะประสานความสามารถทั้งสองนี้เข้าด้วยกัน

ดังนั้น หากแอปของคุณใช้ Play Store อยู่แล้ว ก็ใช้ ML Kit ได้เลย

ไม่เช่นนั้น เราจะอธิบายเส้นทาง LiteRT ด้วย

เรามาพูดถึงสิ่งใหม่ๆ ใน LiteRT กันด้วย

อย่างที่บอกไป LiteRT เป็นวิวัฒนาการของ TensorFlow Lite ใช่ไหม

ดังนั้น การปรับปรุงที่สำคัญที่สุดคือเรามี GPU ที่เร็วขึ้น

GPU ที่เร็วขึ้นรองรับ OpenCL, OpenGL และยังรองรับการทำงานข้ามแพลตฟอร์มแม้กระทั่งสำหรับแบ็กเอนด์ Metal

ดังนั้น คุณจึงใช้ฟีเจอร์นี้กับหลายแพลตฟอร์มได้ตามต้องการ

และยังใช้งานง่ายกว่าด้วย

เรามีเวิร์กโฟลว์แบบรวมเดียวสำหรับการเร่ง CPU, GPU และ NPU

ปัจจุบัน CPU และ GPU อยู่ในบริการ Google Play ส่วน NPU จะรวมอยู่ใน LiteRT และเรากำลังดำเนินการอยู่

ก่อนหน้านี้ ตัวเร่งแต่ละตัวหมายถึงการตั้งค่าผู้รับมอบสิทธิ์ที่แตกต่างกันใช่ไหม

คุณเพียงแค่ต้องดำเนินการครั้งเดียวเท่านั้น

ดังนั้นจึงมี API เดียวที่เปลี่ยนกลับไปใช้ CPU โดยอัตโนมัติ และคุณไม่จำเป็นต้องตั้งค่าการมอบสิทธิ์เฉพาะ

และคุณสามารถใช้การเรียกใช้ Accelerator ที่จัดการเรื่องนี้ได้ง่ายขึ้นมากและใช้โค้ดน้อยลง

นอกจากนี้ยังทรงพลังด้วย โมเดลเดียวกันนี้ทำงานบนหลายแพลตฟอร์มอย่างที่ฉันได้กล่าวไป

ความยืดหยุ่นจึงเป็นสิ่งสำคัญมาก

ดังนั้นรูปแบบ .tflite จึงยังคงเหมือนเดิม

หากมีแอปอยู่แล้ว คุณจะยังใช้รูปแบบนี้ได้

หากคุณกำลังสร้างแอปใหม่ คุณสามารถใช้รูปแบบไฟล์นี้ได้อีกครั้ง

สิ่งที่น่าสนใจอีกอย่างคือเรารองรับ Interpreter API ซึ่งเคยอยู่ใน TensorFlow Lite

ดังนั้นหากคุณต้องการย้ายข้อมูลเป็นระยะๆ Interpreter API จะรวมอยู่ใน LiteRT ใหม่ด้วย ซึ่งจะช่วยให้คุณย้ายข้อมูลได้ง่ายขึ้น

นั่นคือรันไทม์

มาพูดถึงสิ่งที่คุณสร้างได้ด้วยเครื่องมือนี้กัน

มาดูกันว่าแอป Android กำลังสร้างอะไรอยู่ในปัจจุบัน

ทุกอย่างตั้งแต่เอฟเฟกต์กล้อง การแต่งภาพ การพิมพ์อัจฉริยะ เกม และอวาตาร์ ใช่ไหม

แอปเหล่านี้จำนวนมากจะต้องใช้ความสามารถแบบเรียลไทม์

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

โมเดลการแก้ไขรูปภาพบางโมเดลก็มีขนาดใหญ่ขึ้นด้วย

และเช่นเดียวกันกับความสามารถ AR/VR ที่คุณได้เห็นในการสาธิตบางรายการด้วยแว่นตา ความสามารถเหล่านี้ส่วนใหญ่จะใช้ LiteRT อยู่เบื้องหลัง

ซึ่งเป็นรันไทม์เดียวกับที่อยู่เบื้องหลังฟีเจอร์หลักของ Google และในบริการ Google Play ด้วย คุณจึงได้รับฟีเจอร์ทั้งหมดนี้โดยไม่ต้องรวมอะไรไว้ใน APK

ตอนนี้เรามาสร้างแอปกันดีกว่า โดย Fergus จะแสดงให้เราเห็นว่าต้องทำอย่างไร

มาเริ่มกันเลย

ขอขอบคุณ Chintan

ดังนั้นผมจะพูดถึงสิ่งใหม่ๆ ใน LiteRT ในบริการ Google Play สักเล็กน้อย

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

คุณจึงสามารถใช้โมเดลในอุปกรณ์ที่ทำงานในนาฬิกาหรืออุปกรณ์ที่สวมใส่ได้อื่นๆ หรือในรถยนต์ได้

ก่อนหน้านี้ คุณสามารถใช้แอปในโทรศัพท์ซึ่งเป็นแอปที่ใช้ร่วมกันกับ Wear ได้ แต่ตอนนี้คุณสามารถใช้แอปดังกล่าวในอุปกรณ์ที่สวมใส่ได้โดยตรง และใช้กับ Android Automotive ได้ด้วย

คุณจึงมี API เดียวกัน โมเดล .tflite เดียวกัน แต่มีแพลตฟอร์มมากขึ้น

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

และข้อดีของรูปแบบการเผยแพร่บริการ Google Play คือเราสามารถพอร์ตฟีเจอร์นี้กลับไปให้ทำงานในอุปกรณ์รุ่นเก่าได้

ดังนั้นสำหรับ Android Automotive OS เราจึงรองรับย้อนหลังไปถึง Android 11 ที่เปิดตัวในปี 2020 และสำหรับ Wear OS เราจะรองรับตั้งแต่ Wear OS 4 ขึ้นไป

ตกลง

ตอนนี้เราจะพูดถึง 2 เส้นทางที่แตกต่างกัน ได้แก่ การสร้างแอปใหม่และการอัปเกรดแอปที่มีอยู่

ซึ่งเราจะพูดถึงเรื่องนี้ในช่วงที่เหลือของการบรรยาย

ดังนั้นฉันจะเริ่มด้วยแอปตัวอย่างที่รวมการใช้ ML Kit กับโมเดล GPU ที่กำหนดเองซึ่งทำงานบน LiteRT

และสำหรับการอัปเกรดแอปที่มีอยู่ จะมีการเปลี่ยนแปลงเล็กน้อย 3 อย่าง ได้แก่ การเปลี่ยนแปลง Gradle เพื่ออัปเดตทรัพยากร Dependency, การเปลี่ยนแปลง init เพื่อเปิดใช้ LiteRT ในบริการ Google Play และการเปลี่ยนจาก Interpreter API เป็น CompiledModel API

แต่เราจะทำเช่นนั้นกับแอปใหม่ก่อน เนื่องจากการอัปเกรดจะสมเหตุสมผลมากขึ้นเมื่อคุณได้เห็นสิ่งที่คุณกำลังอัปเกรด

ดังนั้น การสร้างแอปใหม่

นี่คือแอปที่เราจะสร้าง

โดยจะมีมุมมองกล้องแบบสดซึ่งคุณจะดูคมชัด และพื้นหลังจะเปลี่ยนเป็นสไตล์ศิลปะ

เราจะใช้เฟรมกล้อง

เราจะสตรีมรูปภาพจากเฟรมกล้องผ่านการแบ่งกลุ่มเซลฟีของ ML Kit

ซึ่งเป็นหนึ่งใน API แบบเบ็ดเสร็จของ ML Kit ที่มีอยู่

ซึ่งจะสร้างมาสก์พื้นหน้าที่บอกว่าพิกเซลใดในรูปภาพที่สอดคล้องกับบุคคลในรูปภาพ

จากนั้นเราจะนำโมเดลที่กำหนดเองซึ่งเป็นโมเดลประเภทการถ่ายโอนสไตล์มาใช้เพื่อนำสไตล์ไปใช้กับรูปภาพ

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

เราจึงต้องการใช้ API แบบเบ็ดเสร็จที่มีอยู่ และ API ที่กำหนดเองซึ่งทำให้แอปของเราแตกต่าง

นี่คือส่วนแรกที่เราเรียกใช้ API การแบ่งกลุ่มเซลฟีของ ML Kit

// 1. Configure and create segmenter client
val segmenter = Segmentation.getClient(
    SelfieSegmenterOptions.Builder()
        .setDetectorMode(
            SelfieSegmenterOptions.STREAM_MODE)
        .build())

// 2. Prepare image & run inference
fun processFrame(mediaImage: Image) {
  val image = InputImage.fromMediaImage(
      mediaImage, /* rotationDegrees= */ 0)
  segmenter.process(image)
      .addOnSuccessListener { mask -> … }
}

แสดงว่า API นี้ก็เหมือนกับ API ทั่วไปใช่ไหม

ซึ่งเป็นสิ่งที่นักพัฒนาแอป Android ต้องทำเป็นประจำอยู่แล้ว

คุณก็แค่ดูเอกสารประกอบ API หรือขอความช่วยเหลือจาก Gemini สร้างให้คุณ

แต่คุณก็รู้ว่ามันค่อนข้างตรงไปตรงมา

คุณสร้างไคลเอ็นต์โดยส่งตัวเลือกบางอย่างเมื่อสร้างไคลเอ็นต์

ในกรณีนี้ เราจะระบุโหมดสตรีมมิงเพื่อให้ประมวลผลสตรีมเฟรมวิดีโอได้

จากนั้นจะมีเมธอดที่เรียกว่า process และ Callback จากเมธอดนั้นจะได้รับมาสก์ที่แสดงผล ซึ่งคำนวณโดยการแบ่งกลุ่มเซลฟี

และอินพุตคือรูปภาพจากกล้อง

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

สำหรับส่วนที่ 2 ซึ่งเป็นโมเดลที่กำหนดเอง เราจะใช้โมเดล PyTorch

ฉันคิดว่า Chintan ได้โมเดลนี้มาจากแหล่งข้อมูลอย่าง Kaggle หรือ Hugging Face…

ขวา

ใช่ หรือคุณจะแปลงไฟล์ของคุณเองก็ได้

คุณสร้างโมเดลของคุณเองได้

ขอโทษนะ ย้อนกลับ

ใช่ นี่คือลักษณะของสแต็กประเภทนี้

คุณสามารถนำโมเดล PyTorch มาแปลงและทำ Quantize เพื่อให้ได้โมเดล LiteRT

จากนั้นคุณจะเผยแพร่คีย์นั้นพร้อมกับแอปด้วยวิธีใดก็ได้ตามต้องการ

โดยจะรวมเป็นส่วนหนึ่งของแอปเป็นชิ้นงานหรือจะดาวน์โหลดแยกต่างหากก็ได้

คุณจะใช้วิธีใดก็ได้

ซึ่งจะอยู่ด้านบนของรันไทม์ LiteRT ในบริการ Google Play

จากนั้นก็มีเคอร์เนล CPU สำหรับการเพิ่มประสิทธิภาพใน CPU และ ML Drift คือชื่อของตัวเร่ง GPU

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

การแปลงจาก PyTorch ใช้ Python เพียงไม่กี่บรรทัด

import litert_torch

model = my_models.Stylizer().eval()

# Convert with torch.export under the hood
edge_model = litert_torch.convert(
    model, sample_inputs)
edge_model.export("stylizer_f32.tflite")

ดังนั้น คุณจึงติดตั้ง LiteRT-Torch โดยใช้ pip, เรียกใช้ litert_torch.convert, ส่ง sample_inputs บางรายการที่อาจเป็นอินพุตแบบสุ่ม และส่งออกไฟล์ TFLite

LiteRT-Torch เป็นชื่อใหม่ของ ai-edge-torch หากคุณคุ้นเคยกับชื่อนั้น

จากนั้นการทำ Quantization ก็ตรงไปตรงมามากเช่นกัน

# Python
# previously ai_edge_quantizer
from litert_quantizer import quantizer, recipe

qt = quantizer.Quantizer("stylizer_f32.tflite")

# int8 weights, float activations
qt.load_quantization_recipe(
    recipe.dynamic_wi8_afp32())

qt.quantize().export_model("stylizer_int8.tflite")

คุณนำเข้า Quantizer และสูตรจาก LiteRT Quantizer

เมื่อสร้าง Quantizer คุณจะส่งโมเดลจุดลอยตัวเดิมและส่งสูตร ซึ่งเป็นสูตรมาตรฐานที่เราใช้และแนะนำสำหรับ GPU ซึ่งใช้น้ำหนักจำนวนเต็ม 8 บิต แต่คงการเปิดใช้งานเป็นจุดลอยตัว 32 บิต

จากนั้นคุณก็แค่เรียกใช้ quantize แล้วเรียกใช้ export_model เพื่อบันทึกโมเดลเอาต์พุต

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

ใช่แล้ว GPU ของ CompiledModel API คือจุดเด่นของโมเดลนี้

ดังนั้น อย่างที่ Chintan ได้กล่าวไปแล้วว่าความเร็วเพิ่มขึ้นอย่างมากเมื่อเทียบกับ TFLite GPU รุ่นเดิม

ตัวเลขที่แน่นอนจะแตกต่างกันไปเล็กน้อยในแต่ละรุ่น แต่ 1.4 เท่าคือสิ่งที่คุณคาดหวังได้อย่างสมเหตุสมผล

เร็วกว่าการอนุมาน CPU ถึง 10 เท่า ซึ่งถือเป็นข้อดีอย่างมากเลยใช่ไหม

หากคุณเป็นคนส่วนใหญ่ที่ใช้โมเดลในปัจจุบัน คุณอาจเรียกใช้โมเดลเหล่านั้นใน CPU และพลาดประสิทธิภาพที่เพิ่มขึ้นถึง 10 เท่าจาก GPU

ซึ่งเป็นแรงจูงใจที่ดีมาก

สิ่งที่ทำให้รวดเร็ว

เราสนับสนุนหลายอย่าง เช่น การดำเนินการแบบอะซิงโครนัส เพื่อให้คุณนำ AHardwareBuffer และส่งต่อโดยตรง หรือบัฟเฟอร์ OpenGL จากไปป์ไลน์การแสดงผลของกล้องนั้น ส่งตรงไปยังบัฟเฟอร์ Tensor

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

ดังนั้น สำหรับแอปพลิเคชันที่ต้องการการทำงานแบบเรียลไทม์สูงมากซึ่งคุณต้องการใช้การเพิ่มประสิทธิภาพแบบ Zero-Copy เราก็รองรับเช่นกัน

และอย่างที่ Chintan พูดถึงไปแล้วว่านี่เป็นแบบข้ามแพลตฟอร์มที่รองรับ OpenGL, OpenCL และ Metal เป็นแบ็กเอนด์ GPU

และสุดท้ายแต่ไม่ท้ายสุด เครื่องมือเพิ่มประสิทธิภาพ ML Drift เป็นโอเพนซอร์ส

โดยมีให้บริการภายใต้ใบอนุญาต Apache

Google เพิ่งเปิดให้เป็นโอเพนซอร์สเมื่อเร็วๆ นี้

โอเค แล้วนี่ก็คือโค้ดของแอป

// Kotlin
// Build once, off the main thread.
private val model: CompiledModel =
    CompiledModel.create(
        context.assets,
        "stylizer_int8.tflite",
        // Simple GPU setup!
        CompiledModel.Options(Accelerator.GPU),
        environment
    )

// Reuse buffers across frames.
private val inputBuffers  = model.createInputBuffers()
private val outputBuffers = model.createOutputBuffers()

fun stylize(input: FloatArray): FloatArray {
    inputBuffers[0].writeFloat(input)
    model.run(inputBuffers, outputBuffers) // sync
    return outputBuffers[0].readFloat()
}

คุณจะเห็นได้ว่าโค้ดมีขนาดเล็กและตรงไปตรงมา

คุณจึงสร้างโมเดลเพียงครั้งเดียว แล้วนำมาใช้ซ้ำในทุกเฟรม

ดังนั้น CompiledModel.create จะส่งผ่านไฟล์ .tflite

คุณเพียงแค่ระบุว่าต้องการเรียกใช้บน GPU จากนั้นก็สร้างอินพุตและ outputBuffers

จากนั้นในลูปหลักที่คุณประมวลผลทุกเฟรมจริงๆ คุณจะเรียก model.run นี้เพื่อส่งอินพุตและเอาต์พุต

หลังจากเขียนลงใน inputBuffers แล้ว ให้เรียกใช้ model.run จากนั้นอ่านจาก outputBuffers

ตกลง

ใช่แล้ว และในนั้น หากคุณระบุ GPU ไว้ ระบบจะเรียกใช้ใน GPU

หากคุณระบุ CPU และ GPU ไว้ที่นั่นด้วย ระบบจะพยายามเรียกใช้ GPU

หาก GPU ไม่พร้อมใช้งานไม่ว่าด้วยเหตุผลใดก็ตาม ระบบจะเปลี่ยนไปใช้ CPU แทน

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

โดยทั่วไปแล้ว คุณควรมี CPU สำรอง

ตกลง

เราจึงสร้างขึ้นโดยใช้ LiteRT ที่รวมมาด้วย ซึ่งยังไม่ได้ใช้บริการ Google Play

ฉันจะแสดงวิธีใช้ LiteRT ในบริการ Google Play ให้ดู

ดังนั้นจึงมีการเปลี่ยนแปลง 3 อย่าง อย่างแรกคือการเปลี่ยนแปลงทรัพยากร Dependency

// Easier with CompiledModel API: 3 steps

// 1. app/build.gradle: replace litert with play-services-litert
- implementation 'com.google.ai.edge.litert:litert:...'
+ implementation 'com.google.android.gms:play-services-litert:17.0.0'  // also pulls in litert-api

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

และคุณนำทรัพยากร Dependency litert หรือทรัพยากร Dependency ของแพ็กเกจ TensorFlow Lite Maven เวอร์ชันเก่าออก แล้วแทนที่ด้วย play-services-litert นี้

ซึ่งจะดึงแพ็กเกจ litert-api เข้ามาด้วย

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

ดังนั้น ขั้นตอนที่ 2 คือพารามิเตอร์สภาพแวดล้อม

ซึ่งเป็นที่ที่คุณระบุการแทรกทรัพยากร Dependency เพื่อระบุว่าคุณกำลังใช้หรือต้องการใช้ LiteRT ของบริการ Google Play

ดังนั้น คุณจึงนำเข้า gms.litert.LiteRt และเรียกใช้ฟังก์ชันเริ่มต้น โดยส่งบริบทซึ่งเป็นกิจกรรม Android ของคุณ

// 2. Initialize the LiteRT Environment from Play services (context = your Activity)
- val environment = Environment.create(...)
+ import com.google.android.gms.litert.LiteRt
+ val environment = LiteRt.initialize(context).await()

// 3. Pass environment whenever you call CompiledModel.create

// That's it! The rest of your app uses the normal CompiledModel APIs from litert-api.

และนั่นเป็นแบบอะซิงโครนัส คุณจึงต้องเรียก .await หรือให้ส่วนที่เหลืออิงตาม Callback

และสุดท้าย เมื่อคุณมีสภาพแวดล้อมนั้นแล้ว คุณก็เพียงแค่ส่งสภาพแวดล้อมนั้นเมื่อใดก็ตามที่คุณเรียกใช้ CompiledModel.create

ซึ่งจะทำให้แอปใช้รันไทม์ LiteRT ของบริการ Google Play จากบริการ Google Play

เพียงเท่านี้ก็เรียบร้อย

นั่นคือส่วนที่เหลือของแอปจะใช้ LiteRT CompiledModel API เดียวกันทุกประการจาก LiteRT API

โค้ดการอนุมานที่เหลือจะไม่เปลี่ยนแปลงสำหรับการใช้บริการ Google Play

และคุณสามารถย้ายข้อมูลแบบค่อยเป็นค่อยไปได้

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

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

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

และหากคุณใช้ LiteRT ในบริการ Google Play ข้อควรระวังอีกอย่างคือคุณไม่ควรผสมออบเจ็กต์ระหว่าง LiteRT ในบริการ Google Play กับ LiteRT ที่รวมมาด้วย

ดังนั้น หากคุณได้รับ Tensor, โมเดลที่คอมไพล์แล้ว หรืออินเทอร์พรีเตอร์จาก LiteRT ในบริการ Google Play คุณไม่ควรส่งต่อสิ่งเหล่านั้นไปยัง LiteRT ที่รวมมา หรือในทางกลับกัน

แต่หากไม่เป็นเช่นนั้น การผสมผสานสิ่งเหล่านี้ก็ใช้ได้ดี

ตกลง

นั่นคือการสร้างแอปใหม่

ต่อไปเราจะพูดถึงวิธีอัปเกรดแอปที่มีอยู่

ดังนั้น คุณอาจมีแอปที่ใช้ Interpreter API อยู่แล้ว

นี่คือสิ่งที่เราเรียกว่า TFLite API รุ่นเก่าที่ใช้ Interpreter เป็นคลาสหลัก

โค้ดทางด้านซ้ายใช้ Interpreter API และทางด้านขวาคุณจะเห็นโค้ด CompiledModel API ใหม่

// Dependencies (Gradle):
// play-services-tflite-java and/or litert (bundled)

// Init
TfLite.initialize(context).await()

// Load
val interpreterOptions =
    InterpreterApi.Options().apply {
      runtime = TfLiteRuntime.FROM_SYSTEM_ONLY
    }

val interpreter =
    InterpreterApi.create(modelFile, interpreterOptions)

// Prepare inputs/outputs
val inputs = …
val outputs = …

// Execute
interpreter.run(inputs, outputs)

// Dependencies (Gradle):
// play-services-litert

// Init
val environment =
  LiteRt.initialize(context).await()

// Load
val modelOptions = CompiledModel.Options(Accelerator.CPU)

val model =
    CompiledModel.create(modelPath, modelOptions, environment)

// Prepare inputs/outputs
val inputBuffers = model.createInputBuffers()
val outputBuffers = model.createOutputBuffers()

// Execute
model.run(inputBuffers, outputBuffers

ดังนั้น คุณเพียงแค่เปลี่ยน TfLite.initialize เป็น LiteRt.initialize และตอนนี้จะแสดงผลเป็นสภาพแวดล้อม

จากนั้นคุณจะส่งต่อสภาพแวดล้อมไปยัง CompiledModel.create

ดังนั้นจึงเป็นการเปลี่ยนแปลงเล็กน้อย และ APK ไม่ได้มีขนาดเพิ่มขึ้น

และคุณจะเห็นในสไลด์ถัดไปว่าเราจะแสดงวิธีดำเนินการด้วย GPU ซึ่งเป็นอีกตัวเลือกหนึ่ง

นี่คือโค้ดเพิ่มเติมที่คุณต้องใช้เพื่อเปิดใช้ GPU

// Dependencies (Gradle):
// play-services-tflite-java and/or litert (bundled)

// Init
val initOptions = TfLiteInitializationOptions.builder()
    .setEnableGpuDelegateSupport(true).build()
TfLite.initialize(context, initOptions).await()
val useGpu =
    TfLiteGpu.isGpuDelegateAvailable(context).await()

// Load
val interpreterOptions =
    InterpreterApi.Options().apply {
      runtime = TfLiteRuntime.FROM_SYSTEM_ONLY
    }
if (useGpu) {
    interpreterOptions.addDelegateFactory(
        GpuDelegateFactory());
}
val interpreter =
    InterpreterApi.create(modelFile, interpreterOptions)

// Prepare inputs/outputs
val inputs = …
val outputs = …

// Execute
interpreter.run(inputs, outputs)

// Dependencies (Gradle):
// play-services-litert

// Init
val initOptions = LiteRtInitializationOptions.builder()
    .setEnableGpu(true).build()
val environment = LiteRt.initialize(context, initOptions).await()

// Load
val modelOptions =
    CompiledModel.Options(Accelerator.CPU, Accelerator.GPU)

val model =
    CompiledModel.create(modelPath, modelOptions, environment)

// Prepare inputs/outputs
val inputBuffers = model.createInputBuffers()
val outputBuffers = model.createOutputBuffers()

// Execute
model.run(inputBuffers, outputBuffers)

อย่างที่คุณเห็น โค้ดใน API ใหม่สำหรับการเปิดใช้ GPU นั้นค่อนข้างจะเรียบง่ายกว่าโค้ดก่อนหน้านี้

ดังนั้น การเรียกใช้ setEnableGpu ครั้งแรกในตัวเลือกการเริ่มต้น LiteRT ที่คุณส่งไปยัง LiteRt.initialize จะทำให้ระบบโหลดโค้ดสำหรับตัวเร่ง GPU ลงในแอป

จากนั้นเมื่อสร้าง modelOptions และส่งไปยัง CompiledModel.create คุณจะระบุตัวเร่งที่จะใช้สำหรับโมเดลหนึ่งๆ ไม่ว่าคุณจะต้องการให้โมเดลอื่นทำงานบน GPU เท่านั้น หรือ GPU ที่มี CPU สำรอง หรือเฉพาะบน CPU

โอเค

ใช่ อย่างที่คุณเห็น การเปิดใช้ GPU นั้นง่ายขึ้นมากด้วย API ใหม่

แล้วคุณจะได้อะไรบ้าง

Chintan จะบอกคุณเอง

โอเค

ขอบคุณ Fergus

มาพูดถึงสิ่งที่เราจะได้รับจากทั้งหมดนี้กัน

จำได้ไหมว่าเราบอกว่าจะสร้างแอป มาดูกันว่าเราสร้างอะไรขึ้นมาจริงๆ

นั่นคือผมเอง และสิ่งที่เราทำที่นี่คือสิ่งที่เกิดขึ้นตอนนี้ เราใช้ ML Kit เพื่อค้นหาผม ดังนั้นการแบ่งกลุ่มจึงทำโดย API แบบเบ็ดเสร็จ เช่น ML Kit

นั่นคือการหาหัวของฉันตรงนั้น

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

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

ข้อดีอีกอย่างคือคุณไม่จำเป็นต้องทำทั้งหมดนี้ด้วยตนเอง

นอกจากนี้ยังมีทักษะใหม่ที่เราเพิ่งเปิดตัวใน Android ซึ่งโดยพื้นฐานแล้ว เราได้เผยแพร่ทักษะ Android LiteRT ที่อัปเกรด ML ในอุปกรณ์ได้ภายในไม่กี่นาทีใช่ไหม

คุณสามารถทำสิ่งต่างๆ ได้หลายอย่าง เช่น อัปเกรดแอปที่มีอยู่ สร้างแอปใหม่ และอัปเกรดแอปเพื่อใช้การผสานรวมบริการ Google Play ใหม่นี้ด้วย

ดังนั้นคุณจึงใช้ฟีเจอร์ทั้งหมดนี้ได้

ลิงก์อยู่ในสไลด์และ GitHub รวมถึงจะแสดงในเอกสารประกอบและบล็อกของเราด้วย

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

Fergus จะบอกเราว่าขั้นตอนต่อไปคืออะไร

เราจึงมุ่งมั่นที่จะพัฒนา AI ในอุปกรณ์ด้วย LiteRT

เรายังคงลงทุนอย่างต่อเนื่องในการปรับปรุงการเร่งความเร็ว GPU และความครอบคลุมของโมเดล รวมถึงอัปเดต LiteRT 2.x เป็นประจำ ทั้งสำหรับ LiteRT ที่รวมอยู่ในโอเพนซอร์สและแพ็กเกจ LiteRT Maven ของบริการ Google Play ซึ่งเป็น LiteRT ในบริการ Google Play

และเราจะยังคงให้ความเข้ากันได้แบบย้อนหลังต่อไป

รันไทม์ของบริการ Google Play จะยังคงรองรับแอปที่สร้างด้วย SDK เวอร์ชันเก่า

ใช่

คุณทราบดีว่านั่นเป็นสิ่งสำคัญอย่างยิ่งสำหรับผู้ใช้ของเรา และเป็นสิ่งสำคัญอย่างยิ่งสำหรับเรา

สำหรับ LiteRT 1.x SDK ตอนนี้อยู่ในโหมดการบำรุงรักษา จึงมีการแก้ไขด้านความปลอดภัยที่สำคัญเท่านั้น

และ NNAPI ซึ่งเราเลิกใช้งานไปแล้วในปี 2024 จะไม่มีให้ใช้งานอีกต่อไป และมีแนวโน้มว่าจะถูกนำออกตั้งแต่ปี 2027 เป็นต้นไป

ดังนั้น หากคุณใช้ NNAPI โปรดเปลี่ยนไปใช้การเร่ง GPU หรือการเร่ง NPU ด้วย LiteRT ที่รวมมาให้

ตกลง

ใช่

ดังนั้น ยิ่งคุณเปลี่ยนไปใช้ 2.x และ CompiledModel เร็วเท่าใด คุณก็จะมีงานที่ต้องทำในภายหลังน้อยลงเท่านั้น

สรุป 3 สิ่งที่ควรนำไปใช้

ดังนั้น สร้างเลย

เริ่มต้นด้วย ML Kit และหากชุดเครื่องมือนี้ทำสิ่งที่คุณต้องการได้อยู่แล้วก็ถือว่าดีมาก

แต่หากไม่รองรับ ให้ใช้ LiteRT สำหรับโมเดลที่กำหนดเอง

อัปเกรดเป็น LiteRT ในบริการ Google Play เพื่อประหยัดพื้นที่ APK และรันไทม์ที่ใช้ร่วมกัน

และลองใช้ CompiledModel API เพื่อการอนุมาน GPU ที่รวดเร็วและง่ายขึ้น

ใช่

ทุกอย่างได้รับการบันทึกไว้ในเว็บไซต์เอกสารประกอบของ LiteRT บน AI Edge ที่ URL ด้านบน

ประมาณนั้น

ขอบคุณที่มาร่วมงานกับเรา และเราแทบจะรอไม่ไหวที่จะได้เห็นสิ่งที่คุณสร้างขึ้น