Intel NPU (OpenVino) with LiteRT

‫LiteRT תומך ב-Intel OpenVino דרך CompiledModel API גם עבור AOT וגם עבור קומפילציה במכשיר.

הגדרת סביבת פיתוח

‫Linux (x86_64):

• ‫Ubuntu 22.04 או 24.04 LTS
• ‫Python 3.10 ואילך – אפשר להתקין מ-python.org או מההפצה שלכם (sudo apt install python3 python3-venv)
• ‫Intel NPU driver v1.32.1 – ראו Linux NPU Setup

‫Windows (x86_64):

• ‫Windows 10 או 11
• ‫Python 3.10 ואילך – אפשר להתקין מ-python.org
• מנהל התקן Intel NPU‏ 32.0.100.4724+ – ראו הגדרה של Windows NPU

כדי לבצע build מקוד המקור, נדרשת גם גרסה 7.4.1 ואילך של Bazel באמצעות Bazelisk או build הרמטי של Docker.

מערכות SoC נתמכות

התחלה מהירה

1. התקנה של מנהלי התקנים של NPU

מידע נוסף מופיע במאמר בנושא הגדרת NPU ב-Linux או הגדרת NPU ב-Windows. אפשר לדלג על השלב הזה אם אתם צריכים רק AOT.

דרייבר ה-NPU נדרש רק במערכות שמריצות את המודל בחומרת NPU. מערכות build של AOT טהור יכולות לדלג על השלב הזה.

הערה: ‏ai-edge-litert-sdk-intel-nightly מצמיד את גלגל OpenVINO nightly התואם לפי גרסת PEP 440 (למשל, openvino==2026.2.0.dev20260506), ולכן pip צריך --extra-index-url https://storage.openvinotoolkit.org/simple/wheels/nightly כדי לאתר אותו. ב-Linux, אם הזיהוי האוטומטי של ההפצה בוחר בארכיון הלא נכון, צריך להגדיר את LITERT_OV_OS_ID=ubuntu22 או ubuntu24 לפני pip install.

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 לפתור את הגלגל היומי openvino המוצמד של OpenVINO מהאינדקס שלו לצד חבילות ב-PyPI.

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 (Linux) או openvino_intel_npu_compiler.dll (Windows) – נדרש ל-AOT.libopenvino_intel_npu_compiler.so
• ‫Available devices כולל NPU – מאשר שמנהל ההתקן של NPU מותקן ו-OpenVINO יכול לתקשר עם המכשיר. האפליקציה NPU לא תופיע במערכות שבהן יש רק קומפילציה מראש (AOT) (שבהן לא מותקן מנהל ההתקן) ובמערכות ללא חומרת Intel NPU.

5. קומפילציה של AOT (אופציונלי)

• מבצע קומפילציה מראש של .tflite עבור יעד ספציפי של Intel NPU ‏ (PTL או LNL) כדי שזמן הריצה ידלג על שלב הפלאגין של הקומפיילר.
• לא צריך NPU פיזי או את מנהל ההתקן של ה-NPU – רק 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. הרצת היקשים ב-NPU

‫LiteRT תומך בשני נתיבי הסקה ב-NPU של Intel:

• ‫JIT – טעינה של .tflite גולמי. פלאגין הקומפיילר מחלק ומקמפל את הפעולות הנתמכות עבור ה-NPU בזמן CompiledModel.from_file(). מוסיף זמן אחזור מסוים בהפעלה הראשונה (משתנה בהתאם למודל).
• ‫AOT-compiled – טעינה של <model>_IntelOpenVINO_<SoC>_apply_plugin.tflite שנוצר בשלב 4. מדלג על שלב החלוקה למחיצות ועל שלב ההידור בזמן הטעינה.

קטע הקוד הזה פועל גם עבור:

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 מצליח, היומן מכיל (סיומת הקובץ היא .so ב-Linux, ‏ .dll ב-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...

אם השורות האלה לא מופיעות אבל עדיין מדווח על Fully accelerated: True, המודל הופעל בגיבוי של XNNPACK CPU, ולא ב-NPU – אפשר לעיין בשורה של פתרון בעיות ב-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 wheel שולח קומפיילר פלאגין לכל ספק רשום (intel_openvino/, google_tensor/, mediatek/, qualcomm/, samsung/).
• כדי לכפות את הנתיב של Intel OV (מומלץ כשמותקנות כמה ערכות SDK של ספקים), מעבירים את הספריות של 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 בספריות מקבילות לא נטענים אף פעם.

ב-CLI, הדגלים המקבילים הם:

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

כדי לוודא שהמודל באמת פעל ב-NPU, צריך לבדוק אם מופיעים שני האותות:

1. היומן מכיל את Loading shared library: .../LiteRtDispatch_IntelOpenvino.{so,dll} – ספריית השליחה של Intel נטענה (.so ב-Linux, ‏ .dll ב-Windows).
2. ‫model.is_fully_accelerated() returns True — every op was offloaded to the selected accelerator.

השימוש ב-is_fully_accelerated() לבד לא מספיק: אם ספריית השליחה לא נטענה אף פעם, הפעולות הועברו במלואן ל-XNNPACK/CPU, ולא ל-NPU.

הגדרת NPU ב-Linux

הערה: אם אתם צריכים רק AOT, אתם יכולים לדלג על הקטע הזה כי לא נדרש NPU פיזי.

מידע: שימוש במנהל התקן של NPU 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

לאחר מכן מריצים את קטע הקוד להתקנה ולאימות מתוך התחלה מהירה.

הגדרה של NPU ב-Windows

הערה: אם אתם צריכים רק AOT, אתם יכולים לדלג על הקטע הזה כי לא נדרש NPU פיזי.

• מתקינים את הדרייבר של Intel NPU ‏ (32.0.100.4724+) ממרכז ההורדות של Intel.
• מוודאים שמנהל המכשירים מציג את מכשיר ה-NPU בקטע מעבדים עצביים (מוצג כ-Intel(R) AI Boost או כ-Intel(R) NPU בהתאם לדרייבר).
• מריצים את קטע הקוד להתקנה ולאימות מתוך התחלה מהירה, ומחליפים את pip ב-python -m pip.

מידע: import ai_edge_litert מתבצעת הרשמה אוטומטית של ספריות DLL באמצעות os.add_dll_directory(), כך שלא נדרשת הגדרה של PATH בסקריפטים של Python. לצרכנים שאינם משתמשים ב-Python, מריצים את הפקודה setupvars.bat או מוסיפים את הקידומת <openvino>/libs ל-PATH.

בנייה ממקור

האם אתם משתמשים בשרת Proxy? ייצוא http_proxy / https_proxy / no_proxy לפני הרצת סקריפטים של build – הם מעבירים את זה ל-Docker ולמאגר.

‫Linux (Docker, hermetic):

cd LiteRT/docker_build && ./build_wheel_with_docker.sh

‫Windows (PowerShell, ‏ Bazel בנתיב):

.\ci\build_pip_package_with_bazel_windows.ps1

הפלט נשמר ב-dist/:

• ‫ai_edge_litert-*.whl – גלגל זמן הריצה.
• ‫ai_edge_litert_sdk_{intel,qualcomm,mediatek,samsung}-*.tar.gz — vendor sdists.
• קובץ ה-sdist של Intel הוא בנפח של כ-5KB. קומפיילר ה-NPU‏ .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

פתרון בעיות

מגבלות

רק מכשיר ה-NPU נתמך דרך נתיב השליחה של OpenVINO. למסקנות של CPU, משתמשים רק ב-HardwareAccelerator.CPU (XNNPACK).

השלבים הבאים

1. כדאי להתחיל עם המדריך המאוחד של NPU: האצת NPU באמצעות LiteRT
2. פועלים לפי השלבים להמרת הקובץ ולפריסה שלו, ובוחרים באפשרות Qualcomm במקומות הרלוונטיים.
3. למודלים של שפה גדולה (LLM), ראו הפעלת LLM ב-NPU באמצעות LiteRT-LM.