ยินดีต้อนรับสู่ภาพรวม LiteRT

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

การเปิดตัว LiteRT 2.x ล่าสุดได้นำ CompiledModel API มาใช้ ซึ่งเป็นอินเทอร์เฟซรันไทม์ที่ทันสมัยซึ่งออกแบบมาเพื่อเพิ่มการเร่งด้วยฮาร์ดแวร์ให้ได้สูงสุด แม้ว่า Interpreter API (เดิมคือ TensorFlow Lite) จะยังคงพร้อมใช้งานเพื่อความเข้ากันได้แบบย้อนหลัง แต่ CompiledModel API เป็นตัวเลือกที่แนะนำสำหรับนักพัฒนาแอปที่ต้องการประสิทธิภาพที่ล้ำสมัยในแอปพลิเคชัน AI ในอุปกรณ์

ฟีเจอร์หลักของ LiteRT

เพิ่มประสิทธิภาพการพัฒนาด้วย LiteRT

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

ประสิทธิภาพ GPU ที่ดีที่สุด

ขับเคลื่อนโดย ML Drift ซึ่งตอนนี้รองรับทั้งโมเดล ML และ Generative AI ใน API ของ GPU ดูเอกสารประกอบเกี่ยวกับการเร่ง GPU

การเร่งความเร็ว NPU แบบรวม

เร่งความเร็วโมเดลโดยใช้การเข้าถึง NPU ที่ง่ายขึ้นจากผู้ให้บริการชิปเซ็ตรายใหญ่ ดูเอกสารประกอบเกี่ยวกับการเร่งความเร็ว NPU

การสนับสนุน LLM ที่เหนือกว่า

LiteRT ช่วยให้ติดตั้งใช้งานโมเดล Generative AI ประสิทธิภาพสูงในแพลตฟอร์มต่างๆ ได้แก่ อุปกรณ์เคลื่อนที่ เดสก์ท็อป และเว็บ ดูเอกสารประกอบการติดตั้งใช้งาน GenAI

การรองรับเฟรมเวิร์ก ML อย่างกว้างขวาง

LiteRT รองรับการแปลงจากเฟรมเวิร์ก PyTorch, TensorFlow และ JAX เป็นรูปแบบ .tflite หรือ .litertlm ได้อย่างมีประสิทธิภาพ ดูเอกสารประกอบเกี่ยวกับการแปลงโมเดล

เวิร์กโฟลว์การพัฒนา

LiteRT จะเรียกใช้การอนุมานในอุปกรณ์อย่างสมบูรณ์บน Android, iOS, เว็บ, IoT และบนเดสก์ท็อป/แล็ปท็อป ไม่ว่าจะเป็นอุปกรณ์ใด เวิร์กโฟลว์ที่พบบ่อยที่สุดมีดังนี้ พร้อมลิงก์ไปยังวิธีการเพิ่มเติม

ระบุโซลูชันที่เหมาะสมที่สุดสำหรับความท้าทายด้าน ML

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

รับและเตรียมโมเดล

โมเดล LiteRT จะแสดงในรูปแบบแบบพกพาที่มีประสิทธิภาพซึ่งเรียกว่า FlatBuffers ซึ่งใช้.tflite นามสกุลไฟล์

คุณขอรับโมเดล LiteRT ได้ด้วยวิธีต่อไปนี้

• รับโมเดลที่ฝึกไว้ล่วงหน้า: สำหรับภาระงาน ML ยอดนิยม เช่น การแบ่งกลุ่มรูปภาพ การตรวจหาออบเจ็กต์ เป็นต้น

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

  ประเภทโมเดล	แหล่งที่มาของโมเดลที่ฝึกไว้ล่วงหน้า
  ML แบบคลาสสิก (รูปแบบ .tflite)	ไปที่ Kaggle หรือ HuggingFace เช่น โมเดลการแบ่งกลุ่มรูปภาพและแอปตัวอย่าง
  Generative AI (.litertlm รูปแบบ)	หน้า LiteRT ของ Hugging Face เช่น Gemma Family

• แปลงโมเดล PyTorch, TensorFlow หรือ JAX ที่เลือกเป็นโมเดล LiteRT หากเลือกที่จะไม่ใช้โมเดลที่ฝึกไว้ล่วงหน้า [PRO USER]

  เฟรมเวิร์กโมเดล	โมเดลตัวอย่าง	เครื่องมือ Conversion
  Pytorch	Hugging Face Torchvision	ลิงก์
  TensorFlow	โมเดล Kaggle Hugging Face	ลิงก์
  Jax	Hugging Face	ลิงก์

• สร้าง LLM เพื่อเพิ่มประสิทธิภาพเพิ่มเติมโดยใช้ Generative API [ผู้ใช้ PRO]

  ไลบรารี Generative API มีบล็อกการสร้างในตัวของ PyTorch สำหรับการเขียนโมเดล Transformer เช่น Gemma, TinyLlama และอื่นๆ โดยใช้การแยกส่วนที่เหมาะกับอุปกรณ์เคลื่อนที่ ซึ่งเราสามารถรับประกันการแปลง และการดำเนินการที่มีประสิทธิภาพในรันไทม์บนอุปกรณ์เคลื่อนที่ของเราอย่าง LiteRT ดูเอกสารประกอบเกี่ยวกับ Generative API

ควอนไทเซชัน [ผู้ใช้ PRO]

AI Edge Quantizer สำหรับนักพัฒนาซอฟต์แวร์ขั้นสูงเป็นเครื่องมือสำหรับ Quantize โมเดล LiteRT ที่แปลงแล้ว โดยมีเป้าหมายเพื่อช่วยให้ผู้ใช้ขั้นสูงสามารถมุ่งมั่นที่จะได้รับประสิทธิภาพสูงสุด ในโมเดลที่ต้องการทรัพยากรสูง (เช่น โมเดล GenAI)

ดูรายละเอียดเพิ่มเติมได้จากเอกสารประกอบเกี่ยวกับ AI Edge Quantizer

ผสานรวมโมเดลเข้ากับแอปในแพลตฟอร์ม Edge

LiteRT ช่วยให้คุณเรียกใช้โมเดล ML บนอุปกรณ์ได้อย่างเต็มรูปแบบด้วยประสิทธิภาพสูง ในแพลตฟอร์ม Android, iOS, เว็บ, เดสก์ท็อป และ IoT

ใช้คำแนะนำต่อไปนี้เพื่อผสานรวมโมเดล LiteRT ในแพลตฟอร์มที่ต้องการ

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

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

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

// Fill the input buffer
inputBuffers.get(0).writeFloat(input0)
inputBuffers.get(1).writeFloat(input1)

// Invoke
compiledModel.run(inputBuffers, outputBuffers)

// Read the output
val output = outputBuffers.get(0).readFloat()

// Load model and initialize runtime
LITERT_ASSIGN_OR_RETURN(auto env, GetEnvironment());
LITERT_ASSIGN_OR_RETURN(auto options, GetOptions());
LITERT_ASSIGN_OR_RETURN(
    auto compiled_model,
    CompiledModel::Create(env, "/path/to/mymodel.tflite", options));

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

// Fill the input buffer
LITERT_ABORT_IF_ERROR(input_buffers[0].Write(input0));
LITERT_ABORT_IF_ERROR(input_buffers[1].Write(input1));

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

// Read the output
LITERT_ABORT_IF_ERROR(output_buffers[0].Read(output0));

เลือกตัวเร่งฮาร์ดแวร์

วิธีที่ตรงไปตรงมาที่สุดในการรวมแบ็กเอนด์ใน LiteRT คือการใช้ประโยชน์จาก ปัญญาประดิษฐ์ (AI) ในตัวของรันไทม์ CompiledModel API ของ LiteRT ช่วยให้การตั้งค่าง่ายขึ้นอย่างมากด้วยความสามารถในการระบุ แบ็กเอนด์เป้าหมายเป็นตัวเลือก ดูรายละเอียดเพิ่มเติมได้ที่คู่มือการอนุมานในอุปกรณ์

เอกสารและการสนับสนุนเพิ่มเติม

• ที่เก็บ GitHub ของ LiteRT-Samples สำหรับแอปตัวอย่าง LiteRT เพิ่มเติม

• สำหรับผู้ใช้ TensorFlow Lite อยู่แล้ว โปรดดูคำแนะนำในการย้ายข้อมูล

• หน้าเครื่องมือ LiteRT สำหรับประสิทธิภาพ การสร้างโปรไฟล์ การรายงานข้อผิดพลาด ฯลฯ