LiteRT ile Intel NPU (OpenVino)

LiteRT, hem AOT hem de cihaz üzerinde derleme için CompiledModel API'si aracılığıyla Intel OpenVino'yu destekler.

Python API

Geliştirme ortamını kurma

Linux (x86_64):

• Ubuntu 22.04 veya 24.04 LTS
• Python 3.10 veya daha yeni bir sürüm — python.org adresinden veya dağıtımınızdan (sudo apt install python3 python3-venv) yükleyin.
• Intel NPU sürücüsü v1.32.1 — Linux NPU Kurulumu'na bakın.

Windows (x86_64):

• Windows 10 veya 11
• Python 3.10 veya sonraki bir sürüm — python.org adresinden yükleyin.
• Intel NPU sürücüsü 32.0.100.4724+ — Windows NPU Kurulumu bölümüne bakın.

Kaynaktan derleme için Bazelisk kullanılan Bazel 7.4.1+ veya hermetik Docker derlemesi de gereklidir.

Desteklenen çip üzerinde sistemler

Hızlı Başlangıç

1. NPU sürücülerini yükleme

Linux NPU Kurulumu veya Windows NPU Kurulumu başlıklı makaleyi inceleyin. Yalnızca AOT'ye ihtiyacınız varsa bu adımı atlayın.

NPU sürücüsü yalnızca modeli NPU donanımında çalıştıran sistemlerde gereklidir. Tam AOT derleme sistemleri bu adımı atlayabilir.

Not: ai-edge-litert-sdk-intel-nightly, PEP 440 sürümüne göre (ör.openvino==2026.2.0.dev20260506) eşleşen OpenVINO gece sürümü tekerleğini sabitler. Bu nedenle, pip'in bunu bulması için --extra-index-url https://storage.openvinotoolkit.org/simple/wheels/nightly gerekir. Linux'ta dağıtım otomatik algılama özelliği yanlış arşivi seçerse pip install öncesinde LITERT_OV_OS_ID=ubuntu22 veya ubuntu24'ı ayarlayın.

2. Python sanal ortamı oluşturma

Gece derlemesi openvino tekerleğinin, sistem genelinde OpenVINO yüklemelerinden izole edilmesi önerilir.

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 paketini yükleme

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'in OpenVINO'nun dizinindeki sabitlenmiş openvino nightly wheel'ı PyPI'deki paketlerle birlikte çözmesine olanak tanır.

4. Kurulumu doğrulama

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

Çıkışta kontrol edilecekler:

• SDK libs listeleri libopenvino_intel_npu_compiler.so (Linux) veya openvino_intel_npu_compiler.dll (Windows) — AOT için gereklidir.
• Available devices, NPU içerir. Bu, NPU sürücüsünün yüklendiğini ve OpenVINO'nun cihazla iletişim kurabildiğini onaylar. NPU, yalnızca AOT sistemlerinde (sürücünün yüklü olmadığı) ve Intel NPU donanımı olmayan sistemlerde bulunmaz.

5. AOT derlemesi (isteğe bağlı)

• Çalışma zamanının derleyici eklentisi adımını atlaması için belirli bir Intel NPU hedefi (PTL veya LNL) için .tflite önceden derler.
• Fiziksel bir NPU veya NPU sürücüsü gerekmez. Yalnızca ai-edge-litert-nightly ve ai-edge-litert-sdk-intel-nightly yeterlidir.
• Çapraz derleme desteklenir: Herhangi bir Linux veya Windows ana makinesinde derleme yapın, sonuçtaki .tflite dosyasını her iki işletim sisteminin hedefinde gönderin ve orada çalıştırın.

Çıkış dosyaları <model>_IntelOpenVINO_<SoC>_apply_plugin.tflite olarak adlandırılır.

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 çıkarımı çalıştırma

LiteRT, Intel NPU'da iki çıkarım yolunu destekler:

• JIT: Ham .tflite yükleyin. Derleyici eklentisi, CompiledModel.from_file() zamanında NPU için desteklenen işlemleri bölümlendirir ve derler. İlk çalıştırma gecikmesi ekler (modele göre değişir).
• AOT ile derlenmiş: <model>_IntelOpenVINO_<SoC>_apply_plugin.tflite ile üretilen bir <model>_IntelOpenVINO_<SoC>_apply_plugin.tflite yükleyin. Yükleme sırasında bölümleme ve derleme adımını atlar.

Bu snippet her ikisi için de çalışır:

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'nin gerçekten çalıştırıldığını onaylama

JIT başarılı olduğunda günlükte şunlar yer alır (Linux'ta dosya uzantısı .so, Windows'da .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...

Bu satırlar yoksa ancak Fully accelerated: True yine de bildiriliyorsa model, NPU'da değil XNNPACK CPU yedeklemesinde çalıştırılmıştır. JIT ile ilgili sorun giderme satırına bakın.

7. Karşılaştırma

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

Sık kullanılan işaretler:

Gelişmiş / geçersiz kılma işaretleri: Yalnızca özel derlemelere yönlendirmek için gereklidir: --dispatch_library_path, --compiler_plugin_path, --runtime_path.

Farklı tedarikçilere ait tekerlekler: JIT'yi Intel OV'ye sabitleme

Not: Environment.create(), açık yollar olmadan çağrıldığında ai_edge_litert/vendors/ altındaki sağlayıcıları alfabetik sırayla otomatik olarak keşfeder ve bulduğu ilk sağlayıcıyı kaydeder. Karma tedarikçi kurulumunda bu, Intel OV olmayabilir. Doğru seçimi zorlamak için Intel OV dizinlerini açıkça iletin.

• pip wheel, kayıtlı her satıcı için derleyici eklentileri gönderir (intel_openvino/, google_tensor/, mediatek/, qualcomm/, samsung/).
• Intel OV yolunu zorlamak için (birden fazla tedarikçi SDK'sı yüklendiğinde önerilir) Intel OV dizinlerini manuel olarak iletin:

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

Çalışma zamanı, belirtilen dizinde bulduğu her paylaşılan kitaplığı yükler. Bu nedenle, vendors/intel_openvino/compiler/ dizinini işaret ettiğinizde yalnızca Intel eklentisi yüklenir. Kardeş dizinlerdeki Google Tensor / MediaTek / Qualcomm / Samsung eklentilerine hiçbir zaman dokunulmaz.

CLI için eşdeğer işaretler şunlardır:

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 Yürütme İşlemini Doğrulama

Modelin gerçekten NPU'da çalıştığını onaylamak için her iki sinyali de kontrol edin:

1. Günlük, Loading shared library: .../LiteRtDispatch_IntelOpenvino.{so,dll} öğesini içerir. Intel dağıtım kitaplığı yüklendi (Linux'ta .so, Windows'da .dll).
2. model.is_fully_accelerated(), True döndürür. Her işlem, seçilen hızlandırıcıya aktarılmıştır.

is_fully_accelerated() tek başına yeterli değildir: Gönderme kitaplığı hiç yüklenmediyse işlemler NPU'ya değil, XNNPACK/CPU'ya tamamen aktarılır.

Linux NPU Kurulumu

Not: Yalnızca AOT'ye ihtiyacınız varsa bu bölümü atlayın. Fiziksel bir NPU gerekmez.

Bilgi: NPU sürücüsü v1.32.1 (OpenVINO 2026.1 ile eşleştirilmiş) kullanın. Eski sürücüler Level0 pfnCreate2 result: ZE_RESULT_ERROR_UNSUPPORTED_FEATURE ile başarısız olur.

# 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

Ardından Hızlı Başlangıç'taki yükleme + doğrulama snippet'ini çalıştırın.

Windows NPU Kurulumu

Not: Yalnızca AOT'ye ihtiyacınız varsa bu bölümü atlayın. Fiziksel bir NPU gerekmez.

• Intel İndirme Merkezi'nden Intel NPU sürücüsünü (32.0.100.4724+) yükleyin.
• Cihaz Yönetim Paneli'nin NPU cihazını Sinirsel işlemciler altında listelediğini doğrulayın (sürücüye bağlı olarak Intel(R) AI Boost veya Intel(R) NPU olarak gösterilir).
• Hızlı Başlangıç'tan yükleme + doğrulama snippet'ini çalıştırın ve pip yerine python -m pip yazın.

Bilgi: import ai_edge_litert, os.add_dll_directory() kullanarak DLL dizinlerini otomatik olarak kaydeder. Bu nedenle, Python komut dosyaları için PATH kurulumu gerekmez. Python kullanmayanlar için setupvars.bat komutunu çalıştırın veya PATH komutunun başına <openvino>/libs ekleyin.

Kaynaktan derleme

Proxy kullanıyor musunuz? Derleme komut dosyalarını çalıştırmadan önce http_proxy / https_proxy / no_proxy öğelerini dışa aktarın. Bu öğeler Docker'a ve kapsayıcıya yönlendirilir.

Linux (Docker, hermetik):

cd LiteRT/docker_build && ./build_wheel_with_docker.sh

Windows (PATH'te PowerShell, Bazel):

.\ci\build_pip_package_with_bazel_windows.ps1

Çıktılar dist/ konumuna kaydedilir:

• ai_edge_litert-*.whl — çalışma zamanı tekerleği.
• ai_edge_litert_sdk_{intel,qualcomm,mediatek,samsung}-*.tar.gz — vendor sdists.
• Intel sdist'i yaklaşık 5 KB'tır. NPU derleyicisi .so/.dll, pip install zamanında getirilir. Bu nedenle aynı sdist, Linux ve Windows'ta çalışır.

Birim Testleri

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

Sorun giderme

Sınırlamalar

OpenVINO gönderme yolu üzerinden yalnızca NPU cihazı desteklenir. CPU çıkarımı için yalnızca HardwareAccelerator.CPU (XNNPACK) kullanın.

C++ API'si

Ön koşullar ve derleme kurulumu

Derleme ön koşulları:

• Visual Studio 2022 veya sonraki bir sürüm (C++ geliştirme araçları yüklü olmalıdır).
• git: https://git-scm.com/install/ adresinden git'i yükleyin. LiteRT/LiteRT-LM derleme işlemlerinin bash.exe ve git.exe'yi bulabilmesi için sisteminizin PATH ortam değişkenine C:\Program Files\Git\bin and C:\Program Files\Git\cmd eklediğinizden emin olun.
• bazelisk: Bazelisk'i yükleyin ve konumunu sisteminizin PATH ortam değişkenine ekleyin: https://bazel.build/install/bazelisk.
• Cmake: https://cmake.org/download/ adresinden Cmake 4.3.0 veya sonraki bir sürümünü yükleyin ve Cmake'in sisteminizin PATH'ine dahil edildiğini doğrulayın.
• Python: Python 3.11 veya sonraki bir sürümün yüklendiğinden ve python.exe'nin PATH'inizde olduğundan emin olun.
• Windows Ayarları: Windows Ayarları'nda Geliştirici Modu'nu etkinleştirin.

Intel NPU için LiteRT araçları ve eklentileri oluşturma

LiteRT ile Intel NPU'da modellerin çalıştırılabilmesi için LiteRT Intel OpenVINO derleyici eklentisi kullanılarak derlenmeleri gerekir. Ayrıca, Intel NPU'da yürütülmek üzere derlenen tüm modeller, LiteRT Intel OpenVINO dağıtım eklentisine devredilmelidir.

LiteRT'nin bu eklentileri çağırma mekanizması aşağıda gösterilmiştir:

LiteRT araçları ve Intel eklentileri oluşturma adımları.

LiteRT'den herhangi bir yürütülebilir dosya veya kitaplık oluşturmadan önce yerel bir dizin oluşturun (ör. C:\bzl). Derleme çıkışı ikili dosyası bu dizinden toplanır. Intel OpenVINO dispatch eklentisini oluşturma

# At the top-level directory of LiteRT repository
bazelisk --output_base=C:\bzl build //litert/vendors/intel_openvino/dispatch:LiteRtDispatch --config=windows

Alternatif olarak, hedef öğeye @litert önekini ekleyerek LiteRT-LM deposundan da dağıtım eklentisini oluşturabilirsiniz. Bu durum, LiteRT deposundaki aşağıdaki tüm hedefler için benzerdir.

# At the top-level directory of LiteRT-LM repository
bazelisk --output_base=C:\bzl build @litert//litert/vendors/intel_openvino/dispatch:LiteRtDispatch --config=windows

Intel OpenVINO derleyici eklentisini oluşturma

bazelisk --output_base=C:\bzl build //litert/vendors/intel_openvino/compiler:LiteRtCompilerPlugin --config=windows

Build LiteRT Ahead-of-Time (AOT) derleyici yardımcı programı Bazı LiteRT araçları, Intel NPU'da çalıştırılmadan önce modellerin açıkça AOT derlenmesini gerektirir. LiteRT AOT derleyici yardımcı programının derleme talimatı:

bazelisk --output_base=C:\bzl build
//litert/tools:apply_plugin_main --config=windows

LiteRT model çalıştırıcı oluşturma LiteRT model çalıştırıcı, bir modeli Intel NPU'da çalıştırmak için kullanılabilir. Bu model, önceden derlenmemiş veya AOT derlenmiş olabilir. Model oluşturma talimatı runner:

bazelisk --output_base=C:\bzl build //litert/tools:run_model --config=windows

LiteRT karşılaştırma modeli yardımcı programını oluşturma LiteRT model karşılaştırma aracı, Intel NPU'da bir modelin çıkarım performansını karşılaştırmak için kullanılabilir. Karşılaştırma aracı oluşturma talimatı varsa:

bazelisk --output_base=C:\bzl build //litert/tools:benchmark_model --config=windows --define=protobuf_allow_msvc=true

LiteRT sayısal değer kontrolü yardımcı programını oluşturma

bazelisk --output_base=C:\bzl build //litert/tools:npu_numerics_check --config=windows

Gelişmiş kullanım: Özelleştirilmiş Intel OpenVINO SDK ile geliştirme

LiteRT derleme sistemi, derleyiciyi ve dağıtım eklentilerini derlerken önceden oluşturulmuş Intel OpenVINO SDK'sını otomatik olarak getirir.

Projeniz için Intel OpenVINO SDK'nın belirli veya özelleştirilmiş bir sürümü gerekiyorsa eklenti derlemesini başlatmadan önce aşağıdaki ek yapılandırma adımlarını tamamlayın:

1. Windows için en son OpenVINO sürümünün ikili dosyasını https://www.intel.com/content/www/us/en/download/753640/intel-distribution-of-openvino-toolkit.html adresinden indirip yerel diske (ör. C:\Intel\intel_openvino) çıkarın.
2. Bu yolun altındaki tek alt dizinin "openvino" olarak adlandırıldığından ve "runtime" ile "include" gibi alt dizinler içerdiğinden emin olun.
3. Konsolunuzda (komut istemi veya PowerShell) klonlanmış LiteRT deposunun kök dizinine gidin ve OPENVINO_NATIVE_DIR değişkenini ayarlayın (sondaki \`), for example:set OPENVINO_NATIVE_DIR=C:\Intel\intel_openvino` karakterinin olmadığından emin olun).

Özel modellerin AOT derlemesi

Bu bölümde ortam hazırlanır ve LiteRT için özel TFLite, PyTorch veya JAX modellerinin AOT derlemesi gerçekleştirilir.

Intel NPU için model derleme işlemi sırasında LiteRT, model grafiğini LiteRT Intel OpenVINO derleyici eklentisi tarafından desteklenen operatörlere göre doğrular. Derleyici eklentisiyle uyumlu operatörler veya alt grafikler için LiteRT, bu tür alt grafiklerin her birini DISPATCH_OP olarak derler. Bu, daha sonra grafikteki orijinal alt grafiğin yerini alır. Intel OpenVINO derleyicisi tarafından desteklenen işlem kümesine dahil edilmeyen operatörler, grafikte değişmeden kalır. Sonuç olarak, AOT derlemesi tamamen devredilmiş veya kısmen devredilmiş bir model oluşturabilir. Tam olarak temsilci atanmış AOT ile derlenmiş model örneğini aşağıda görebilirsiniz:

Bu amaçla kullanabileceğiniz AOT derleme yardımcı programı, LiteRT apply_plugin_main yardımcı programıdır (apply_plugin_main.exe). Intel platformunda yardımcı programın örnek kullanımı:

.\apply_plugin_main.exe -cmd apply --model="C:\models\model.tflite" -o C:\models\model_aot.tflite --soc_model=PTL --soc_manufacturer "IntelOpenVINO" --libs C:\litertlibs  

Intel OpenVINO SDK'nın ikili dağıtımına dahil olan varsayılan temel NPU derleyicisinin, Intel Core Ultra Serisi 2 ve sonraki SoC'ler için kullanıldığını lütfen unutmayın. Desteklenenler listesinde yer almayan bir NPU için model derleniyorsa derleyici türü açıkça belirtilmelidir (Intel Core Ultra 2 ve sonraki sürümlerde bu işlem isteğe bağlıdır).

set IE_NPU_COMPILER_TYPE=PLUGIN

Uygulamanızda JIT ve AOT derlemesi

Modelleri kendi LiteRT uygulamanızda derlemek için iki yaklaşım vardır: daha önce tanıttığımız AOT derlemesi ve anında (JIT) derleme.

AOT derlemesiyle mod, dağıtımdan önce çevrimdışı olarak derlenir ve daha sonra kullanılmak üzere kaydedilebilir. Bu yöntem genellikle derleme, cihaz üzerinde çalıştırılamayacak kadar kaynak yoğun olduğunda kullanılır. Bu işlem, modeli dağıttığınız cihazda yapılmak zorunda değildir. Kodunuzda AOT derlemesi örneği:

void AotCompileForOpenVINO() {
  auto run = std::make_unique<ApplyPluginRun>();

  // Full pipeline: partition → compile → embed bytecode in .tflite
  run->cmd = ApplyPluginRun::Cmd::APPLY;

  // Path to directory containing LiteRtComplilerPlugin.dll
  run->lib_search_paths.push_back("/path/to/plugin/dir/");

  // Input model
  run->model.emplace("model.tflite");

  // Intel OpenVINO target
  run->soc_manufacturer.emplace("IntelOpenVINO");
  run->soc_models.push_back("PTL");  // or "LNL"

  // Output stream for the AOT-compiled model
  std::stringstream compiled_output;
  run->outs.push_back(compiled_output);

  // Run AOT compilation
  auto status = ApplyPlugin(std::move(run));
  // compiled_output now contains .tflite with embedded OpenVINO bytecode
}

AOT ile derlenmiş bir modelle çıkarım yapma yöntemi:

void RunAotCompiledModel() {
  auto env = litert::Environment::Create({}).value();

  // Load AOT-compiled model, still must specify NPU accelerator
  auto compiled_model = litert::CompiledModel::Create(
      env, "model_aot.tflite", litert::HwAccelerators::kNpu).value();

  auto input_buffers = compiled_model.CreateInputBuffers().value();
  auto output_buffers = compiled_model.CreateOutputBuffers().value();

  input_buffers[0].Write<float>({/* data */});
  compiled_model.Run(input_buffers, output_buffers);
}

Alternatif yaklaşım, modeli cihazda çalışma zamanında JIT derlemektir. Daha esnektir: Yalnızca tek bir arka uçtan bağımsız model dosyası gerektirir.

// Create environment
auto env = litert::Environment::Create({}).value();

// JIT compile for NPU
auto compiled_model = litert::CompiledModel::Create(
    env, "model.tflite", litert::HwAccelerators::kNpu).value();

// Create I/O buffers
auto input_buffers = compiled_model.CreateInputBuffers().value();
auto output_buffers = compiled_model.CreateOutputBuffers().value();

// Fill inputs
input_buffers[0].Write<float>({/* input data */});

// Run inference
compiled_model.Run(input_buffers, output_buffers);

benchmark_model ile karşılaştırma

LiteRT benchmark_model yardımcı programı (benchmark_model.exe), NPU'da AOT ile derlenmiş bir modelin karşılaştırmasını yapmak için özel olarak tasarlanmıştır ve LiteRT'deki CPU arka ucu (XNNPack) ile performansı karşılaştırmak için kullanılabilir. Intel NPU'da AOT ile derlenmiş bir modeli karşılaştırmak için örnek komut:

.\benchmark_model.exe --graph=C:\models\model_aot.tflite --use_npu=true --compiler_plugin_library_path=C:\litertlib --dispatch_library_path=C:\litertlib --compiler_cache_path=C:\models

npu_numerics_check ile doğruluk kontrolü

npu_numerics_check yardımcı programı, NPU'da derlenen bir modelin sayısal doğruluğunu bir temel çizgiye (genellikle CPU arka ucu, XNNPack) göre doğrulamak için kullanılır. Bu adım, NPU'ya devretme işleminin model kalitesini etkileyebilecek kabul edilemez sayısal sapmalar oluşturmadığından emin olmak için çok önemlidir.

Sayısal değer kontrolü yapma Bu yardımcı program, AOT ile derlenmiş modeli gerektirir ve çıkışlarını CPU'da çalıştırılan orijinal, devredilmemiş modelle karşılaştırır.

.\npu_numerics_check.exe --npu_model=C:\models\model_aot.tflite --cpu_model=C:\models\model.tflite --dispatch_library_path=C:\litertlib

Sonraki adımlar

1. Birleştirilmiş NPU kılavuzuyla başlayın: LiteRT ile NPU hızlandırma
2. Buradaki dönüşüm ve dağıtım adımlarını uygulayın ve uygun olduğunda Qualcomm'u seçin.
3. LLM'ler için LiteRT-LM kullanarak NPU'da LLM'leri yürütme başlıklı makaleyi inceleyin.