NPU Intel (OpenVino) con LiteRT

LiteRT supporta Intel OpenVino tramite l'API CompiledModel per la compilazione AOT e on-device.

Configura l'ambiente di sviluppo

Linux (x86_64):

• Ubuntu 22.04 o 24.04 LTS
• Python 3.10+ - installa da python.org o dalla tua distribuzione (sudo apt install python3 python3-venv)
• Driver NPU Intel v1.32.1: vedi Configurazione della NPU Linux

Windows (x86_64):

• Windows 10 o 11
• Python 3.10+ - installa da python.org
• Driver NPU Intel 32.0.100.4724+. Vedi Configurazione della NPU di Windows

Per la compilazione dal codice sorgente, è necessario anche Bazel 7.4.1+ che utilizza Bazelisk o la build Docker ermetica.

SoC supportati

Avvio rapido

1. Installare i driver NPU

Consulta Configurazione della NPU Linux o Configurazione della NPU Windows. Salta se hai bisogno solo di AOT.

Il driver NPU è necessario solo sui sistemi che eseguono il modello sull'hardware NPU. I sistemi di compilazione AOT pura possono ignorarlo.

Nota:ai-edge-litert-sdk-intel-nightly blocca la ruota notturna OpenVINO corrispondente in base alla versione PEP 440 (ad es. openvino==2026.2.0.dev20260506), quindi pip ha bisogno di --extra-index-url https://storage.openvinotoolkit.org/simple/wheels/nightly per individuarla. Su Linux, se il rilevamento automatico della distribuzione sceglie l'archivio sbagliato, imposta LITERT_OV_OS_ID=ubuntu22 o ubuntu24 prima di pip install.

2. Crea un ambiente virtuale Python

Consigliamo di mantenere la ruota openvino notturna isolata da qualsiasi installazione OpenVINO a livello di sistema.

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. Installa il pacchetto 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 consente a pip di risolvere la ruota notturna openvino dall'indice di OpenVINO insieme ai pacchetti su PyPI.

4. Verifica dell'installazione

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

Cosa controllare nell'output:

• SDK libs elenca libopenvino_intel_npu_compiler.so (Linux) o openvino_intel_npu_compiler.dll (Windows), richiesti per AOT.
• Available devices include NPU: conferma che il driver NPU è installato e che OpenVINO può comunicare con il dispositivo. NPU non sarà presente sui sistemi solo AOT (in cui il driver non è installato) e sui sistemi senza hardware Intel NPU.

5. Compilazione AOT (facoltativa)

• Precompila un .tflite per un target NPU Intel specifico (PTL o LNL) in modo che il runtime salti il passaggio del plug-in del compilatore.
• Non ha bisogno di una NPU fisica o del driver NPU, solo di ai-edge-litert-nightly e ai-edge-litert-sdk-intel-nightly.
• È supportata la compilazione incrociata: compila su qualsiasi host Linux o Windows, invia il .tflite risultante a una destinazione di uno dei due sistemi operativi ed eseguilo lì.

I file di output sono denominati <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. Esegui inferenza NPU

LiteRT supporta due percorsi di inferenza sulla NPU Intel:

• JIT: carica un .tflite non elaborato; il plug-in del compilatore partiziona e compila le operazioni supportate per la NPU al momento di CompiledModel.from_file(). Aggiunge una latenza di primo avvio (varia in base al modello).
• Compilato AOT: carica un <model>_IntelOpenVINO_<SoC>_apply_plugin.tflite prodotto dal passaggio 4. Salta il passaggio di partizionamento e compilazione al momento del caricamento.

Questo snippet funziona per:

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

Conferma che il provisioning JIT sia stato eseguito

Quando la compilazione JIT ha esito positivo, il log contiene (l'estensione del file è .so su Linux, .dll su 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...

Se queste righe non sono presenti, ma Fully accelerated: True viene comunque segnalato, il modello è stato eseguito sul fallback della CPU XNNPACK, non sulla NPU. Consulta la riga di risoluzione dei problemi 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

Flag comuni:

Flag avanzati / di override: necessari solo per indicare build personalizzate: --dispatch_library_path, --compiler_plugin_path, --runtime_path.

Ruote di fornitori misti: blocco di JIT su Intel OV

Nota:quando Environment.create() viene chiamato senza percorsi espliciti, rileva automaticamente i fornitori in ai_edge_litert/vendors/ in ordine alfabetico e registra il primo che trova. In un'installazione di più fornitori, questo potrebbe non essere Intel OV. Trasferisci esplicitamente le directory Intel OV per forzare la scelta corretta.

• Il pacchetto pip include i plug-in del compilatore per ogni fornitore registrato (intel_openvino/, google_tensor/, mediatek/, qualcomm/, samsung/).
• Per forzare il percorso Intel OV (consigliato quando sono installati più SDK di fornitori), passa manualmente le directory 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,
)

Il runtime carica ogni libreria condivisa che trova nella directory specificata, quindi se punti a vendors/intel_openvino/compiler/ viene caricato solo il plug-in Intel; i plug-in Google Tensor / MediaTek / Qualcomm / Samsung nelle directory di pari livello non vengono mai toccati.

Per la CLI, i flag equivalenti sono:

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

Verifica dell'esecuzione della NPU

Per verificare che il modello sia stato eseguito effettivamente sulla NPU, controlla entrambi i segnali:

1. Il log contiene Loading shared library: .../LiteRtDispatch_IntelOpenvino.{so,dll}: la libreria di invio Intel è stata caricata (.so su Linux, .dll su Windows).
2. model.is_fully_accelerated() restituisce True: ogni operazione è stata scaricata sull'acceleratore selezionato.

is_fully_accelerated() da solo non è sufficiente: se la libreria di distribuzione non è mai stata caricata, le operazioni sono state completamente scaricate su XNNPACK/CPU, non sulla NPU.

Configurazione della NPU Linux

Nota:salta questa sezione se hai bisogno solo di AOT. Non è necessario un NPU fisico.

Informazioni:utilizza il driver NPU v1.32.1 (abbinato a OpenVINO 2026.1). I driver meno recenti non funzionano con 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

Quindi esegui lo snippet di installazione e verifica dalla Avvio rapido.

Configurazione della NPU di Windows

Nota:salta questa sezione se hai bisogno solo di AOT. Non è necessario un NPU fisico.

• Installa il driver NPU Intel (32.0.100.4724+) dal Centro download Intel.
• Verifica che Gestione dispositivi elenchi il dispositivo NPU nella sezione Processori neurali (visualizzato come Intel(R) AI Boost o Intel(R) NPU a seconda del driver).
• Esegui lo snippet di installazione e verifica da Avvio rapido, sostituendo pip con python -m pip.

Informazioni:import ai_edge_litert registra automaticamente le directory DLL utilizzando os.add_dll_directory(), quindi gli script Python non richiedono alcuna configurazione PATH. Per i consumatori non Python, esegui setupvars.bat o anteponi <openvino>/libs a PATH.

Compilare dall'origine

Dietro un proxy? Esporta http_proxy / https_proxy / no_proxy prima di eseguire gli script di build, in quanto li inoltrano a Docker e al container.

Linux (Docker, ermetico):

cd LiteRT/docker_build && ./build_wheel_with_docker.sh

Windows (PowerShell, Bazel in PATH):

.\ci\build_pip_package_with_bazel_windows.ps1

Gli output vengono inseriti in dist/:

• ai_edge_litert-*.whl: la rotellina del runtime.
• ai_edge_litert_sdk_{intel,qualcomm,mediatek,samsung}-*.tar.gz — vendor sdists.
• L'sdist di Intel è di circa 5 KB; il compilatore NPU .so/.dll viene recuperato al momento pip install, quindi lo stesso sdist funziona su Linux e Windows.

Test delle unità

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

Risoluzione dei problemi

Limitazioni

Solo il dispositivo NPU è supportato tramite il percorso di distribuzione OpenVINO. Per l'inferenza della CPU, utilizza solo HardwareAccelerator.CPU (XNNPACK).

Passaggi successivi

1. Inizia con la guida NPU unificata: Accelerazione NPU con LiteRT
2. Segui i passaggi per la conversione e l'implementazione, scegliendo Qualcomm dove applicabile.
3. Per gli LLM, consulta Eseguire LLM sulla NPU utilizzando LiteRT-LM.