NPU Intel (OpenVino) có LiteRT

LiteRT hỗ trợ Intel OpenVino thông qua API CompiledModel cho cả AOT và quá trình biên dịch trên thiết bị.

Python API

Thiết lập môi trường phát triển

Linux (x86_64):

• Ubuntu 22.04 hoặc 24.04 LTS
• Python 3.10 trở lên – cài đặt từ python.org hoặc bản phân phối của bạn (sudo apt install python3 python3-venv)
• Trình điều khiển NPU của Intel v1.32.1 – xem phần Thiết lập NPU trên Linux

Windows (x86_64):

• Windows 10 hoặc 11
• Python 3.10 trở lên – cài đặt từ python.org
• Trình điều khiển NPU của Intel 32.0.100.4724+ – xem phần Thiết lập NPU trên Windows

Để tạo từ nguồn, bạn cũng cần Bazel 7.4.1 trở lên bằng Bazelisk hoặc bản dựng Docker khép kín.

SoC được hỗ trợ

Bắt đầu nhanh

1. Cài đặt trình điều khiển NPU

Xem phần Thiết lập NPU trên Linux hoặc Thiết lập NPU trên Windows. Bỏ qua nếu bạn chỉ cần AOT.

Bạn chỉ cần trình điều khiển NPU trên những hệ thống thực thi mô hình trên phần cứng NPU. Các hệ thống chỉ tạo AOT có thể bỏ qua bước này.

Lưu ý: ai-edge-litert-sdk-intel-nightly ghim bánh xe OpenVINO phù hợp theo phiên bản PEP 440 (ví dụ: openvino==2026.2.0.dev20260506), vì vậy pip cần --extra-index-url https://storage.openvinotoolkit.org/simple/wheels/nightly để xác định vị trí của bánh xe này. Trên Linux, nếu tính năng tự động phát hiện bản phân phối chọn sai tệp lưu trữ, hãy đặt LITERT_OV_OS_ID=ubuntu22 hoặc ubuntu24 trước pip install.

2. Tạo môi trường ảo Python

Bạn nên giữ bánh xe openvino hằng đêm tách biệt với mọi bản cài đặt OpenVINO trên toàn hệ thống.

python -m venv litert_env
# Linux / macOS
source litert_env/bin/activate
# Windows (PowerShell)
.\litert_env\Scripts\Activate.ps1

python -m pip install --upgrade pip

3. Cài đặt gói pip

pip install --pre \
    --extra-index-url https://storage.openvinotoolkit.org/simple/wheels/nightly \
    ai-edge-litert-nightly ai-edge-litert-sdk-intel-nightly

--extra-index-url cho phép pip phân giải bánh xe openvino được ghim hằng đêm từ chỉ mục của OpenVINO cùng với các gói trên PyPI.

4. Xác minh quá trình cài đặt

python -c "
from ai_edge_litert.aot.vendors.intel_openvino import intel_openvino_backend
import ai_edge_litert_sdk_intel, openvino, os
print('Backend:', intel_openvino_backend.IntelOpenVinoBackend.id())
print('Dispatch:', intel_openvino_backend.get_dispatch_dir())
print('OpenVINO:', openvino.__version__)
print('SDK libs:', sorted(os.listdir(ai_edge_litert_sdk_intel.path_to_sdk_libs())))
print('Available devices:', openvino.Core().available_devices)
"

Nội dung cần kiểm tra trong kết quả đầu ra:

• SDK libs lists libopenvino_intel_npu_compiler.so (Linux) hoặc openvino_intel_npu_compiler.dll (Windows) – bắt buộc đối với AOT.
• Available devices bao gồm NPU – xác nhận rằng trình điều khiển NPU đã được cài đặt và OpenVINO có thể giao tiếp với thiết bị. NPU sẽ không có trên các hệ thống chỉ có AOT (nơi trình điều khiển không được cài đặt) và trên các hệ thống không có phần cứng NPU của Intel.

5. Biên dịch AOT (Không bắt buộc)

• Biên dịch trước một .tflite cho một mục tiêu NPU cụ thể của Intel (PTL hoặc LNL) để thời gian chạy bỏ qua bước trình bổ trợ trình biên dịch.
• Không cần NPU thực hoặc trình điều khiển NPU — chỉ cần ai-edge-litert-nightly và ai-edge-litert-sdk-intel-nightly.
• Hỗ trợ biên dịch chéo: biên dịch trên mọi máy chủ lưu trữ Linux hoặc Windows, chuyển .tflite kết quả đến một mục tiêu của một trong hai hệ điều hành và chạy kết quả đó ở đó.

Tệp đầu ra có tên là <model>_IntelOpenVINO_<SoC>_apply_plugin.tflite.

from ai_edge_litert.aot import aot_compile
from ai_edge_litert.aot.vendors.intel_openvino import target as intel_target

# Compile for a single Intel NPU target (PTL or LNL).
aot_compile.aot_compile(
    "model.tflite",
    output_dir="out",
    target=intel_target.Target(soc_model=intel_target.SocModel.PTL),
)

# Or omit target= to compile for every registered backend/target.
aot_compile.aot_compile("model.tflite", output_dir="out", keep_going=True)

6. Chạy suy luận NPU

LiteRT hỗ trợ hai đường dẫn suy luận trên NPU của Intel:

• JIT – tải một .tflite thô; trình bổ trợ trình biên dịch phân vùng và biên dịch các hoạt động được hỗ trợ cho NPU tại thời điểm CompiledModel.from_file(). Tăng độ trễ khi chạy lần đầu (tuỳ theo mô hình).
• Được biên dịch AOT – tải một <model>_IntelOpenVINO_<SoC>_apply_plugin.tflite do bước 4 tạo ra. Bỏ qua bước phân vùng và biên dịch tại thời gian tải.

Đoạn mã này hoạt động cho cả:

from ai_edge_litert.compiled_model import CompiledModel
from ai_edge_litert.hardware_accelerator import HardwareAccelerator

model = CompiledModel.from_file(
    "model.tflite",  # raw tflite (JIT) or ..._apply_plugin.tflite (AOT)
    hardware_accel=HardwareAccelerator.NPU | HardwareAccelerator.CPU,
)

sig_key = list(model.get_signature_list().keys())[0]
sig_idx = model.get_signature_index(sig_key)
input_buffers = model.create_input_buffers(sig_idx)
output_buffers = model.create_output_buffers(sig_idx)
model.run_by_index(sig_idx, input_buffers, output_buffers)
print("Fully accelerated:", model.is_fully_accelerated())

Xác nhận rằng JIT thực sự đã chạy

Khi JIT thành công, nhật ký sẽ chứa (phần mở rộng tệp là .so trên Linux, .dll trên Windows):

INFO: [compiler_plugin.cc:236] Loaded plugin at: .../LiteRtCompilerPlugin_IntelOpenvino.{so,dll}
INFO: [compiler_plugin.cc:690] Partitioned subgraph<0>, selected N ops, from a total of N ops
INFO: [compiled_model.cc:1006] JIT compilation changed model, reserializing...

Nếu không có những dòng đó nhưng Fully accelerated: True vẫn được báo cáo, thì mô hình đã chạy trên cơ chế dự phòng CPU XNNPACK, chứ không phải trên NPU – hãy xem hàng khắc phục sự cố JIT.

7. Benchmark (Điểm chuẩn)

# Dispatch library and the NPU compiler are auto-discovered from the wheel.
litert-benchmark --model=model.tflite --use_npu --num_runs=50

Các cờ cảnh báo phổ biến:

Cờ nâng cao / ghi đè – chỉ cần thiết để trỏ đến các bản dựng tuỳ chỉnh: --dispatch_library_path, --compiler_plugin_path, --runtime_path.

Bánh xe của nhiều nhà cung cấp: ghim JIT vào Intel OV

Lưu ý: Khi Environment.create() được gọi mà không có đường dẫn rõ ràng, nó sẽ tự động phát hiện các nhà cung cấp trong ai_edge_litert/vendors/ theo thứ tự bảng chữ cái và đăng ký nhà cung cấp đầu tiên mà nó tìm thấy. Trong quá trình cài đặt của nhiều nhà cung cấp, đây có thể không phải là Intel OV — hãy truyền các thư mục Intel OV một cách rõ ràng để buộc chọn đúng.

• Trình biên dịch pip wheel ships cho mọi nhà cung cấp đã đăng ký (intel_openvino/, google_tensor/, mediatek/, qualcomm/, samsung/).
• Để bắt buộc đường dẫn Intel OV (nên dùng khi bạn cài đặt nhiều SDK của nhà cung cấp), hãy truyền các thư mục Intel OV theo cách thủ công:

from ai_edge_litert.environment import Environment
from ai_edge_litert.compiled_model import CompiledModel
from ai_edge_litert.hardware_accelerator import HardwareAccelerator
from ai_edge_litert.aot.vendors.intel_openvino import intel_openvino_backend as ov

env = Environment.create(
    compiler_plugin_path=ov.get_compiler_plugin_dir(),   # JIT compiler
    dispatch_library_path=ov.get_dispatch_dir(),          # runtime
)
model = CompiledModel.from_file(
    "model.tflite",
    hardware_accel=HardwareAccelerator.NPU | HardwareAccelerator.CPU,
    environment=env,
)

Thời gian chạy tải mọi thư viện dùng chung mà nó tìm thấy trong thư mục đã cho, vì vậy, việc trỏ đến vendors/intel_openvino/compiler/ chỉ tải trình bổ trợ Intel; các trình bổ trợ Google Tensor / MediaTek / Qualcomm / Samsung trong các thư mục ngang hàng sẽ không bao giờ được chạm đến.

Đối với CLI, các cờ tương đương là:

DISPATCH_DIR=$(python3 -c 'from ai_edge_litert.aot.vendors.intel_openvino import intel_openvino_backend as ov; print(ov.get_dispatch_dir())')
COMPILER_DIR=$(python3 -c 'from ai_edge_litert.aot.vendors.intel_openvino import intel_openvino_backend as ov; print(ov.get_compiler_plugin_dir())')

litert-benchmark --model=model.tflite --use_npu \
    --compiler_plugin_path=$COMPILER_DIR \
    --dispatch_library_path=$DISPATCH_DIR

Xác minh việc thực thi NPU

Để xác nhận rằng mô hình thực sự chạy trên NPU, hãy kiểm tra cả hai tín hiệu:

1. Nhật ký chứa Loading shared library: .../LiteRtDispatch_IntelOpenvino.{so,dll} – thư viện điều phối Intel đã được tải (.so trên Linux, .dll trên Windows).
2. model.is_fully_accelerated() trả về True – mọi thao tác đều được chuyển sang bộ tăng tốc đã chọn.

Chỉ is_fully_accelerated() là không đủ: nếu thư viện điều phối không bao giờ được tải, thì các thao tác sẽ được chuyển hoàn toàn sang XNNPACK/CPU, chứ không phải NPU.

Thiết lập NPU trên Linux

Lưu ý: Bỏ qua phần này nếu bạn chỉ cần AOT – không bắt buộc phải có NPU thực.

Thông tin: Sử dụng trình điều khiển NPU v1.32.1 (kết hợp với OpenVINO 2026.1). Các trình điều khiển cũ hơn sẽ không hoạt động với Level0 pfnCreate2 result: ZE_RESULT_ERROR_UNSUPPORTED_FEATURE.

# 1. NPU driver (Ubuntu 24.04 use -ubuntu2204 tarball for 22.04).
sudo dpkg --purge --force-remove-reinstreq \
  intel-driver-compiler-npu intel-fw-npu intel-level-zero-npu intel-level-zero-npu-dbgsym || true
wget https://github.com/intel/linux-npu-driver/releases/download/v1.32.1/linux-npu-driver-v1.32.1.20260422-24767473183-ubuntu2404.tar.gz
tar -xf linux-npu-driver-v1.32.1.*.tar.gz
sudo apt update && sudo apt install -y libtbb12
sudo dpkg -i intel-fw-npu_*.deb intel-level-zero-npu_*.deb intel-driver-compiler-npu_*.deb

# 2. Level Zero loader v1.27.0.
wget https://snapshot.ppa.launchpadcontent.net/kobuk-team/intel-graphics/ubuntu/20260324T100000Z/pool/main/l/level-zero-loader/libze1_1.27.0-1~24.04~ppa2_amd64.deb
sudo dpkg -i libze1_*.deb

# 3. Permissions + verify.
sudo gpasswd -a ${USER} render && newgrp render
ls /dev/accel/accel0   # must exist after reboot

Sau đó, hãy chạy đoạn mã cài đặt + xác minh trong phần Bắt đầu nhanh.

Thiết lập NPU trên Windows

Lưu ý: Bỏ qua phần này nếu bạn chỉ cần AOT – không bắt buộc phải có NPU thực.

• Cài đặt trình điều khiển NPU của Intel (32.0.100.4724+) từ Trung tâm tải xuống của Intel.
• Xác minh rằng Trình quản lý thiết bị liệt kê thiết bị NPU trong phần Bộ xử lý thần kinh (hiển thị dưới dạng Intel(R) AI Boost hoặc Intel(R) NPU tuỳ thuộc vào trình điều khiển).
• Chạy đoạn mã cài đặt + xác minh từ Bắt đầu nhanh, thay thế pip bằng python -m pip.

Thông tin: import ai_edge_litert tự động đăng ký các thư mục DLL bằng os.add_dll_directory(), nên các tập lệnh Python không cần thiết lập PATH. Đối với những người dùng không phải Python, hãy chạy setupvars.bat hoặc thêm <openvino>/libs vào trước PATH.

Tạo từ nguồn

Bạn đang sử dụng proxy? Xuất http_proxy / https_proxy / no_proxy trước khi chạy tập lệnh bản dựng – các tập lệnh này sẽ chuyển tiếp các biến môi trường này vào Docker và vùng chứa.

Linux (Docker, khép kín):

cd LiteRT/docker_build && ./build_wheel_with_docker.sh

Windows (PowerShell, Bazel trong PATH):

.\ci\build_pip_package_with_bazel_windows.ps1

Kết quả đầu ra sẽ nằm trong dist/:

• ai_edge_litert-*.whl – bánh xe thời gian chạy.
• ai_edge_litert_sdk_{intel,qualcomm,mediatek,samsung}-*.tar.gz – vendor sdists.
• Intel sdist có kích thước khoảng 5 KB; trình biên dịch NPU .so/.dll được tìm nạp tại thời điểm pip install, vì vậy, cùng một sdist hoạt động trên cả Linux và Windows.

Kiểm thử đơn vị

bazel test \
  //litert/python/aot/vendors/intel_openvino:intel_openvino_backend_test \
  //litert/c/options:litert_intel_openvino_options_test \
  //litert/cc/options:litert_intel_openvino_options_test \
  //litert/tools/flags/vendors:intel_openvino_flags_test

Khắc phục sự cố

Các điểm hạn chế

Chỉ thiết bị NPU được hỗ trợ thông qua đường dẫn điều phối OpenVINO. Đối với suy luận CPU, chỉ sử dụng HardwareAccelerator.CPU (XNNPACK).

C++ API

Điều kiện tiên quyết và cách thiết lập bản dựng

Điều kiện tiên quyết để xây dựng:

• Visual Studio 2022 trở lên (bạn phải cài đặt các công cụ phát triển C++).
• git: Cài đặt git từ https://git-scm.com/install/. Đảm bảo rằng C:\Program Files\Git\bin and C:\Program Files\Git\cmd có trong biến môi trường PATH của hệ thống để cho phép các quy trình tạo LiteRT/LiteRT-LM xác định vị trí của bash.exe và git.exe.
• bazelisk: Cài đặt bazelisk và thêm vị trí của bazelisk vào biến môi trường PATH của hệ thống: https://bazel.build/install/bazelisk.
• Cmake: Cài đặt Cmake phiên bản 4.3.0 trở lên từ https://cmake.org/download/, xác minh rằng Cmake có trong PATH của hệ thống.
• Python: Đảm bảo bạn đã cài đặt python 3.11 trở lên và python.exe nằm trong PATH.
• Cài đặt Windows: Bật Chế độ nhà phát triển trong phần Cài đặt Windows.

Tạo các công cụ và trình bổ trợ LiteRT cho NPU của Intel

Để chạy các mô hình trên NPU Intel bằng LiteRT, bạn phải biên dịch các mô hình đó bằng trình bổ trợ trình biên dịch LiteRT Intel OpenVINO; Hơn nữa, mọi mô hình đã biên dịch dự kiến thực thi trên NPU Intel đều phải được uỷ quyền cho trình bổ trợ điều phối LiteRT Intel OpenVINO.

Cơ chế mà LiteRT gọi các trình bổ trợ này sẽ được minh hoạ sau đây:

Các bước để tạo các công cụ LiteRT và trình bổ trợ Intel.

Trước khi bạn tạo bất kỳ tệp thực thi hoặc thư viện nào từ LiteRT, hãy tạo một thư mục cục bộ, chẳng hạn như C:\bzl. Tệp nhị phân đầu ra của bản dựng sẽ được thu thập từ thư mục này. Tạo trình bổ trợ điều phối Intel OpenVINO

# At the top-level directory of LiteRT repository
bazelisk --output_base=C:\bzl build //litert/vendors/intel_openvino/dispatch:LiteRtDispatch --config=windows

Ngoài ra, bạn cũng có thể tạo trình bổ trợ điều phối từ kho lưu trữ LiteRT-LM bằng cách thêm tiền tố @litert vào mục tiêu. Điều này tương tự đối với tất cả các mục tiêu sau đây trong kho lưu trữ LiteRT.

# At the top-level directory of LiteRT-LM repository
bazelisk --output_base=C:\bzl build @litert//litert/vendors/intel_openvino/dispatch:LiteRtDispatch --config=windows

Tạo trình bổ trợ trình biên dịch Intel OpenVINO

bazelisk --output_base=C:\bzl build //litert/vendors/intel_openvino/compiler:LiteRtCompilerPlugin --config=windows

Tạo tiện ích trình biên dịch Trước khi thực thi (AOT) LiteRT Một số công cụ LiteRT yêu cầu biên dịch AOT rõ ràng các mô hình trước khi chạy chúng trên NPU của Intel. Hướng dẫn tạo tiện ích trình biên dịch AOT LiteRT:

bazelisk --output_base=C:\bzl build
//litert/tools:apply_plugin_main --config=windows

Tạo trình chạy mô hình LiteRT Trình chạy mô hình LiteRT có thể được dùng để chạy một mô hình trên NPU của Intel, có thể là mô hình chưa được biên dịch trước hoặc mô hình được biên dịch AOT. Hướng dẫn tạo trình chạy mô hình:

bazelisk --output_base=C:\bzl build //litert/tools:run_model --config=windows

Tạo tiện ích mô hình điểm chuẩn LiteRT. Bạn có thể dùng công cụ điểm chuẩn mô hình LiteRT để đo điểm chuẩn hiệu suất suy luận của một mô hình trên NPU của Intel. Nếu hướng dẫn cách tạo công cụ đo điểm chuẩn:

bazelisk --output_base=C:\bzl build //litert/tools:benchmark_model --config=windows --define=protobuf_allow_msvc=true

Tạo tiện ích kiểm tra số LiteRT

bazelisk --output_base=C:\bzl build //litert/tools:npu_numerics_check --config=windows

Cách sử dụng nâng cao: tạo bằng Intel OpenVINO SDK tuỳ chỉnh

Hệ thống xây dựng LiteRT sẽ tự động tìm nạp Intel OpenVINO SDK được tạo sẵn khi biên dịch trình biên dịch và các trình bổ trợ điều phối.

Nếu dự án của bạn yêu cầu một phiên bản cụ thể hoặc tuỳ chỉnh của Intel OpenVINO SDK, hãy hoàn tất các bước định cấu hình bổ sung này trước khi bắt đầu quy trình tạo bản dựng trình bổ trợ:

1. Tải tệp nhị phân phát hành OpenVINO mới nhất cho Windows xuống từ https://www.intel.com/content/www/us/en/download/753640/intel-distribution-of-openvino-toolkit.html, rồi trích xuất tệp đó vào ổ đĩa cục bộ, ví dụ: C:\Intel\intel_openvino.
2. Đảm bảo thư mục con duy nhất trong đường dẫn này có tên là "openvino", chứa các thư mục con như "runtime" và "include".
3. Chuyển đến thư mục gốc của kho lưu trữ LiteRT đã sao chép trong bảng điều khiển (dấu nhắc lệnh hoặc PowerShell) và đặt biến OPENVINO_NATIVE_DIR (đảm bảo không có dấu \`), for example: ở cuối đặt OPENVINO_NATIVE_DIR=C:\Intel\intel_openvino`

Biên dịch AOT của các mô hình tuỳ chỉnh

Phần này chuẩn bị môi trường và thực hiện biên dịch AOT các mô hình TFLite, PyTorch hoặc JAX tuỳ chỉnh cho LiteRT.

Trong quá trình biên dịch mô hình cho NPU Intel, LiteRT sẽ xác thực biểu đồ mô hình dựa trên các toán tử mà trình bổ trợ trình biên dịch LiteRT Intel OpenVINO hỗ trợ. Đối với các toán tử hoặc đồ thị con tương thích với trình bổ trợ trình biên dịch, LiteRT sẽ biên dịch từng đồ thị con như vậy thành một DISPATCH_OP, sau đó thay thế đồ thị con ban đầu trong đồ thị. Các toán tử không có trong opset được trình biên dịch Intel OpenVINO hỗ trợ vẫn không thay đổi trong biểu đồ. Do đó, quá trình biên dịch AOT có thể tạo ra một mô hình được uỷ quyền hoàn toàn hoặc một mô hình được uỷ quyền một phần. Dưới đây là ví dụ về mô hình được biên dịch AOT được uỷ quyền hoàn toàn:

Tiện ích LiteRT apply_plugin_main (apply_plugin_main.exe) là tiện ích biên dịch AOT mà bạn có thể sử dụng cho mục đích này. Ví dụ về cách sử dụng tiện ích trên nền tảng Intel:

.\apply_plugin_main.exe -cmd apply --model="C:\models\model.tflite" -o C:\models\model_aot.tflite --soc_model=PTL --soc_manufacturer "IntelOpenVINO" --libs C:\litertlibs  

Xin lưu ý rằng trình biên dịch NPU cơ bản mặc định (có trong bản phân phối nhị phân của Intel OpenVINO SDK) được dùng cho Intel Core Ultra Series 2 và các SoC tiếp theo. Nếu một mô hình đang được biên dịch cho một NPU không có trong danh sách được hỗ trợ, thì bạn phải chỉ định rõ ràng loại trình biên dịch (mặc dù đây vẫn là lựa chọn không bắt buộc đối với Intel Core Ultra 2 trở lên).

set IE_NPU_COMPILER_TYPE=PLUGIN

Biên dịch JIT so với AOT trong ứng dụng

Để biên dịch các mô hình trong ứng dụng LiteRT của riêng bạn, có 2 phương pháp: biên dịch AOT mà chúng tôi đã giới thiệu và biên dịch Just-in-time (JIT).

Với quá trình biên dịch AOT, chế độ này được biên dịch ngoại tuyến trước khi triển khai và có thể được lưu để sử dụng sau này – thường được dùng khi quá trình biên dịch tiêu tốn quá nhiều tài nguyên để chạy trên thiết bị. Bạn không cần thực hiện việc này trên cùng một thiết bị mà bạn đang triển khai mô hình. Ví dụ về quá trình biên dịch AOT trong mã của bạn:

void AotCompileForOpenVINO() {
  auto run = std::make_unique<ApplyPluginRun>();

  // Full pipeline: partition → compile → embed bytecode in .tflite
  run->cmd = ApplyPluginRun::Cmd::APPLY;

  // Path to directory containing LiteRtComplilerPlugin.dll
  run->lib_search_paths.push_back("/path/to/plugin/dir/");

  // Input model
  run->model.emplace("model.tflite");

  // Intel OpenVINO target
  run->soc_manufacturer.emplace("IntelOpenVINO");
  run->soc_models.push_back("PTL");  // or "LNL"

  // Output stream for the AOT-compiled model
  std::stringstream compiled_output;
  run->outs.push_back(compiled_output);

  // Run AOT compilation
  auto status = ApplyPlugin(std::move(run));
  // compiled_output now contains .tflite with embedded OpenVINO bytecode
}

Cách suy luận bằng mô hình được biên dịch AOT:

void RunAotCompiledModel() {
  auto env = litert::Environment::Create({}).value();

  // Load AOT-compiled model, still must specify NPU accelerator
  auto compiled_model = litert::CompiledModel::Create(
      env, "model_aot.tflite", litert::HwAccelerators::kNpu).value();

  auto input_buffers = compiled_model.CreateInputBuffers().value();
  auto output_buffers = compiled_model.CreateOutputBuffers().value();

  input_buffers[0].Write<float>({/* data */});
  compiled_model.Run(input_buffers, output_buffers);
}

Phương pháp thay thế là biên dịch JIT mô hình trong thời gian chạy trên thiết bị. Tính linh hoạt cao hơn: chỉ yêu cầu một tệp mô hình độc lập với phần phụ trợ.

// Create environment
auto env = litert::Environment::Create({}).value();

// JIT compile for NPU
auto compiled_model = litert::CompiledModel::Create(
    env, "model.tflite", litert::HwAccelerators::kNpu).value();

// Create I/O buffers
auto input_buffers = compiled_model.CreateInputBuffers().value();
auto output_buffers = compiled_model.CreateOutputBuffers().value();

// Fill inputs
input_buffers[0].Write<float>({/* input data */});

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

Đo điểm chuẩn bằng benchmark_model

Tiện ích benchmark_model của LiteRT (benchmark_model.exe) được thiết kế đặc biệt để đo điểm chuẩn cho một mô hình được biên dịch AOT trên NPU và có thể được dùng để so sánh hiệu suất với phần phụ trợ CPU (XNNPack) trong LiteRT. Ví dụ về lệnh để đo điểm chuẩn một mô hình được biên dịch AOT trên NPU của Intel:

.\benchmark_model.exe --graph=C:\models\model_aot.tflite --use_npu=true --compiler_plugin_library_path=C:\litertlib --dispatch_library_path=C:\litertlib --compiler_cache_path=C:\models

Kiểm tra độ chính xác bằng npu_numerics_check

Tiện ích npu_numerics_check được dùng để xác minh độ chính xác về số học của một mô hình được biên dịch NPU so với một đường cơ sở (thường là phần phụ trợ CPU, XNNPack). Bước này rất quan trọng để đảm bảo rằng việc uỷ quyền cho NPU không gây ra những sai lệch về số không thể chấp nhận được, có thể ảnh hưởng đến chất lượng mô hình.

Chạy quy trình kiểm tra số liệu. Tiện ích này yêu cầu mô hình được biên dịch AOT và so sánh đầu ra của mô hình đó với mô hình ban đầu, không được uỷ quyền chạy trên CPU.

.\npu_numerics_check.exe --npu_model=C:\models\model_aot.tflite --cpu_model=C:\models\model.tflite --dispatch_library_path=C:\litertlib

Các bước tiếp theo

1. Bắt đầu với hướng dẫn NPU thống nhất: Tăng tốc NPU bằng LiteRT
2. Làm theo các bước chuyển đổi và triển khai tại đó, chọn Qualcomm nếu có thể.
3. Đối với LLM, hãy xem phần Thực thi LLM trên NPU bằng LiteRT-LM.