NPU de Intel (OpenVino) con LiteRT

LiteRT admite Intel OpenVino a través de la API de CompiledModel para la compilación AOT y la compilación integrado en el dispositivo.

Cómo configurar el entorno de desarrollo

Linux (x86_64):

• Ubuntu 22.04 o 24.04 LTS
• Python 3.10 o versiones posteriores: Instala desde python.org o tu distribución (sudo apt install python3 python3-venv).
• Controlador de NPU de Intel v1.32.1 : Consulta Configuración de NPU de Linux.

Windows (x86_64):

• Windows 10 o 11
• Python 3.10 o versiones posteriores: Instala desde python.org.
• Controlador de NPU de Intel 32.0.100.4724+ : Consulta Configuración de NPU de Windows.

Para compilar desde la fuente, también se requiere Bazel 7.4.1 o versiones posteriores con Bazelisk o la compilación hermética de Docker.

SoCs compatibles

Inicio rápido

1. Instala los controladores de NPU

Consulta Configuración de NPU de Linux o Configuración de NPU de Windows. Omite este paso si solo necesitas AOT.

El controlador de NPU solo es necesario en los sistemas que ejecutan el modelo en hardware de NPU. Los sistemas de compilación AOT puros pueden omitirlo.

Nota: ai-edge-litert-sdk-intel-nightly fija la rueda nocturna de OpenVINO coincidente por la versión PEP 440 (p.ej., openvino==2026.2.0.dev20260506), por lo que pip necesita --extra-index-url https://storage.openvinotoolkit.org/simple/wheels/nightly para ubicarla. En Linux, si la detección automática de la distribución elige el archivo incorrecto, establece LITERT_OV_OS_ID=ubuntu22 o ubuntu24 antes de pip install.

2. Crea un entorno virtual de Python

Se recomienda mantener la rueda openvino nocturna aislada de cualquier instalación de OpenVINO en todo el 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. Instala el paquete pip

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

El --extra-index-url permite que pip resuelva la rueda nocturna openvino fijada desde el índice de OpenVINO junto con los paquetes en PyPI.

4. Verifique la instalación

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

Qué verificar en el resultado:

• SDK libs muestra libopenvino_intel_npu_compiler.so (Linux) o openvino_intel_npu_compiler.dll (Windows), que es obligatorio para AOT.
• Available devices incluye NPU, lo que confirma que el controlador de NPU está instalado y que OpenVINO puede comunicarse con el dispositivo. NPU estará ausente en los sistemas solo AOT (en los que no está instalado el controlador) y en los sistemas sin hardware de NPU de Intel.

5. Compilación AOT (opcional)

• Precompila un .tflite para un destino específico de NPU de Intel (PTL o LNL) para que el entorno de ejecución omita el paso del complemento del compilador.
• No necesita una NPU física ni el controlador de NPU, solo ai-edge-litert-nightly y ai-edge-litert-sdk-intel-nightly.
• Se admite la compilación cruzada: compila en cualquier host de Linux o Windows, envía el .tflite resultante a un destino de cualquiera de los SO y ejecútalo allí.

Los archivos de salida se denominan <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. Ejecuta la inferencia de NPU

LiteRT admite dos rutas de inferencia en la NPU de Intel:

• JIT : Carga un .tflite sin procesar. El complemento del compilador particiona y compila las operaciones compatibles para la NPU en el momento de CompiledModel.from_file(). Agrega algo de latencia de la primera ejecución (varía según el modelo).
• Compilado con AOT : Carga un <model>_IntelOpenVINO_<SoC>_apply_plugin.tflite producido en el paso 4. Omite el paso de partición y compilación en el tiempo de carga.

Este fragmento funciona para ambos casos:

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

Confirma que JIT se ejecutó

Cuando JIT tiene éxito, el registro contiene lo siguiente (la extensión de archivo es .so en Linux y .dll en 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 esas líneas no están presentes, pero aún se informa Fully accelerated: True, el modelo se ejecutó en la CPU de reserva de XNNPACK, no en la NPU. Consulta la fila de solución de problemas de JIT.

7. Comparativa

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

Marcas comunes:

Marcas avanzadas o de anulación: Solo son necesarias para apuntar a compilaciones personalizadas: --dispatch_library_path, --compiler_plugin_path, --runtime_path.

Ruedas de proveedores mixtos: fijación de JIT a Intel OV

Nota: Cuando se llama a Environment.create() sin rutas de acceso explícitas, detecta automáticamente los proveedores en ai_edge_litert/vendors/ en orden alfabético y registra el primero que encuentra. En una instalación de proveedores mixtos, es posible que no sea Intel OV. Pasa los directorios de Intel OV de forma explícita para forzar la selección correcta.

• La rueda pip envía complementos del compilador para cada proveedor registrado (intel_openvino/, google_tensor/, mediatek/, qualcomm/, samsung/).
• Para forzar la ruta de acceso de Intel OV (recomendado cuando se instalan varios SDKs de proveedores), pasa los directorios de Intel OV de forma manual:

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

El entorno de ejecución carga cada biblioteca compartida que encuentra en el directorio determinado, por lo que apuntar a vendors/intel_openvino/compiler/ carga solo el complemento de Intel. Los complementos de Google Tensor, MediaTek, Qualcomm y Samsung en directorios hermanos nunca se tocan.

Para la CLI, las marcas equivalentes son las siguientes:

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 la ejecución de la NPU

Para confirmar que el modelo se ejecutó en la NPU, verifica ambas señales:

1. El registro contiene Loading shared library: .../LiteRtDispatch_IntelOpenvino.{so,dll}. Se cargó la biblioteca de envío de Intel (.so en Linux, .dll en Windows).
2. model.is_fully_accelerated() muestra True. Cada operación se descargó al acelerador seleccionado.

is_fully_accelerated() por sí solo no es suficiente: si la biblioteca de envío nunca se cargó, las operaciones se descargaron por completo a XNNPACK/CPU, no a la NPU.

Configuración de NPU de Linux

Nota: Omite esta sección si solo necesitas AOT. No se requiere una NPU física.

Información: Usa el controlador de NPU v1.32.1 (vinculado con OpenVINO 2026.1). Los controladores más antiguos fallan 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

Luego, ejecuta el fragmento de instalación y verificación desde Inicio rápido.

Configuración de NPU de Windows

Nota: Omite esta sección si solo necesitas AOT. No se requiere una NPU física.

• Instala el controlador de NPU de Intel (32.0.100.4724+) desde el Centro de descargas de Intel.
• Verifica que el Administrador de dispositivos muestre el dispositivo NPU en Procesadores neuronales (que se muestra como Intel(R) AI Boost o Intel(R) NPU según el controlador).
• Ejecuta el fragmento de instalación y verificación desde Inicio rápido, reemplazando pip con python -m pip.

Información: import ai_edge_litert registra automáticamente los directorios DLL con os.add_dll_directory(), por lo que las secuencias de comandos de Python no necesitan configuración de PATH. Para los consumidores que no son de Python, ejecuta setupvars.bat o antepón <openvino>/libs a PATH.

Compila desde el origen

¿Detrás de un proxy? Exporta http_proxy, https_proxy y no_proxy antes de ejecutar las secuencias de comandos de compilación. Las reenvían a Docker y al contenedor.

Linux (Docker, hermético):

cd LiteRT/docker_build && ./build_wheel_with_docker.sh

Windows (PowerShell, Bazel en PATH):

.\ci\build_pip_package_with_bazel_windows.ps1

Las salidas se encuentran en dist/:

• ai_edge_litert-*.whl: La rueda del entorno de ejecución
• ai_edge_litert_sdk_{intel,qualcomm,mediatek,samsung}-*.tar.gz : sdists de proveedores
• El sdist de Intel es de aproximadamente 5 KB. El compilador de NPU .so/.dll se recupera en el momento de pip install time, por lo que el mismo sdist funciona en Linux y Windows.

Pruebas de unidades

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

Solución de problemas

Limitaciones

Solo se admite el dispositivo NPU a través de la ruta de envío de OpenVINO. Para la inferencia de CPU, usa HardwareAccelerator.CPU solo (XNNPACK).

Próximos pasos

1. Comienza con la guía unificada de NPU: Aceleración de NPU con LiteRT.
2. Sigue los pasos de conversión y de implementación, y elige Qualcomm cuando corresponda.
3. Para LLMs, consulta Ejecuta LLMs en NPU con LiteRT-LM.