LiteRT के साथ Intel NPU (OpenVino)

LiteRT, AOT और डिवाइस पर कंपाइलेशन, दोनों के लिए CompiledModel API की मदद से Intel OpenVino के साथ काम करता है.

डेवलपमेंट एनवायरमेंट सेट अप करना

Linux (x86_64):

• Ubuntu 22.04 या 24.04 LTS
• Python 3.10 या इसके बाद का वर्शन — python.org या अपने डिस्ट्रो से इंस्टॉल करें (sudo apt install python3 python3-venv)
• Intel NPU ड्राइवर v1.32.1 — Linux NPU सेटअप देखें

Windows (x86_64):

• Windows 10 या 11
• Python 3.10 या इसके बाद का वर्शन — python.org से इंस्टॉल करें
• Intel NPU ड्राइवर 32.0.100.4724+ — Windows NPU सेटअप देखें

सोर्स से बनाने के लिए, Bazel 7.4.1 या इसके बाद का वर्शन भी ज़रूरी है. इसके लिए, Bazelisk या hermetic Docker बिल्ड का इस्तेमाल किया जा सकता है .

काम करने वाले SoC

क्विक स्टार्ट

1. एनपीयू ड्राइवर इंस्टॉल करना

Linux NPU सेटअप या Windows NPU सेटअप देखें. अगर आपको सिर्फ़ AOT की ज़रूरत है, तो इस चरण को छोड़ दें.

एनपीयू ड्राइवर की ज़रूरत सिर्फ़ उन सिस्टम पर होती है जो एनपीयू हार्डवेयर पर मॉडल एक्ज़ीक्यूट करते हैं. पूरी तरह से AOT-बिल्ड वाले सिस्टम इसे छोड़ सकते हैं.

ध्यान दें: ai-edge-litert-sdk-intel-nightly PEP 440 वर्शन के हिसाब से, OpenVINO के मैचिंग नाइटली व्हील को पिन करता है.जैसे, openvino==2026.2.0.dev20260506. इसलिए, इसे ढूंढने के लिए pip को --extra-index-url https://storage.openvinotoolkit.org/simple/wheels/nightly की ज़रूरत होती है. Linux पर, अगर डिस्ट्रो के अपने-आप पता लगाने की सुविधा से गलत संग्रह चुना जाता है, तो pip install से पहले LITERT_OV_OS_ID=ubuntu22 या ubuntu24 सेट करें.

2. Python का वर्चुअल एनवायरमेंट बनाना

नाइटली openvino व्हील को, सिस्टम-वाइड OpenVINO के किसी भी इंस्टॉलेशन से अलग रखने का सुझाव दिया जाता है.

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 पैकेज इंस्टॉल करना

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 की मदद से, pip, PyPI पर मौजूद पैकेज के साथ-साथ OpenVINO के इंडेक्स से पिन किए गए openvino नाइटली व्हील को हल कर सकता है.

4. इंस्टॉलेशन की पुष्टि करना

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

आउटपुट में क्या देखना है:

• SDK libs में libopenvino_intel_npu_compiler.so (Linux) या openvino_intel_npu_compiler.dll (Windows) शामिल है. यह AOT के लिए ज़रूरी है.
• Available devices में NPU शामिल है. इससे पुष्टि होती है कि एनपीयू ड्राइवर इंस्टॉल हो गया है और OpenVINO, डिवाइस से कम्यूनिकेट कर सकता है. सिर्फ़ AOT वाले सिस्टम (जहां ड्राइवर इंस्टॉल नहीं है) और Intel NPU हार्डवेयर के बिना वाले सिस्टम पर NPU मौजूद नहीं होगा.

5. AOT कंपाइल करना (ज़रूरी नहीं)

• किसी खास Intel NPU टारगेट (PTL या LNL) के लिए, .tflite को पहले से कंपाइल करता है, ताकि रनटाइम, कंपाइलर प्लग-इन वाले चरण को छोड़ सके.
• इसके लिए, फ़िज़िकल एनपीयू या एनपीयू ड्राइवर की ज़रूरत नहीं होती. इसके लिए, सिर्फ़ ai-edge-litert-nightly और ai-edge-litert-sdk-intel-nightly की ज़रूरत होती है.
• क्रॉस-कंपाइलेशन की सुविधा उपलब्ध है: किसी भी Linux या Windows होस्ट पर कंपाइल करें, कंपाइल किया गया .tflite, किसी भी ओएस के टारगेट पर भेजें और उसे वहां चलाएं.

आउटपुट फ़ाइलों के नाम <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. एनपीयू इन्फ़रेंस चलाना

LiteRT, Intel NPU पर इन्फ़रेंस के दो पाथ के साथ काम करता है:

• JIT — रॉ .tflite लोड करें. कंपाइलर प्लग-इन, CompiledModel.from_file() के समय, एनपीयू के लिए काम करने वाले ऑप्स को बांटता है और कंपाइल करता है. इससे, पहली बार रन करने में कुछ इंतज़ार का समय लगता है. यह मॉडल के हिसाब से अलग-अलग होता है.
• AOT-कंपाइल किया गया — चौथे चरण में बनाए गए <model>_IntelOpenVINO_<SoC>_apply_plugin.tflite को लोड करें. लोड करने के समय, यह विभाजन और कंपाइलेशन वाले चरण को छोड़ देता है.

यह स्निपेट, दोनों के लिए काम करता है:

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

पुष्टि करें कि JIT असल में चला है

JIT के सफल होने पर, लॉग में यह जानकारी शामिल होती है. Linux पर फ़ाइल एक्सटेंशन .so और Windows पर .dll होता है:

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...

अगर ये लाइनें मौजूद नहीं हैं, लेकिन फिर भी Fully accelerated: True दिखता है, तो मॉडल को एनपीयू पर नहीं, बल्कि XNNPACK सीपीयू फ़ॉलबैक पर चलाया गया था. इसके लिए, JIT की समस्या हल करने वाली लाइन देखें.

7. मानदंड

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

आम तौर पर इस्तेमाल होने वाले फ़्लैग:

एडवांस / ओवरराइड फ़्लैग — इनकी ज़रूरत सिर्फ़ कस्टम बिल्ड की ओर इशारा करने के लिए होती है: --dispatch_library_path, --compiler_plugin_path, --runtime_path.

अलग-अलग वेंडर के व्हील: JIT को Intel OV पर पिन करना

ध्यान दें: जब साफ़ तौर पर पाथ दिए बिना Environment.create() को कॉल किया जाता है, तो यह वर्णमाला के क्रम में ai_edge_litert/vendors/ में वेंडर को अपने-आप ढूंढ लेता है और मिलने वाले पहले वेंडर को रजिस्टर कर लेता है. अलग-अलग वेंडर के इंस्टॉलेशन में, यह Intel OV नहीं हो सकता. इसलिए, सही वेंडर चुनने के लिए, Intel OV की डायरेक्ट्री साफ़ तौर पर पास करें.

• pip व्हील, रजिस्टर किए गए हर वेंडर (intel_openvino/, google_tensor/, mediatek/, qualcomm/, samsung/) के लिए कंपाइलर प्लग-इन शिप करता है.
• Intel OV पाथ को फ़ोर्स करने के लिए (जब एक से ज़्यादा वेंडर के एसडीके इंस्टॉल हों, तब यह तरीका अपनाने का सुझाव दिया जाता है), 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,
)

रनटाइम, दी गई डायरेक्ट्री में मौजूद हर शेयर की गई लाइब्रेरी को लोड करता है. इसलिए, vendors/intel_openvino/compiler/ की ओर इशारा करने पर, सिर्फ़ Intel प्लग-इन लोड होता है. साथ ही, Google Tensor / MediaTek / Qualcomm / Samsung के प्लग-इन, कभी भी ऐक्सेस नहीं किए जाते.

सीएलआई के लिए, इनसे मिलते-जुलते फ़्लैग ये हैं:

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

एनपीयू एक्ज़ीक्यूशन की पुष्टि करना

इस बात की पुष्टि करने के लिए कि मॉडल असल में एनपीयू पर चला है, दोनों सिग्नल देखें:

1. लॉग में Loading shared library: .../LiteRtDispatch_IntelOpenvino.{so,dll} शामिल है. इसका मतलब है कि Intel डिस्पैच लाइब्रेरी लोड हो गई है. Linux पर .so और Windows पर .dll.
2. model.is_fully_accelerated() से True मिलता है. इसका मतलब है कि हर ऑप को चुने गए ऐक्सेलरेटर पर ऑफ़लोड किया गया है.

सिर्फ़ is_fully_accelerated() से पुष्टि नहीं होती. अगर डिस्पैच लाइब्रेरी कभी लोड नहीं हुई, तो ऑप्स को एनपीयू पर नहीं, बल्कि XNNPACK/सीपीयू पर पूरी तरह से ऑफ़लोड किया गया था.

Linux NPU सेटअप

ध्यान दें: अगर आपको सिर्फ़ AOT की ज़रूरत है, तो इस सेक्शन को छोड़ दें. इसके लिए, फ़िज़िकल एनपीयू की ज़रूरत नहीं होती.

जानकारी: एनपीयू ड्राइवर v1.32.1 का इस्तेमाल करें. यह OpenVINO 2026.1 के साथ काम करता है. पुराने ड्राइवर, 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

इसके बाद, क्विक स्टार्ट में दिया गया, इंस्टॉल करने और पुष्टि करने वाला स्निपेट चलाएं.

Windows NPU सेटअप

ध्यान दें: अगर आपको सिर्फ़ AOT की ज़रूरत है, तो इस सेक्शन को छोड़ दें. इसके लिए, फ़िज़िकल एनपीयू की ज़रूरत नहीं होती.

• Intel Download Center से, Intel NPU ड्राइवर (32.0.100.4724+) इंस्टॉल करें.
• डिवाइस मैनेजर में, न्यूरल प्रोसेसर में एनपीयू डिवाइस की सूची देखें. ड्राइवर के हिसाब से, यह Intel(R) AI Boost या Intel(R) NPU के तौर पर दिखता है.
• क्विक स्टार्ट में दिया गया, इंस्टॉल करने और पुष्टि करने वाला स्निपेट चलाएं. इसमें pip की जगह python -m pip का इस्तेमाल करें.

जानकारी: import ai_edge_litert, os.add_dll_directory() का इस्तेमाल करके, DLL डायरेक्ट्री को अपने-आप रजिस्टर करता है. इसलिए, Python स्क्रिप्ट को PATH सेटअप की ज़रूरत नहीं होती. Python के अलावा अन्य प्लैटफ़ॉर्म पर, setupvars.bat चलाएं या <openvino>/libs को PATH में जोड़ें.

सोर्स से बनाना

प्रॉक्सी का इस्तेमाल कर रहे हैं? बिल्ड स्क्रिप्ट चलाने से पहले, http_proxy / https_proxy / no_proxy एक्सपोर्ट करें. ये स्क्रिप्ट, इन्हें Docker और कंटेनर में फ़ॉरवर्ड करती हैं.

Linux (Docker, hermetic):

cd LiteRT/docker_build && ./build_wheel_with_docker.sh

Windows (PowerShell, Bazel in PATH):

.\ci\build_pip_package_with_bazel_windows.ps1

आउटपुट, dist/ में सेव होते हैं:

• ai_edge_litert-*.whl — रनटाइम व्हील.
• ai_edge_litert_sdk_{intel,qualcomm,mediatek,samsung}-*.tar.gz — वेंडर एसडीस्ट.
• Intel sdist का साइज़ करीब 5 केबी होता है. एनपीयू कंपाइलर .so/.dll को pip install के समय फ़ेच किया जाता है. इसलिए, एक ही sdist, Linux और Windows पर काम करता है.

यूनिट टेस्ट

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

समस्या का हल

सीमाएं

OpenVINO डिस्पैच पाथ के ज़रिए, सिर्फ़ एनपीयू डिवाइस के साथ काम किया जा सकता है. सीपीयू इन्फ़रेंस के लिए, सिर्फ़ HardwareAccelerator.CPU (XNNPACK) का इस्तेमाल करें.

अगले चरण

1. एनपीयू के लिए बनी एक ही गाइड से शुरुआत करें: LiteRT की मदद से एनपीयू ऐक्सेलरेटर की सुविधा का इस्तेमाल करना
2. इसमें दिए गए कन्वर्ज़न और डिप्लॉयमेंट के चरणों को फ़ॉलो करें. जहां लागू हो, वहां Qualcomm चुनें.
3. एलएलएम के लिए, LiteRT-LM का इस्तेमाल करके एनपीयू पर एलएलएम को एक्ज़ीक्यूट करना देखें.