Giới thiệu LiteRT Next: Một bộ API mới giúp cải thiện và đơn giản hoá tính năng tăng tốc phần cứng trên thiết bị.

Trang này được dịch bởi Cloud Translation API.

Tổng quan về LiteRT Next

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:

Bắt đầu nhanh

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 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));

Kotlin

// 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()

Để biết thêm thông tin, hãy xem hướng dẫn Bắt đầu sử dụng Kotlin và Bắt đầu sử dụng C++.

Tính năng chính

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.