NPU da Intel (OpenVino) com LiteRT

O LiteRT oferece suporte ao Intel OpenVino pela API CompiledModel para compilação AOT e no dispositivo.

Configurar o ambiente de desenvolvimento

Linux (x86_64) :

• Ubuntu 22.04 ou 24.04 LTS
• Python 3.10 ou mais recente: instale em python.org ou na sua distribuição (sudo apt install python3 python3-venv)
• Driver da NPU Intel v1.32.1 : consulte a configuração da NPU do Linux

Windows (x86_64) :

• Windows 10 ou 11
• Python 3.10 ou mais recente: instale em python.org
• Driver da NPU Intel 32.0.100.4724+ : consulte a configuração da NPU do Windows

Para criar a partir da origem, também é necessário o Bazel 7.4.1 ou mais recente usando Bazelisk ou a versão hermética do Docker.

SoCs compatíveis

Início rápido

1. Instalar drivers da NPU

Consulte a configuração da NPU do Linux ou a configuração da NPU do Windows. Pule essa etapa se você só precisar da AOT.

O driver da NPU só é necessário em sistemas que executam o modelo no hardware da NPU. Os sistemas de build AOT puro podem pular essa etapa.

Observação: ai-edge-litert-sdk-intel-nightly fixa a roda noturna do OpenVINO correspondente pela versão PEP 440 (por exemplo, openvino==2026.2.0.dev20260506), então o pip precisa de --extra-index-url https://storage.openvinotoolkit.org/simple/wheels/nightly para localizá-la. No Linux, se a detecção automática de distribuição escolher o arquivo errado, defina LITERT_OV_OS_ID=ubuntu22 ou ubuntu24 antes de pip install.

2. Criar um ambiente virtual do Python

Recomendado para manter a roda noturna openvino isolada de qualquer instalação do OpenVINO em todo o 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. Instalar o pacote pip

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

O --extra-index-url permite que o pip resolva a roda noturna openvino fixada do índice do OpenVINO junto com os pacotes no PyPI.

4. Verifique a instalação

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

O que verificar na saída:

• SDK libs lista libopenvino_intel_npu_compiler.so (Linux) ou openvino_intel_npu_compiler.dll (Windows), necessário para a AOT.
• Available devices inclui NPU, que confirma que o driver da NPU está instalado e que o OpenVINO pode se comunicar com o dispositivo. NPU estará ausente em sistemas somente AOT (em que o driver não está instalado) e em sistemas sem hardware da NPU Intel.

5. Compilação AOT (opcional)

• Pré-compila um .tflite para um destino específico da NPU Intel (PTL ou LNL) para que o ambiente de execução pule a etapa do plug-in do compilador.
• Não precisa de uma NPU física ou do driver da NPU, apenas ai-edge-litert-nightly e ai-edge-litert-sdk-intel-nightly.
• A compilação cruzada é compatível: compile em qualquer host Linux ou Windows, envie o .tflite resultante para um destino de qualquer SO e execute-o lá.

Os arquivos de saída são nomeados como <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. Executar a inferência da NPU

O LiteRT oferece suporte a dois caminhos de inferência na NPU Intel:

• JIT : carrega um .tflite bruto. O plug-in do compilador particiona e compila operações compatíveis para a NPU no momento de CompiledModel.from_file(). Adiciona alguma latência de primeira execução (varia de acordo com o modelo).
• Compilado por AOT : carrega um <model>_IntelOpenVINO_<SoC>_apply_plugin.tflite produzido pela etapa 4. Pula a etapa de partição e compilação no tempo de carregamento.

Este snippet funciona para os dois:

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

Confirmar se o JIT foi executado

Quando o JIT é bem-sucedido, o registro contém (a extensão do arquivo é .so no Linux e .dll no 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 essas linhas estiverem ausentes, mas Fully accelerated: True ainda for informado, o modelo será executado no fallback da CPU XNNPACK, não na NPU. Consulte a linha de solução de problemas do JIT.

7. Comparativo de mercado

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

Flags comuns:

Flags avançadas / de substituição: só são necessárias para apontar para builds personalizados: --dispatch_library_path, --compiler_plugin_path, --runtime_path.

Rodas de fornecedores mistos: fixar o JIT no Intel OV

Observação:quando Environment.create() é chamado sem caminhos explícitos, ele descobre automaticamente os fornecedores em ai_edge_litert/vendors/ em ordem alfabética e registra o primeiro encontrado. Em uma instalação de fornecedor misto, isso pode não ser o Intel OV. Transmita os diretórios do Intel OV explicitamente para forçar a escolha certa.

• A roda pip envia plug-ins do compilador para cada fornecedor registrado (intel_openvino/, google_tensor/, mediatek/, qualcomm/, samsung/).
• Para forçar o caminho do Intel OV (recomendado quando vários SDKs de fornecedores estão instalados), transmita os diretórios do Intel OV manualmente:

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

O ambiente de execução carrega todas as bibliotecas compartilhadas encontradas no diretório especificado. Portanto, apontar para vendors/intel_openvino/compiler/ carrega apenas o plug-in Intel. Os plug-ins Google Tensor / MediaTek / Qualcomm / Samsung em diretórios irmãos nunca são acessados.

Para a CLI, as flags equivalentes são:

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

Verificar a execução da NPU

Para confirmar se o modelo foi executado na NPU, verifique ambos os sinais:

1. O registro contém Loading shared library: .../LiteRtDispatch_IntelOpenvino.{so,dll}. A biblioteca de distribuição da Intel foi carregada (.so no Linux, .dll no Windows).
2. model.is_fully_accelerated() retorna True. Todas as operações foram descarregadas para o acelerador selecionado.

is_fully_accelerated() sozinho não é suficiente: se a biblioteca de distribuição nunca foi carregada, as operações foram totalmente descarregadas para XNNPACK/CPU, não para a NPU.

Configuração da NPU do Linux

Observação:pule esta seção se você só precisar da AOT. Uma NPU física não é necessária.

Informações: use o driver da NPU v1.32.1 (pareado com o OpenVINO 2026.1). Drivers mais antigos falham com 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

Em seguida, execute o snippet de instalação e verificação do início rápido.

Configuração da NPU do Windows

Observação:pule esta seção se você só precisar da AOT. Uma NPU física não é necessária.

• Instale o driver da NPU Intel (32.0.100.4724+) na Central de downloads da Intel.
• Verifique se o Gerenciador de dispositivos lista o dispositivo da NPU em Processadores neurais (mostrado como Intel(R) AI Boost ou Intel(R) NPU, dependendo do driver).
• Execute o snippet de instalação e verificação do Início rápido, substituindo pip por python -m pip.

Informações:import ai_edge_litert registra automaticamente os diretórios de DLL usando os.add_dll_directory(), então os scripts Python não precisam de configuração PATH. Para consumidores que não são do Python, execute setupvars.bat ou adicione <openvino>/libs ao PATH.

Criar a partir da fonte

Atrás de um proxy? Exporte http_proxy / https_proxy / no_proxy antes de executar os scripts de build. Eles encaminham esses scripts para o Docker e o contêiner.

Linux (Docker, hermético):

cd LiteRT/docker_build && ./build_wheel_with_docker.sh

Windows (PowerShell, Bazel no PATH):

.\ci\build_pip_package_with_bazel_windows.ps1

As saídas são exibidas em dist/:

• ai_edge_litert-*.whl: a roda do ambiente de execução.
• ai_edge_litert_sdk_{intel,qualcomm,mediatek,samsung}-*.tar.gz : sdists de fornecedores.
• O sdist da Intel tem cerca de 5 KB. O compilador da NPU .so/.dll é buscado no momento de pip install, então o mesmo sdist funciona no Linux e no Windows.

Testes de unidade

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

Solução de problemas

Limitações

Somente o dispositivo da NPU é compatível com o caminho de distribuição do OpenVINO. Para inferência de CPU, use apenas HardwareAccelerator.CPU (XNNPACK).

Próximas etapas

1. Comece com o guia unificado da NPU: aceleração da NPU com o LiteRT
2. Siga as etapas de conversão e implantação, escolhendo a Qualcomm quando aplicável.
3. Para LLMs, consulte Executar LLMs na NPU usando o LiteRT-LM.