Intel NPU (OpenVino) mit LiteRT

LiteRT unterstützt Intel OpenVINO über die CompiledModel API für die AOT- und die On-Device-Kompilierung.

Entwicklungsumgebung einrichten

Linux (x86_64):

• Ubuntu 22.04 oder 24.04 LTS
• Python 3.10 oder höher – von python.org oder Ihrer Distribution installieren (sudo apt install python3 python3-venv)
• Intel NPU-Treiber v1.32.1 – siehe Linux-NPU-Einrichtung

Windows (x86_64):

• Windows 10 oder 11
• Python 3.10 oder höher – von python.org installieren
• Intel NPU-Treiber 32.0.100.4724+ – siehe Windows-NPU-Einrichtung

Für die Erstellung aus der Quelle ist auch Bazel 7.4.1 oder höher mit Bazelisk oder der hermetischen Docker-Erstellung erforderlich.

Unterstützte SoCs

Schnellstart

1. NPU-Treiber installieren

Weitere Informationen finden Sie unter Linux-NPU-Einrichtung oder Windows-NPU-Einrichtung. Überspringen Sie diesen Schritt, wenn Sie nur AOT benötigen.

Der NPU-Treiber ist nur auf Systemen erforderlich, die das Modell auf der NPU-Hardware ausführen. Systeme, die nur AOT-Builds verwenden, können diesen Schritt überspringen.

Hinweis: ai-edge-litert-sdk-intel-nightly fixiert das passende OpenVINO Nightly-Wheel nach der PEP 440-Version (z. B. openvino==2026.2.0.dev20260506). Daher muss pip --extra-index-url https://storage.openvinotoolkit.org/simple/wheels/nightly verwenden, um es zu finden. Wenn unter Linux die automatische Erkennung der Distribution das falsche Archiv auswählt, legen Sie vor pip install LITERT_OV_OS_ID=ubuntu22 oder ubuntu24 fest.

2. Virtuelle Python-Umgebung erstellen

Empfohlen, um das Nightly-Wheel openvino von einer systemweiten OpenVINO-Installation zu isolieren.

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. pip-Paket installieren

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

Mit --extra-index-url kann pip das fixierte openvino-Nightly-Wheel aus dem OpenVINO-Index zusammen mit Paketen auf PyPI auflösen.

4. Installation prüfen

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

Was Sie in der Ausgabe prüfen sollten:

• Unter SDK libs wird libopenvino_intel_npu_compiler.so (Linux) oder openvino_intel_npu_compiler.dll (Windows) aufgeführt – erforderlich für AOT.
• Unter Available devices ist NPU enthalten – dies bestätigt, dass der NPU-Treiber installiert ist und OpenVINO mit dem Gerät kommunizieren kann. NPU ist auf Systemen, die nur AOT verwenden (auf denen der Treiber nicht installiert ist), und auf Systemen ohne Intel NPU-Hardware nicht vorhanden.

5. AOT-Kompilierung (optional)

• Kompiliert vorab eine .tflite-Datei für ein bestimmtes Intel NPU-Ziel (PTL oder LNL), sodass die Laufzeit den Schritt des Compiler-Plug-ins überspringt.
• Erfordert keine physische NPU oder den NPU-Treiber, sondern nur ai-edge-litert-nightly und ai-edge-litert-sdk-intel-nightly.
• Die Cross-Kompilierung wird unterstützt: Sie können auf einem beliebigen Linux- oder Windows-Host kompilieren, die resultierende .tflite-Datei an ein Ziel eines der beiden Betriebssysteme senden und dort ausführen.

Ausgabedateien haben den Namen <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. NPU-Inferenz ausführen

LiteRT unterstützt zwei Inferenzpfade auf der Intel NPU:

• JIT : Laden Sie eine unkompilierte .tflite-Datei. Das Compiler-Plug-in partitioniert und kompiliert unterstützte Vorgänge für die NPU zur Zeit von CompiledModel.from_file(). Fügt eine gewisse Latenz bei der ersten Ausführung hinzu (variiert je nach Modell).
• AOT-kompiliert : Laden Sie eine <model>_IntelOpenVINO_<SoC>_apply_plugin.tflite die in Schritt 4 erstellt wurde. Überspringt den Partitionierungs- und Kompilierungsschritt zur Ladezeit.

Dieses Snippet funktioniert für beide:

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

Prüfen, ob JIT tatsächlich ausgeführt wurde

Wenn JIT erfolgreich ist, enthält das Log Folgendes (die Dateierweiterung ist .so unter Linux und .dll unter 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...

Wenn diese Zeilen fehlen, aber trotzdem Fully accelerated: True gemeldet wird, wurde das Modell mit dem XNNPACK-CPU-Fallback und nicht auf der NPU ausgeführt. Weitere Informationen finden Sie in der Zeile zur Fehlerbehebung bei 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

Häufig verwendete Flags:

Erweiterte / überschreibende Flags – nur erforderlich, um auf benutzerdefinierte Builds zu verweisen: --dispatch_library_path, --compiler_plugin_path, --runtime_path.

Wheels verschiedener Anbieter: JIT an Intel OV anpinnen

Hinweis:Wenn Environment.create() ohne explizite Pfade aufgerufen wird, werden Anbieter unter ai_edge_litert/vendors/ in alphabetischer Reihenfolge automatisch erkannt und der erste gefundene Anbieter registriert. Bei einer Installation mit mehreren Anbietern ist das möglicherweise nicht Intel OV. Übergeben Sie die Intel OV-Verzeichnisse explizit, um die richtige Auswahl zu erzwingen.

• Das pip-Wheel enthält Compiler-Plug-ins für jeden registrierten Anbieter (intel_openvino/, google_tensor/, mediatek/, qualcomm/, samsung/).
• Wenn Sie den Intel OV-Pfad erzwingen möchten (empfohlen, wenn mehrere Anbieter-SDKs installiert sind), übergeben Sie die Intel OV-Verzeichnisse manuell:

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

Die Laufzeit lädt jede freigegebene Bibliothek, die im angegebenen Verzeichnis gefunden wird. Wenn Sie also auf vendors/intel_openvino/compiler/ verweisen, wird nur das Intel-Plug-in geladen. Die Google Tensor-, MediaTek-, Qualcomm- und Samsung-Plug-ins in den gleichgeordneten Verzeichnissen werden nicht verwendet.

Für die CLI sind die entsprechenden Flags:

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

NPU-Ausführung prüfen

Prüfen Sie beide Signale, um zu bestätigen, dass das Modell tatsächlich auf der NPU ausgeführt wurde:

1. Das Log enthält Loading shared library: .../LiteRtDispatch_IntelOpenvino.{so,dll} – die Intel-Dispatch-Bibliothek wurde geladen (.so unter Linux, .dll unter Windows).
2. model.is_fully_accelerated() gibt True zurück – alle Vorgänge wurden auf den ausgewählten Beschleuniger ausgelagert.

is_fully_accelerated() allein reicht nicht aus. Wenn die Dispatch-Bibliothek nie geladen wurde, wurden die Vorgänge vollständig auf XNNPACK/CPU und nicht auf die NPU ausgelagert.

Linux-NPU-Einrichtung

Hinweis:Überspringen Sie diesen Abschnitt, wenn Sie nur AOT benötigen – eine physische NPU ist nicht erforderlich.

Info:Verwenden Sie den NPU-Treiber v1.32.1 (in Kombination mit OpenVINO 2026.1). Ältere Treiber schlagen mit Level0 pfnCreate2 result: ZE_RESULT_ERROR_UNSUPPORTED_FEATURE fehl.

# 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

Führen Sie dann das Snippet für die Installation und Überprüfung aus Schnelleinstieg aus.

Windows-NPU-Einrichtung

Hinweis:Überspringen Sie diesen Abschnitt, wenn Sie nur AOT benötigen – eine physische NPU ist nicht erforderlich.

• Installieren Sie den Intel NPU-Treiber (32.0.100.4724+) aus dem Intel Download Center.
• Prüfen Sie, ob der Geräte-Manager das NPU-Gerät unter Neural processors (je nach Treiber als Intel(R) AI Boost oder Intel(R) NPU angezeigt) auflistet.
• Führen Sie das Snippet für die Installation und Überprüfung aus Schnelleinstieg aus und ersetzen Sie pip durch python -m pip.

Info:import ai_edge_litert registriert DLL-Verzeichnisse automatisch mit os.add_dll_directory(), sodass für Python-Skripts keine PATH-Einrichtung erforderlich ist. Für Nicht-Python-Nutzer führen Sie setupvars.bat aus oder stellen Sie <openvino>/libs vor PATH.

Aus Quelle erstellen

Hinter einem Proxy? Exportieren Sie http_proxy / https_proxy / no_proxy, bevor Sie die Build-Skripts ausführen. Diese werden an Docker und den Container weitergeleitet.

Linux (Docker, hermetisch):

cd LiteRT/docker_build && ./build_wheel_with_docker.sh

Windows (PowerShell, Bazel in PATH):

.\ci\build_pip_package_with_bazel_windows.ps1

Die Ausgaben befinden sich in dist/:

• ai_edge_litert-*.whl – das Laufzeit-Wheel.
• ai_edge_litert_sdk_{intel,qualcomm,mediatek,samsung}-*.tar.gz – Anbieter-SDists.
• Die Intel-Sdist ist etwa 5 KB groß. Der NPU-Compiler .so/.dll wird zur Zeit von pip install abgerufen, sodass dieselbe Sdist unter Linux und Windows funktioniert.

Unit Tests

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

Fehlerbehebung

Beschränkungen

Nur das NPU-Gerät wird über den OpenVINO-Dispatch-Pfad unterstützt. Verwenden Sie für die CPU-Inferenz nur HardwareAccelerator.CPU (XNNPACK).

Nächste Schritte

1. Beginnen Sie mit der einheitlichen NPU-Anleitung: NPU-Beschleunigung mit LiteRT
2. Folgen Sie dort den Schritten zur Konvertierung und Bereitstellung und wählen Sie gegebenenfalls Qualcomm aus.
3. Informationen zu LLMs finden Sie unter LLMs auf der NPU mit LiteRT-LM ausführen.