NPU Intel (OpenVino) avec LiteRT

LiteRT est compatible avec Intel OpenVino via l'API CompiledModel pour la compilation AOT et sur l'appareil.

Configurer l'environnement de développement

Linux (x86_64) :

• Ubuntu 22.04 ou 24.04 LTS
• Python 3.10 ou version ultérieure : installez-le depuis python.org ou votre distribution (sudo apt install python3 python3-venv).
• Pilote Intel NPU v1.32.1 : consultez la section Configuration du NPU Linux.

Windows (x86_64) :

• Windows 10 ou 11
• Python 3.10 ou version ultérieure : installez-le depuis python.org.
• Pilote Intel NPU 32.0.100.4724+ : consultez Configuration du NPU Windows.

Pour la compilation à partir de la source, Bazel 7.4.1+ utilisant Bazelisk ou la compilation Docker hermétique est également requis.

SoC compatibles

Démarrage rapide

1. Installer les pilotes NPU

Consultez Configuration de l'unité de traitement neuronal (NPU) sous Linux ou Configuration de l'unité de traitement neuronal (NPU) sous Windows. Ignorez cette étape si vous n'avez besoin que de l'AOT.

Le pilote NPU n'est nécessaire que sur les systèmes qui exécutent le modèle sur le matériel NPU. Les systèmes de compilation AOT pure peuvent l'ignorer.

Remarque : ai-edge-litert-sdk-intel-nightly épingle la roue nightly OpenVINO correspondante par version PEP 440 (par exemple, openvino==2026.2.0.dev20260506). pip a donc besoin de --extra-index-url https://storage.openvinotoolkit.org/simple/wheels/nightly pour la localiser. Sur Linux, si la détection automatique de la distribution choisit la mauvaise archive, définissez LITERT_OV_OS_ID=ubuntu22 ou ubuntu24 avant pip install.

2. Créer un environnement virtuel Python

Il est recommandé de conserver la roue openvino nightly isolée de toute installation OpenVINO à l'échelle du système.

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. Installer le package pip

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

Le --extra-index-url permet à pip de résoudre la roue openvino quotidienne épinglée à partir de l'index OpenVINO en même temps que les packages sur PyPI.

4. Vérifier l'installation

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

Points à vérifier dans le résultat :

• SDK libs liste libopenvino_intel_npu_compiler.so (Linux) ou openvino_intel_npu_compiler.dll (Windows), obligatoire pour AOT.
• Available devices inclut NPU : cela confirme que le pilote NPU est installé et qu'OpenVINO peut communiquer avec l'appareil. NPU sera absent des systèmes AOT uniquement (où le pilote n'est pas installé) et des systèmes sans matériel Intel NPU.

5. Compilation AOT (facultatif)

• Précompile un .tflite pour une cible NPU Intel spécifique (PTL ou LNL) afin que l'environnement d'exécution ignore l'étape du plug-in du compilateur.
• N'a pas besoin d'un NPU physique ni du pilote NPU. Seuls ai-edge-litert-nightly et ai-edge-litert-sdk-intel-nightly sont nécessaires.
• La compilation croisée est acceptée : compilez sur n'importe quel hôte Linux ou Windows, envoyez le .tflite obtenu à une cible de l'un ou l'autre des OS et exécutez-le.

Les fichiers de sortie sont nommés <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. Exécuter l'inférence NPU

LiteRT est compatible avec deux chemins d'inférence sur l'unité de traitement neuronal Intel :

• JIT : charge un .tflite brut. Le plug-in du compilateur partitionne et compile les opérations compatibles pour la NPU au moment de l'exécution CompiledModel.from_file(). Ajoute une latence de première exécution (variable selon le modèle).
• Compilation AOT : chargez un <model>_IntelOpenVINO_<SoC>_apply_plugin.tflite produit à l'étape 4. Ignore l'étape de partitionnement et de compilation au moment du chargement.

Cet extrait fonctionne pour les deux :

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

Vérifier que la compilation JIT a bien été exécutée

Lorsque la compilation JIT réussit, le journal contient les informations suivantes (l'extension de fichier est .so sur Linux et .dll sur 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...

Si ces lignes sont absentes, mais que Fully accelerated: True est toujours signalé, cela signifie que le modèle a été exécuté sur le processeur de secours XNNPACK et non sur l'unité de traitement neuronal. Consultez la ligne de dépannage JIT.

7. Benchmark

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

Options courantes :

Options avancées / de remplacement : ne sont nécessaires que pour pointer vers des versions personnalisées : --dispatch_library_path, --compiler_plugin_path, --runtime_path.

Roues de différents fournisseurs : épingler JIT à Intel OV

Remarque : Lorsque Environment.create() est appelé sans chemins d'accès explicites, il détecte automatiquement les fournisseurs sous ai_edge_litert/vendors/ par ordre alphabétique et enregistre le premier qu'il trouve. Dans une installation multi-fournisseurs, il se peut que ce ne soit pas Intel OV. Transmettez explicitement les répertoires Intel OV pour forcer la bonne sélection.

• La roue pip fournit des plug-ins de compilateur pour chaque fournisseur enregistré (intel_openvino/, google_tensor/, mediatek/, qualcomm/, samsung/).
• Pour forcer le chemin d'accès Intel OV (recommandé lorsque plusieurs SDK de fournisseurs sont installés), transmettez manuellement les répertoires Intel OV :

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

L'environnement d'exécution charge toutes les bibliothèques partagées qu'il trouve dans le répertoire donné. Par conséquent, en pointant sur vendors/intel_openvino/compiler/, seul le plug-in Intel est chargé. Les plug-ins Google Tensor / MediaTek / Qualcomm / Samsung dans les répertoires frères ne sont jamais utilisés.

Pour la CLI, les indicateurs équivalents sont les suivants :

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

Vérifier l'exécution de l'unité de traitement neuronal

Pour vérifier que le modèle s'est bien exécuté sur l'unité de traitement neuronal, recherchez les deux signaux suivants :

1. Le journal contient Loading shared library: .../LiteRtDispatch_IntelOpenvino.{so,dll} : la bibliothèque de répartition Intel a été chargée (.so sur Linux, .dll sur Windows).
2. model.is_fully_accelerated() renvoie True : chaque opération a été déchargée sur l'accélérateur sélectionné.

is_fully_accelerated() seul ne suffit pas : si la bibliothèque de répartition n'a jamais été chargée, les opérations ont été entièrement déchargées sur XNNPACK/CPU, et non sur l'unité de traitement neuronal.

Configuration du NPU Linux

Remarque : Ignorez cette section si vous n'avez besoin que d'AOT. Un NPU physique n'est pas nécessaire.

Info : Utiliser le pilote NPU v1.32.1 (associé à OpenVINO 2026.1). Les pilotes plus anciens échouent avec 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

Exécutez ensuite l'extrait d'installation et de vérification à partir du guide de démarrage rapide.

Configuration du NPU Windows

Remarque : Ignorez cette section si vous n'avez besoin que d'AOT. Un NPU physique n'est pas nécessaire.

• Installez le pilote Intel NPU (32.0.100.4724+) depuis le Centre de téléchargement Intel.
• Vérifiez que le Gestionnaire de périphériques liste l'appareil NPU sous Processeurs neuronaux (affiché sous la forme Intel(R) AI Boost ou Intel(R) NPU selon le pilote).
• Exécutez l'extrait d'installation et de validation du démarrage rapide en remplaçant pip par python -m pip.

Info : import ai_edge_litert enregistre automatiquement les répertoires DLL à l'aide de os.add_dll_directory(). Les scripts Python n'ont donc pas besoin de configuration PATH. Pour les consommateurs non Python, exécutez setupvars.bat ou ajoutez <openvino>/libs à PATH.

Créer à partir de la source

Derrière un proxy ? Exportez http_proxy / https_proxy / no_proxy avant d'exécuter les scripts de compilation. Ils les transmettent à Docker et au conteneur.

Linux (Docker, hermétique) :

cd LiteRT/docker_build && ./build_wheel_with_docker.sh

Windows (PowerShell, Bazel dans PATH) :

.\ci\build_pip_package_with_bazel_windows.ps1

Les résultats s'affichent dans dist/ :

• ai_edge_litert-*.whl : roue de l'environnement d'exécution.
• ai_edge_litert_sdk_{intel,qualcomm,mediatek,samsung}-*.tar.gz : distributions de sources du fournisseur.
• La sdist Intel est d'environ 5 Ko. Le compilateur NPU .so/.dll est récupéré au moment de pip install. La même sdist fonctionne donc sur Linux et Windows.

Tests unitaires

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

Dépannage

Limites

Seul l'appareil NPU est compatible avec le chemin de répartition OpenVINO. Pour l'inférence du CPU, utilisez uniquement HardwareAccelerator.CPU (XNNPACK).

Étapes suivantes

1. Commencez par le guide unifié sur les NPU : Accélération des NPU avec LiteRT
2. Suivez les étapes de conversion et de déploiement, en choisissant Qualcomm le cas échéant.
3. Pour les LLM, consultez Exécuter des LLM sur NPU à l'aide de LiteRT-LM.