LiteRT Next là một bộ API mới giúp cải thiện LiteRT, đặc biệt là về hiệu suất và tính năng tăng tốc phần cứng cho các ứng dụng AI và ML trên thiết bị. Các API này là bản phát hành alpha và có sẵn trong Kotlin và C++.
API mô hình đã biên dịch LiteRT Next được xây dựng dựa trên API Trình diễn giải TensorFlow Lite, đồng thời đơn giản hoá quá trình tải và thực thi mô hình cho hoạt động học máy trên thiết bị. Các API mới cung cấp một cách đơn giản mới để sử dụng tính năng tăng tốc phần cứng, không cần phải xử lý FlatBuffers mô hình, khả năng tương tác của vùng đệm I/O và các đại diện. API LiteRT Next không tương thích với API LiteRT. Để sử dụng các tính năng của LiteRT Next, hãy xem hướng dẫn Bắt đầu.
Ví dụ về cách triển khai LiteRT Next, hãy tham khảo các ứng dụng minh hoạ sau:
Quá trình chạy suy luận bằng API LiteRT Next bao gồm các bước chính sau:
Tải một mô hình tương thích.
Phân bổ vùng đệm tensor đầu vào và đầu ra.
Gọi mô hình đã biên dịch.
Đọc các suy luận vào vùng đệm đầu ra.
Các đoạn mã sau đây cho thấy cách triển khai cơ bản của toàn bộ quy trình trong Kotlin và C++.
C++
// Load model and initialize runtimeLITERT_ASSIGN_OR_RETURN(automodel,Model::CreateFromFile("mymodel.tflite"));LITERT_ASSIGN_OR_RETURN(autoenv,Environment::Create({}));LITERT_ASSIGN_OR_RETURN(autocompiled_model,CompiledModel::Create(env,model,kLiteRtHwAcceleratorCpu));// Preallocate input/output buffersLITERT_ASSIGN_OR_RETURN(autoinput_buffers,compiled_model.CreateInputBuffers());LITERT_ASSIGN_OR_RETURN(autooutput_buffers,compiled_model.CreateOutputBuffers());// Fill the first inputfloatinput_values[]={/* your data */};input_buffers[0].Write<float>(absl::MakeConstSpan(input_values,/*size*/));// Invokecompiled_model.Run(input_buffers,output_buffers);// Read the outputstd::vector<float>data(output_data_size);output_buffers[0].Read<float>(absl::MakeSpan(data));
Kotlin
// Load model and initialize runtimevalmodel=CompiledModel.create(context.assets,"mymodel.tflite",CompiledModel.Options(Accelerator.CPU))// Preallocate input/output buffersvalinputBuffers=model.createInputBuffers()valoutputBuffers=model.createOutputBuffers()// Fill the first inputinputBuffers[0].writeFloat(FloatArray(data_size){data_value/* your data */})// Invokemodel.run(inputBuffers,outputBuffers)// Read the outputvaloutputFloatArray=outputBuffers[0].readFloat()
LiteRT Next có các lợi ích và tính năng chính sau:
API LiteRT mới: Tinh giản quá trình phát triển bằng cách lựa chọn trình tăng tốc tự động, thực thi không đồng bộ thực sự và xử lý bộ đệm I/O hiệu quả.
Hiệu suất GPU tốt nhất trong phân khúc: Sử dụng tính năng tăng tốc GPU hiện đại cho công nghệ học máy trên thiết bị. Khả năng tương tác vùng đệm mới cho phép không sao chép và giảm thiểu độ trễ trên nhiều loại vùng đệm GPU.
Suy luận AI tạo sinh vượt trội: Cho phép tích hợp đơn giản nhất với hiệu suất tốt nhất cho các mô hình GenAI.
Tăng tốc NPU hợp nhất: Cung cấp quyền truy cập liền mạch vào các NPU của các nhà cung cấp chipset lớn với trải nghiệm nhất quán cho nhà phát triển. Bạn có thể sử dụng tính năng tăng tốc NPU LiteRT thông qua Chương trình tiếp cận sớm.
Các điểm cải tiến chính
LiteRT Next (API mô hình đã biên dịch) chứa các điểm cải tiến chính sau đây trên LiteRT (API trình diễn giải TFLite). Để xem hướng dẫn toàn diện về cách thiết lập ứng dụng bằng LiteRT Next, hãy xem hướng dẫn Bắt đầu.
Sử dụng trình tăng tốc: Việc chạy mô hình trên GPU bằng LiteRT yêu cầu tạo, gọi hàm và sửa đổi biểu đồ một cách rõ ràng. Với LiteRT
Next, bạn chỉ cần chỉ định trình tăng tốc.
Khả năng tương tác của vùng đệm phần cứng gốc: LiteRT không cung cấp tuỳ chọn vùng đệm và buộc tất cả dữ liệu phải đi qua bộ nhớ CPU. Với LiteRT Next, bạn có thể truyền vào vùng đệm phần cứng Android (AHWB), vùng đệm OpenCL, vùng đệm OpenGL hoặc các vùng đệm chuyên biệt khác.
Thực thi không đồng bộ: LiteRT Next đi kèm với một API không đồng bộ được thiết kế lại, cung cấp một cơ chế không đồng bộ thực sự dựa trên hàng rào đồng bộ hoá. Điều này cho phép thời gian thực thi tổng thể nhanh hơn thông qua việc sử dụng nhiều loại phần cứng – như CPU, GPU, CPU và NPU – cho nhiều tác vụ.
Tải mô hình: LiteRT Next không yêu cầu một bước trình tạo riêng biệt khi tải mô hình.
[[["Dễ hiểu","easyToUnderstand","thumb-up"],["Giúp tôi giải quyết được vấn đề","solvedMyProblem","thumb-up"],["Khác","otherUp","thumb-up"]],[["Thiếu thông tin tôi cần","missingTheInformationINeed","thumb-down"],["Quá phức tạp/quá nhiều bước","tooComplicatedTooManySteps","thumb-down"],["Đã lỗi thời","outOfDate","thumb-down"],["Vấn đề về bản dịch","translationIssue","thumb-down"],["Vấn đề về mẫu/mã","samplesCodeIssue","thumb-down"],["Khác","otherDown","thumb-down"]],["Cập nhật lần gần đây nhất: 2025-09-03 UTC."],[],[],null,["# LiteRT Next Overview\n\n| **Experimental:** LiteRT Next is an alpha release and under active development.\n\nLiteRT Next is a new set of APIs that improves upon LiteRT, particularly in\nterms of hardware acceleration and performance for on-device ML and AI\napplications. The APIs are an alpha release and available in Kotlin and C++.\n\nThe LiteRT Next Compiled Model API builds on the TensorFlow Lite Interpreter\nAPI, and simplifies the model loading and execution process for on-device\nmachine learning. The new APIs provide a new streamlined way to use hardware\nacceleration, removing the need to deal with model FlatBuffers, I/O buffer\ninteroperability, and delegates. The LiteRT Next APIs are not compatible with\nthe LiteRT APIs. In order to use features from LiteRT Next, see the [Get\nStarted](./get_started) guide.\n\nFor example implementations of LiteRT Next, refer to the following demo\napplications:\n\n- [Image segmentation with Kotlin](https://github.com/google-ai-edge/LiteRT/tree/main/litert/samples/image_segmentation/kotlin_cpu_gpu/android)\n- [Asynchronous segmentation with C++](https://github.com/google-ai-edge/LiteRT/tree/main/litert/samples/async_segmentation)\n\nQuickstart\n----------\n\nRunning inference with the LiteRT Next APIs involves the following key steps:\n\n1. Load a compatible model.\n2. Allocate the input and output tensor buffers.\n3. Invoke the compiled model.\n4. Read the inferences into an output buffer.\n\nThe following code snippets show a basic implementation of the entire process in\nKotlin and C++. \n\n### C++\n\n // Load model and initialize runtime\n LITERT_ASSIGN_OR_RETURN(auto model, Model::CreateFromFile(\"mymodel.tflite\"));\n LITERT_ASSIGN_OR_RETURN(auto env, Environment::Create({}));\n LITERT_ASSIGN_OR_RETURN(auto compiled_model,\n CompiledModel::Create(env, model, kLiteRtHwAcceleratorCpu));\n\n // Preallocate input/output buffers\n LITERT_ASSIGN_OR_RETURN(auto input_buffers, compiled_model.CreateInputBuffers());\n LITERT_ASSIGN_OR_RETURN(auto output_buffers, compiled_model.CreateOutputBuffers());\n\n // Fill the first input\n float input_values[] = { /* your data */ };\n input_buffers[0].Write\u003cfloat\u003e(absl::MakeConstSpan(input_values, /*size*/));\n\n // Invoke\n compiled_model.Run(input_buffers, output_buffers);\n\n // Read the output\n std::vector\u003cfloat\u003e data(output_data_size);\n output_buffers[0].Read\u003cfloat\u003e(absl::MakeSpan(data));\n\n### Kotlin\n\n // Load model and initialize runtime\n val model =\n CompiledModel.create(\n context.assets,\n \"mymodel.tflite\",\n CompiledModel.Options(Accelerator.CPU)\n )\n\n // Preallocate input/output buffers\n val inputBuffers = model.createInputBuffers()\n val outputBuffers = model.createOutputBuffers()\n\n // Fill the first input\n inputBuffers[0].writeFloat(FloatArray(data_size) { data_value /* your data */ })\n\n // Invoke\n model.run(inputBuffers, outputBuffers)\n\n // Read the output\n val outputFloatArray = outputBuffers[0].readFloat()\n\nFor more information, see the [Get Started with Kotlin](./android_kotlin) and\n[Get Started with C++](./android_cpp) guides.\n\nKey features\n------------\n\nLiteRT Next contains the following key benefits and features:\n\n- **New LiteRT API**: Streamline development with automated accelerator selection, true async execution, and efficient I/O buffer handling.\n- **Best-in-class GPU Performance**: Use state-of-the-art GPU acceleration for on-device ML. The new buffer interoperability enables zero-copy and minimizes latency across various GPU buffer types.\n- **Superior Generative AI inference**: Enable the simplest integration with the best performance for GenAI models.\n- **Unified NPU Acceleration** : Offer seamless access to NPUs from major chipset providers with a consistent developer experience. LiteRT NPU acceleration is available through an [Early Access\n Program](https://forms.gle/CoH4jpLwxiEYvDvF6).\n\nKey improvements\n----------------\n\nLiteRT Next (Compiled Model API) contains the following key improvements on\nLiteRT (TFLite Interpreter API). For a comprehensive guide to setting up your\napplication with LiteRT Next, see the [Get Started](./get_started) guide.\n\n- **Accelerator usage**: Running models on GPU with LiteRT requires explicit delegate creation, function calls, and graph modifications. With LiteRT Next, just specify the accelerator.\n- **Native hardware buffer interoperability**: LiteRT does not provide the option of buffers, and forces all data through CPU memory. With LiteRT Next, you can pass in Android Hardware Buffers (AHWB), OpenCL buffers, OpenGL buffers, or other specialized buffers.\n- **Async execution**: LiteRT Next comes with a redesigned async API, providing a true async mechanism based on sync fences. This enables faster overall execution times through the use of diverse hardware -- like CPUs, GPUs, CPUs, and NPUs -- for different tasks.\n- **Model loading**: LiteRT Next does not require a separate builder step when loading a model."]]
