Intel NPU (OpenVino) z LiteRT

LiteRT obsługuje Intel OpenVino za pomocą interfejsu CompiledModel API zarówno w przypadku kompilacji AOT, jak i kompilacji na urządzeniu.

Konfigurowanie środowiska programistycznego

Linux (x86_64):

• Ubuntu 22.04 lub 24.04 LTS
• Python 3.10 lub nowszy – zainstaluj z python.org lub dystrybucji (sudo apt install python3 python3-venv)
• Sterownik Intel NPU v1.32.1 – zobacz Konfiguracja NPU w systemie Linux

Windows (x86_64):

• Windows 10 lub 11
• Python 3.10 lub nowszy – zainstaluj z python.org
• Sterownik Intel NPU 32.0.100.4724+ – zobacz Konfiguracja NPU w systemie Windows

Do kompilacji ze źródeł wymagany jest też Bazel 7.4.1 lub nowszy z Bazelisk lub hermetyczna kompilacja Dockera.

Obsługiwane układy SoC

Szybki start

1. Zainstaluj sterowniki NPU

Zapoznaj się z instrukcjami Konfiguracja NPU w systemie Linux lub Konfiguracja NPU w systemie Windows. Pomiń ten krok, jeśli potrzebujesz tylko kompilacji AOT.

Sterownik NPU jest potrzebny tylko w systemach, które wykonują model na sprzęcie NPU. Systemy z czystą kompilacją AOT mogą pominąć ten krok.

Uwaga: ai-edge-litert-sdk-intel-nightly przypina pasujący pakiet OpenVINO nightly według wersji PEP 440 (np. openvino==2026.2.0.dev20260506), więc pip musi użyć --extra-index-url https://storage.openvinotoolkit.org/simple/wheels/nightly, aby go znaleźć. Jeśli w systemie Linux automatyczne wykrywanie dystrybucji wybierze nieprawidłowe archiwum, przed uruchomieniem pip install ustaw LITERT_OV_OS_ID=ubuntu22 lub ubuntu24.

2. Utwórz środowisko wirtualne Pythona

Zalecamy, aby pakiet nightly openvino był odizolowany od instalacji OpenVINO w całym systemie.

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. Zainstaluj pakiet pip

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

Flaga --extra-index-url umożliwia pipowi rozpoznanie przypiętego pakietu nightly openvino z indeksu OpenVINO obok pakietów w PyPI.

4. Sprawdź instalację

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

Co należy sprawdzić w danych wyjściowych:

• SDK libs zawiera libopenvino_intel_npu_compiler.so (Linux) lub openvino_intel_npu_compiler.dll (Windows) – wymagane do kompilacji AOT.
• Available devices zawiera NPU – potwierdza, że sterownik NPU jest zainstalowany i OpenVINO może komunikować się z urządzeniem. NPU nie będzie widoczny w systemach tylko z kompilacją AOT (gdzie sterownik nie jest zainstalowany) oraz w systemach bez sprzętu Intel NPU.

5. Kompilacja AOT (opcjonalnie)

• Wstępnie kompiluje plik .tflite dla określonego celu Intel NPU (PTL lub LNL), dzięki czemu środowisko wykonawcze pomija krok wtyczki kompilatora.
• Nie wymaga fizycznego NPU ani sterownika NPU – tylko ai-edge-litert-nightly i ai-edge-litert-sdk-intel-nightly.
• Obsługiwana jest kompilacja skrośna: skompiluj na dowolnym hoście z systemem Linux lub Windows, prześlij wynikowy plik .tflite do celu z dowolnym systemem operacyjnym i uruchom go tam.

Pliki wyjściowe mają nazwę <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. Uruchom wnioskowanie NPU

LiteRT obsługuje 2 ścieżki wnioskowania na Intel NPU:

• JIT – wczytaj surowy plik .tflite; wtyczka kompilatora dzieli i kompiluje obsługiwane operacje dla NPU w czasie CompiledModel.from_file(). Dodaje pewne opóźnienie przy pierwszym uruchomieniu (zależy od modelu).
• Skompilowany AOT – wczytaj plik <model>_IntelOpenVINO_<SoC>_apply_plugin.tflite utworzony w kroku 4. Pomija krok podziału i kompilacji w czasie wczytywania.

Ten fragment kodu działa w obu przypadkach:

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

Potwierdź, że JIT rzeczywiście został uruchomiony

Jeśli JIT zakończy się pomyślnie, dziennik będzie zawierać te informacje (rozszerzenie pliku to .so w systemie Linux i .dll w systemie 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...

Jeśli te wiersze są nieobecne, ale nadal wyświetla się Fully accelerated: True, model został uruchomiony na rezerwowym procesorze XNNPACK, a nie na NPU – zobacz wiersz rozwiązywania problemów z JIT.

7. Test porównawczy

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

Typowe flagi:

Flagi zaawansowane lub zastępujące – potrzebne tylko do wskazywania niestandardowych kompilacji: --dispatch_library_path, --compiler_plugin_path, --runtime_path.

Pakiety od różnych dostawców: przypinanie JIT do Intel OV

Uwaga: gdy wywoływana jest funkcja Environment.create() bez jawnych ścieżek, automatycznie wykrywa dostawców w folderze ai_edge_litert/vendors/ w porządku alfabetycznym i rejestruje pierwszego znalezionego. W przypadku instalacji od różnych dostawców może to nie być Intel OV – aby wymusić prawidłowy wybór, przekaż katalogi Intel OV.

• Pakiet pip zawiera wtyczki kompilatora dla każdego zarejestrowanego dostawcy (intel_openvino/, google_tensor/, mediatek/, qualcomm/, samsung/).
• Aby wymusić ścieżkę Intel OV (zalecane, gdy zainstalowanych jest wiele pakietów SDK dostawców), przekaż katalogi Intel OV ręcznie:

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

Środowisko wykonawcze wczytuje każdą bibliotekę współdzieloną, którą znajdzie w danym katalogu, więc wskazanie vendors/intel_openvino/compiler/ wczytuje tylko wtyczkę Intel; wtyczki Google Tensor, MediaTek, Qualcomm i Samsung w katalogach równorzędnych nigdy nie są używane.

W przypadku interfejsu CLI odpowiednie flagi to:

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

Sprawdź wykonanie NPU

Aby potwierdzić, że model rzeczywiście został uruchomiony na NPU, sprawdź oba sygnały:

1. Dziennik zawiera Loading shared library: .../LiteRtDispatch_IntelOpenvino.{so,dll} – biblioteka wysyłania Intel została wczytana (.so w systemie Linux, .dll w systemie Windows).
2. model.is_fully_accelerated() zwraca True – każda operacja została przeniesiona do wybranego akceleratora.

Samo is_fully_accelerated() nie wystarczy: jeśli biblioteka wysyłania nigdy się nie wczytała, operacje zostały w pełni przeniesione do XNNPACK/procesora, a nie do NPU.

Konfiguracja NPU w systemie Linux

Uwaga: jeśli potrzebujesz tylko kompilacji AOT, pomiń tę sekcję – fizyczny NPU nie jest wymagany.

Informacje: użyj sterownika NPU v1.32.1 (sparowanego z OpenVINO 2026.1). Starsze sterowniki powodują błąd 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

Następnie uruchom fragment kodu instalacji i weryfikacji z sekcji Szybki start.

Konfiguracja NPU w systemie Windows

Uwaga: jeśli potrzebujesz tylko kompilacji AOT, pomiń tę sekcję – fizyczny NPU nie jest wymagany.

• Zainstaluj sterownik Intel NPU (32.0.100.4724+) z Centrum pobierania Intel.
• Sprawdź, czy Menedżer urządzeń wyświetla urządzenie NPU w sekcji Procesory neuronowe (w zależności od sterownika jest ono wyświetlane jako Intel(R) AI Boost lub Intel(R) NPU).
• Uruchom fragment kodu instalacji i weryfikacji z sekcji Szybki start, zastępując pip ciągiem python -m pip.

Informacje: import ai_edge_litert automatycznie rejestruje katalogi DLL za pomocą os.add_dll_directory(), więc skrypty Pythona nie wymagają konfiguracji PATH. W przypadku użytkowników innych niż Python uruchom setupvars.bat lub dodaj <openvino>/libs do PATH.

Kompilacja ze źródeł

Używasz serwera proxy? Przed uruchomieniem skryptów kompilacji wyeksportuj http_proxy / https_proxy / no_proxy – przekazują one te informacje do Dockera i kontenera.

Linux (Docker, hermetyczny):

cd LiteRT/docker_build && ./build_wheel_with_docker.sh

Windows (PowerShell, Bazel w PATH):

.\ci\build_pip_package_with_bazel_windows.ps1

Dane wyjściowe znajdują się w folderze dist/:

• ai_edge_litert-*.whl – pakiet środowiska wykonawczego.
• ai_edge_litert_sdk_{intel,qualcomm,mediatek,samsung}-*.tar.gz – pakiety sdist dostawców.
• Pakiet sdist Intel ma rozmiar około 5 KB; kompilator NPU .so/.dll jest pobierany w czasie pip install time, więc ten sam pakiet sdist działa w systemach Linux i Windows.

Testy jednostkowe

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

Rozwiązywanie problemów

Ograniczenia

Za pomocą ścieżki wysyłania OpenVINO obsługiwane jest tylko urządzenie NPU. W przypadku wnioskowania na procesorze używaj tylko HardwareAccelerator.CPU (XNNPACK).

Dalsze kroki

1. Zacznij od ujednoliconego przewodnika NPU: Akceleracja NPU za pomocą LiteRT
2. Postępuj zgodnie z instrukcjami dotyczącymi konwersji i wdrażania, wybierając w stosownych przypadkach Qualcomm.
3. W przypadku dużych modeli językowych zapoznaj się z artykułem Wykonywanie dużych modeli językowych na NPU za pomocą LiteRT-LM.