LiteRT ile NPU hızlandırması

LiteRT, tedarikçiye özel derleyiciler, çalışma zamanları veya kitaplık bağımlılıklarında gezinmenizi gerektirmeden sinirsel işlem birimlerini (NPU'lar) kullanmak için birleşik bir arayüz sağlar. NPU hızlandırması için LiteRT kullanmak, gerçek zamanlı ve büyük model çıkarımı için performansı artırır ve sıfır kopyalı donanım arabelleği kullanımıyla bellek kopyalarını en aza indirir.

Başlayın

• Klasik makine öğrenimi modelleri için aşağıdaki demo uygulamalarına bakın.
  • Görüntü segmentasyonu Kotlin uygulaması: sırasıyla AOT derleme ve cihaz üzerinde (JIT) derleme için örnekler sağlar.
  • Eşzamansız segmentasyon C++ uygulaması: Aynı uygulamada hem AOT derlemesini hem de cihaz üzerinde (JIT) derlemeyi gösterir.
• Büyük Dil Modelleri (LLM'ler) için LiteRT-LM kullanarak NPU'da LLM'leri çalıştırma rehberine bakın.

NPU Tedarikçileri

LiteRT, aşağıdaki tedarikçilerle NPU hızlandırmayı destekler:

Qualcomm AI Engine Direct

• CompiledModel API aracılığıyla AOT ve cihaz üzerinde derleme yürütme desteği.
• Kurulum ayrıntıları için Qualcomm AI Engine Direct başlıklı makaleyi inceleyin.
• En son güncellemeler için Unlocking Peak Performance on Qualcomm NPU with LiteRT (LiteRT ile Qualcomm NPU'da En Yüksek Performansı Elde Etme) başlıklı makaleye bakın.

MediaTek NeuroPilot

• CompiledModel API aracılığıyla AOT ve cihaz üzerinde derleme yürütme desteği.
• Kurulum ayrıntıları için MediaTek NeuroPilot başlıklı makaleyi inceleyin.
• En son güncellemeler için MediaTek NPU and LiteRT: Powering the next generation of on-device AI (MediaTek NPU ve LiteRT: Cihaz üzerinde yapay zekanın yeni neslini destekleme) başlıklı makaleye göz atın.

Google Tensor

Google Tensor SDK'sı deneysel erişim aşamasındadır. Buradan kaydolun.

AOT ve cihaz üzerinde derleme

LiteRT NPU, özel dağıtım gereksinimlerinizi karşılamak için hem AOT hem de cihaz üzerinde derlemeyi destekler:

• Çevrimdışı (AOT) derleme: Bu, hedef SoC'nin bilindiği büyük ve karmaşık modeller için en uygundur. Önceden derleme, başlatma maliyetlerini önemli ölçüde azaltır ve kullanıcı uygulamanızı başlattığında bellek kullanımını düşürür.
• Online (cihaz üzerinde) derleme: JIT derleme olarak da bilinir. Bu, küçük modellerin platformdan bağımsız model dağıtımı için idealdir. Model, başlatma sırasında kullanıcının cihazında derlenir. Bu nedenle, ek bir hazırlık adımı gerekmez ancak ilk çalıştırma maliyeti daha yüksektir.

Aşağıdaki kılavuzda, hem AOT hem de cihaz üzerinde derleme için üç adımda nasıl dağıtım yapılacağı gösterilmektedir.

1. adım: Hedef NPU SoC'ler için AOT derlemesi

.tflite modelinizi desteklenen SoC'lerde derlemek için LiteRT AOT (önceden derleme) derleyicisini kullanabilirsiniz. Ayrıca, tek bir derleme işlemi içinde birden fazla SoC tedarikçisini ve sürümünü aynı anda hedefleyebilirsiniz. Daha fazla bilgiyi LiteRT AOT Compilation not defterinde bulabilirsiniz. İsteğe bağlı olmakla birlikte, AOT derlemesi, cihazdaki başlatma süresini azaltmak için daha büyük modellerde kesinlikle önerilir. Bu adım, cihaz üzerinde derleme için gerekli değildir.

2. adım: Android'deyseniz Google Play ile dağıtın

Android'de, model ve NPU çalışma zamanı kitaplıklarını uygulamanızla birlikte dağıtmak için Google Play for On-device AI (PODAI)'yi kullanın.

• Cihaz üzerinde derleme modelleri için: Orijinal .tflite model dosyasını doğrudan uygulamanızın assets/ dizinine ekleyin.
  • Örnek uygulamayı Segmentation on-device compilation Kotlin App'te görebilirsiniz.
• AOT derleme modelleri için: Derlenmiş modellerinizi tek bir Google Play AI Paketi olarak dışa aktarmak için LiteRT'yi kullanın. Ardından, derlenmiş doğru modelleri kullanıcıların cihazlarına otomatik olarak göndermek için yapay zeka paketini Google Play'e yüklersiniz.
  • Derlenmiş modelleri Play AI Pack'e aktarma talimatları için LiteRT AOT Compilation notebook'u inceleyin.
  • Segmentation AOT compilation Kotlin App'te örnek uygulamayı inceleyin.
• NPU çalışma zamanı kitaplıkları için, kullanıcıların cihazlarına doğru çalışma zamanı kitaplıklarını dağıtmak üzere Play Feature Delivery'yi kullanın.

Play Yapay Zeka Paketi ve Play Feature Delivery ile dağıtım hakkında bilgi edinmek için aşağıdaki bölümlere bakın.

Play Yapay Zeka Paketi ile AOT modellerini dağıtma

Aşağıdaki adımlar, Play Yapay Zeka Paketleri'ni kullanarak AOT ile derlenmiş modellerinizi dağıtma konusunda size yol gösterir.

Projeye Yapay Zeka Paketi ekleme

Yapay zeka paketlerini, Gradle projesinin kök dizinine kopyalayarak Gradle projesine aktarın. Örneğin:

my_app/
    ...
    ai_packs/
        my_model/...
        my_model_mtk/...

Her bir yapay zeka paketini Gradle derleme yapılandırmasına ekleyin:

// my_app/ai_packs/my_model/build.gradle.kts

plugins { id("com.android.ai-pack") }

aiPack {
  packName = "my_model"  // ai pack dir name
  dynamicDelivery { deliveryType = "on-demand" }
}

// Add another build.gradle.kts for my_model_mtk/ as well

Gradle yapılandırmasına yapay zeka paketleri ekleme

Oluşturulan yapay zeka paketlerindeki device_targeting_configuration.xml öğesini ana uygulama modülünün dizinine kopyalayın. Ardından settings.gradle.kts öğesini güncelleyin:

// my_app/setting.gradle.kts

...
// AI Packs
include(":ai_packs:my_model")
include(":ai_packs:my_model_mtk")

build.gradle.kts adresini güncelleyin:

// my_app/build.gradle.kts

android {
 ...

 defaultConfig {
    ...
    // API level 31+ is required for NPU support.
    minSdk = 31
  }

  // AI Packs
  assetPacks.add(":ai_packs:my_model")
  assetPacks.add(":ai_packs:my_model_mtk")
}

İsteğe bağlı teslimat için Yapay Zeka Paketini yapılandırma

İsteğe bağlı teslimat, modeli çalışma zamanında istemenize olanak tanır. Bu özellik, modelin yalnızca belirli kullanıcı akışları için gerekli olduğu durumlarda kullanışlıdır. Modeliniz, uygulamanızın dahili depolama alanına indirilir. build.gradle.kts dosyasında yapılandırılmış Android Yapay Zeka Paketi özelliğiyle cihaz özelliklerini kontrol edin. Ayrıca, PODAI'nin yükleme zamanı dağıtımı ve hızlı takip dağıtımı ile ilgili talimatlarını da inceleyin.

val env = Environment.create(BuiltinNpuAcceleratorProvider(context))

val modelProvider = AiPackModelProvider(
    context, "my_model", "model/my_model.tflite") {
    if (NpuCompatibilityChecker.Qualcomm.isDeviceSupported())
      setOf(Accelerator.NPU) else setOf(Accelerator.CPU, Accelerator.GPU)
}
val mtkModelProvider = AiPackModelProvider(
    context, "my_model_mtk", "model/my_model_mtk.tflite") {
    if (NpuCompatibilityChecker.Mediatek.isDeviceSupported())
      setOf(Accelerator.NPU) else setOf()
}
val modelSelector = ModelSelector(modelProvider, mtkModelProvider)
val model = modelSelector.selectModel(env)

val compiledModel = CompiledModel.create(
    model.getPath(),
    CompiledModel.Options(model.getCompatibleAccelerators()),
    env,
)

Play Feature Delivery ile NPU çalışma zamanı kitaplıklarını dağıtma

Play Feature Delivery, ilk indirme boyutunu optimize etmek için yükleme sırasında yayınlama, isteğe bağlı yayınlama, koşullu yayınlama ve anında yayınlama dahil olmak üzere birden fazla yayınlama seçeneğini destekler. Burada, temel yükleme zamanı teslimat kılavuzu gösterilmektedir.

Projeye NPU çalışma zamanı kitaplıklarını ekleme

AOT derlemesi için litert_npu_runtime_libraries.zip veya cihaz üzerinde derleme için litert_npu_runtime_libraries_jit.zip dosyasını indirip projenin kök dizininde açın:

my_app/
    ...
    litert_npu_runtime_libraries/
        mediatek_runtime/...
        qualcomm_runtime_v69/...
        qualcomm_runtime_v73/...
        qualcomm_runtime_v75/...
        qualcomm_runtime_v79/...
        qualcomm_runtime_v81/...
        fetch_qualcomm_library.sh

NPU destek kitaplıklarını indirmek için komut dosyasını çalıştırın. Örneğin, Qualcomm NPU'lar için aşağıdakileri çalıştırın:

$ ./litert_npu_runtime_libraries/fetch_qualcomm_library.sh

NPU çalışma zamanı kitaplıklarını Gradle yapılandırmasına ekleme

Oluşturulan yapay zeka paketlerindeki device_targeting_configuration.xml öğesini ana uygulama modülünün dizinine kopyalayın. Ardından settings.gradle.kts öğesini güncelleyin:

// my_app/setting.gradle.kts

...
// NPU runtime libraries
include(":litert_npu_runtime_libraries:runtime_strings")

include(":litert_npu_runtime_libraries:mediatek_runtime")
include(":litert_npu_runtime_libraries:qualcomm_runtime_v69")
include(":litert_npu_runtime_libraries:qualcomm_runtime_v73")
include(":litert_npu_runtime_libraries:qualcomm_runtime_v75")
include(":litert_npu_runtime_libraries:qualcomm_runtime_v79")
include(":litert_npu_runtime_libraries:qualcomm_runtime_v81")

build.gradle.kts adresini güncelleyin:

// my_app/build.gradle.kts

android {
 ...
 defaultConfig {
    ...
    // API level 31+ is required for NPU support.
    minSdk = 31

    // NPU only supports arm64-v8a
    ndk { abiFilters.add("arm64-v8a") }
    // Needed for Qualcomm NPU runtime libraries
    packaging { jniLibs { useLegacyPackaging = true } }
  }

  // Device targeting
  bundle {
      deviceTargetingConfig = file("device_targeting_configuration.xml")
      deviceGroup {
        enableSplit = true // split bundle by #group
        defaultGroup = "other" // group used for standalone APKs
      }
  }

  // NPU runtime libraries
  dynamicFeatures.add(":litert_npu_runtime_libraries:mediatek_runtime")
  dynamicFeatures.add(":litert_npu_runtime_libraries:qualcomm_runtime_v69")
  dynamicFeatures.add(":litert_npu_runtime_libraries:qualcomm_runtime_v73")
  dynamicFeatures.add(":litert_npu_runtime_libraries:qualcomm_runtime_v75")
  dynamicFeatures.add(":litert_npu_runtime_libraries:qualcomm_runtime_v79")
  dynamicFeatures.add(":litert_npu_runtime_libraries:qualcomm_runtime_v81")
}

dependencies {
  // Dependencies for strings used in the runtime library modules.
  implementation(project(":litert_npu_runtime_libraries:runtime_strings"))
  ...
}

3. adım: LiteRT çalışma zamanını kullanarak NPU'da çıkarım yapma

LiteRT, belirli SoC sürümlerine göre geliştirme yapmanın karmaşıklığını ortadan kaldırarak modelinizi NPU'da yalnızca birkaç satır kodla çalıştırmanıza olanak tanır. Ayrıca, sağlam ve yerleşik bir yedek mekanizma sağlar: Seçenek olarak CPU, GPU veya her ikisini de belirtebilirsiniz. NPU kullanılamıyorsa LiteRT bunları otomatik olarak kullanır. AOT derlemesi, geri dönüşü de destekler. Desteklenmeyen alt grafiklerin belirtildiği şekilde CPU veya GPU'da sorunsuz bir şekilde çalıştırıldığı NPU'da kısmi temsilci atama sağlar.

Kotlin'de çalıştırma

Aşağıdaki demo uygulamalarda örnek uygulamayı inceleyin:

• Cihaz üzerinde derleme Kotlin uygulamasında segmentasyon
• Segmentation AOT compilation Kotlin App

Android bağımlılıkları ekleme

En son LiteRT Maven paketini build.gradle bağımlılıklarınıza ekleyebilirsiniz:

dependencies {
  ...
  implementation("com.google.ai.edge.litert:litert:+")
}

Çalışma zamanı entegrasyonu

// 1. Load model and initialize runtime.
// If NPU is unavailable, inference will fallback to GPU.
val model =
    CompiledModel.create(
        context.assets,
        "model/mymodel.tflite",
        CompiledModel.Options(Accelerator.NPU, Accelerator.GPU)
    )

// 2. Pre-allocate input/output buffers
val inputBuffers = model.createInputBuffers()
val outputBuffers = model.createOutputBuffers()

// 3. Fill the first input
inputBuffers[0].writeFloat(...)

// 4. Invoke
model.run(inputBuffers, outputBuffers)

// 5. Read the output
val outputFloatArray = outputBuffers[0].readFloat()

C++ platformlar arası çalıştırma

Örnek uygulamayı Asynchronous segmentation C++ App'te (Zaman uyumsuz segmentasyon C++ uygulaması) görebilirsiniz.

Bazel derleme bağımlılıkları

C++ kullanıcıları, uygulamanın bağımlılıklarını LiteRT NPU hızlandırmasıyla oluşturmalıdır. Temel uygulama mantığını paketleyen cc_binary kuralı (ör. main.cc) için aşağıdaki çalışma zamanı bileşenleri gerekir:

• LiteRT C API paylaşılan kitaplığı: data özelliği, LiteRT C API paylaşılan kitaplığını (//litert/c:litert_runtime_c_api_shared_lib) ve NPU için tedarikçiye özel dağıtım paylaşılan nesnesini (//litert/vendors/qualcomm/dispatch:dispatch_api_so) içermelidir.
• NPU'ya özel arka uç kitaplıkları: Örneğin, Android ana makinesi için Qualcomm AI RT (QAIRT) kitaplıkları (libQnnHtp.so, libQnnHtpPrepare.so gibi) ve ilgili Hexagon DSP kitaplığı (libQnnHtpV79Skel.so). Bu, LiteRT çalışma zamanının hesaplamaları NPU'ya aktarabilmesini sağlar.
• Özellik bağımlılıkları: deps özelliği, LiteRT'nin tensör arabelleği (//litert/cc:litert_tensor_buffer) ve NPU dağıtım katmanının API'si (//litert/vendors/qualcomm/dispatch:dispatch_api) gibi temel derleme zamanı bağımlılıklarına karşı bağlantı oluşturur. Bu, uygulama kodunuzun LiteRT aracılığıyla NPU ile etkileşim kurmasını sağlar.
• Model dosyaları ve diğer öğeler: data özelliği aracılığıyla eklenir.

Bu kurulum, derlenmiş ikilinizin hızlandırılmış makine öğrenimi çıkarımı için NPU'yu dinamik olarak yüklemesine ve kullanmasına olanak tanır.

NPU ortamı ayarlama

Bazı NPU arka uçları, çalışma zamanı bağımlılıkları veya kitaplıklar gerektirir. Derlenmiş model API'si kullanılırken LiteRT, bu gereksinimleri bir Environment nesnesi aracılığıyla düzenler. Uygun NPU kitaplıklarını veya sürücülerini bulmak için aşağıdaki kodu kullanın:

// Provide a dispatch library directory (following is a hypothetical path) for the NPU
std::vector<Environment::Option> environment_options = {
    {
      Environment::OptionTag::DispatchLibraryDir,
      "/usr/lib64/npu_dispatch/"
    }
};

LITERT_ASSIGN_OR_RETURN(auto env, Environment::Create(absl::MakeConstSpan(environment_options)));

Çalışma zamanı entegrasyonu

Aşağıdaki kod snippet'inde, tüm sürecin C++'taki temel uygulaması gösterilmektedir:

// 1. Load the model that has NPU-compatible ops
LITERT_ASSIGN_OR_RETURN(auto model, Model::Load("mymodel_npu.tflite"));

// 2. Create a compiled model with NPU acceleration
//    See following section on how to set up NPU environment
LITERT_ASSIGN_OR_RETURN(auto compiled_model,
  CompiledModel::Create(env, model, kLiteRtHwAcceleratorNpu));

// 3. Allocate I/O buffers
LITERT_ASSIGN_OR_RETURN(auto input_buffers, compiled_model.CreateInputBuffers());
LITERT_ASSIGN_OR_RETURN(auto output_buffers, compiled_model.CreateOutputBuffers());

// 4. Fill model inputs (CPU array -> NPU buffers)
float input_data[] = { /* your input data */ };
input_buffers[0].Write<float>(absl::MakeConstSpan(input_data, /*size*/));

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

// 6. Access model output
std::vector<float> data(output_data_size);
output_buffers[0].Read<float>(absl::MakeSpan(data));

NPU hızlandırmasıyla sıfır kopyalama

Sıfır kopyalama, NPU'nun verileri doğrudan kendi belleğinde erişmesini sağlar. Bu durumda CPU'nun verileri açıkça kopyalaması gerekmez. Verileri CPU belleğine ve CPU belleğinden kopyalamayarak sıfır kopyalama, uçtan uca gecikmeyi önemli ölçüde azaltabilir.

Aşağıdaki kod, verileri doğrudan NPU'ya aktararak AHardwareBuffer ile Sıfır Kopyalı NPU'nun örnek bir uygulamasıdır. Bu uygulama, CPU belleğine yapılan pahalı gidiş-gelişleri önleyerek çıkarım yükünü önemli ölçüde azaltır.

// Suppose you have AHardwareBuffer* ahw_buffer

LITERT_ASSIGN_OR_RETURN(auto tensor_type, model.GetInputTensorType("input_tensor"));

LITERT_ASSIGN_OR_RETURN(auto npu_input_buffer, TensorBuffer::CreateFromAhwb(
    env,
    tensor_type,
    ahw_buffer,
    /* offset = */ 0
));

std::vector<TensorBuffer> input_buffers{npu_input_buffer};

LITERT_ASSIGN_OR_RETURN(auto output_buffers, compiled_model.CreateOutputBuffers());

// Execute the model
compiled_model.Run(input_buffers, output_buffers);

// Retrieve the output (possibly also an AHWB or other specialized buffer)
auto ahwb_output = output_buffers[0].GetAhwb();

Birden fazla NPU çıkarımını zincirleme

Karmaşık işlem hatları için birden fazla NPU çıkarımını zincirleyebilirsiniz. Her adımda hızlandırıcı dostu bir arabellek kullanıldığından işlem hattınız çoğunlukla NPU tarafından yönetilen bellekte kalır:

// compiled_model1 outputs into an AHWB
compiled_model1.Run(input_buffers, intermediate_buffers);

// compiled_model2 consumes that same AHWB
compiled_model2.Run(intermediate_buffers, final_outputs);

NPU cihaz üzerinde derleme önbelleğe alma

LiteRT, .tflite modellerinin cihaz üzerinde NPU (JIT olarak bilinir) derlemesini destekler. JIT derlemesi, özellikle modelin önceden derlenmesinin mümkün olmadığı durumlarda faydalı olabilir.

Ancak JIT derlemesi, kullanıcı tarafından sağlanan modeli isteğe bağlı olarak NPU bayt kodu talimatlarına çevirmek için bir miktar gecikme ve bellek ek yüküyle birlikte gelebilir. Performans etkisini en aza indirmek için NPU derleme yapıları önbelleğe alınabilir.

Önbelleğe alma etkinleştirildiğinde LiteRT, modelin yeniden derlenmesini yalnızca gerektiğinde tetikler. Örneğin:

• Sağlayıcının NPU derleyici eklentisinin sürümü değiştiyse
• Android derleme parmak izi değiştiyse,
• Kullanıcı tarafından sağlanan model değiştiyse;
• Derleme seçenekleri değişti.

NPU derleme önbelleğini etkinleştirmek için ortam seçeneklerinde CompilerCacheDir ortam etiketini belirtin. Değer, uygulamanın mevcut bir yazılabilir yolu olarak ayarlanmalıdır.

   const std::array environment_options = {
        litert::Environment::Option{
            /*.tag=*/litert::Environment::OptionTag::CompilerPluginLibraryDir,
            /*.value=*/kCompilerPluginLibSearchPath,
        },
        litert::Environment::Option{
            litert::Environment::OptionTag::DispatchLibraryDir,
            kDispatchLibraryDir,
        },
        // 'kCompilerCacheDir' will be used to store NPU-compiled model
        // artifacts.
        litert::Environment::Option{
            litert::Environment::OptionTag::CompilerCacheDir,
            kCompilerCacheDir,
        },
    };

    // Create an environment.
    LITERT_ASSERT_OK_AND_ASSIGN(
        auto environment, litert::Environment::Create(environment_options));

    // Load a model.
    auto model_path = litert::testing::GetTestFilePath(kModelFileName);
    LITERT_ASSERT_OK_AND_ASSIGN(auto model,
                                litert::Model::CreateFromFile(model_path));

    // Create a compiled model, which only triggers NPU compilation if
    // required.
    LITERT_ASSERT_OK_AND_ASSIGN(
        auto compiled_model, litert::CompiledModel::Create(
                                 environment, model, kLiteRtHwAcceleratorNpu));

Örnek gecikme ve bellek tasarrufu:

NPU derlemesi için gereken süre ve bellek, temel alınan NPU çipi ve giriş modelinin karmaşıklığı gibi çeşitli faktörlere bağlı olarak değişebilir.

Aşağıdaki tabloda, NPU derlemesi gerektiğinde ve önbelleğe alma nedeniyle derlemenin atlanabildiği durumlarda çalışma zamanı başlatma süresi ve bellek tüketimi karşılaştırılmaktadır. Bir örnek cihazda aşağıdakileri elde ederiz:

Başka bir cihazda aşağıdaki bilgileri alırız: