LiteRT ile NPU hızlandırması

LiteRT, tedarikçiye özel derleyiciler, çalışma zamanları veya kitaplık bağımlılıklarında gezinmenizi istemeden 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ında 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

NPU Tedarikçileri

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

AOT ve cihaz üzerinde derleme

LiteRT NPU, belirli dağıtım şartlarınızı 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.

Modelinizi hem AOT hem de cihaz üzerinde derleme seçeneklerini kullanarak nasıl dağıtabileceğiniz aşağıda açıklanmıştır:

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, cihaz üzerinde 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 cihaz üzerinde 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 başlıklı makaleyi inceleyin.
  • Örnek uygulamayı Segmentation AOT compilation Kotlin App'te görebilirsiniz.
• 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 paketlerinden device_targeting_configuration.xml öğesini kopyalayıp ana uygulama modülünün dizinine yapıştırı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 öğelerini güncelleme:

// 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ı yayın 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ılan Android Yapay Zeka Paketi özelliğiyle cihaz özelliklerini kontrol edin. Ayrıca PODAI'nin yükleme zamanı dağıtımı ve hızlı indirme dağıtımı ile ilgili talimatlarını da inceleyin.

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

val cpuGpuModelProvider =
      ModelProvider.staticModel(
        ModelProvider.Type.ASSET,
        "model/my_model_cpu_gpu.tflite",
        if (accelerator != Accelerator.NPU) accelerator else Accelerator.CPU,
      )

val qualcommNpuModelProvider =
  AiPackModelProvider(context, "my_model", "model/my_model.tflite")
  {
    buildSet {
      if (
        accelerator == Accelerator.NPU && NpuCompatibilityChecker.Qualcomm.isDeviceSupported()
      )
        add(Accelerator.NPU)
    }
  }

val mtkNpuModelProvider =
  AiPackModelProvider(context, "my_model_mtk", "model/my_model.tflite")
  {
    buildSet {
      if (
        accelerator == Accelerator.NPU && NpuCompatibilityChecker.Mediatek.isDeviceSupported()
      )
        add(Accelerator.NPU)
    }
  }

val googleTensorTpuModelProvider =
  AiPackModelProvider(context, "my_model", "model/my_model.tflite")
  {
    buildSet {
      if (accelerator == Accelerator.NPU &&
          NpuCompatibilityChecker.GoogleTensor.isDeviceSupported()
      )
        add(Accelerator.NPU)
    }
  }

val aiPackModelProvider =
        ModelSelector(cpuGpuModelProvider, mtkNpuModelProvider, qualcommNpuModelProvider, googleTensorTpuModelProvider)
          .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 en son sürümden litert_npu_runtime_libraries.zip dosyasını veya cihaz üzerinde derleme için en son sürümden litert_npu_runtime_libraries_jit.zip dosyasını indirip projenin kök dizininde açın:

my_app/
    ...
    litert_npu_runtime_libraries/
        google_tensor_runtime/...
        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 paketlerinden device_targeting_configuration.xml öğesini kopyalayıp ana uygulama modülünün dizinine yapıştırı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:google_tensor_runtime")
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 öğelerini güncelleme:

// 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:google_tensor_runtime")
  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 karşı geliştirme yapmanın karmaşıklığını ortadan kaldırarak modelinizi yalnızca birkaç satır kodla NPU'da çalıştırmanıza olanak tanır. Ayrıca, güçlü ve yerleşik bir yedek mekanizma sunar: 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 yetki devri sağlar.

Kotlin'de çalıştırma

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

• Cihaz üzerinde derleme Kotlin uygulamasında segmentasyon
• Segmentasyon AOT derlemesi Kotlin uygulaması

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++'ta platformlar arası çalıştırma

Asynchronous segmentation C++ App'teki örnek uygulamaya bakın.

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 yapay zeka 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 yük 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ılar 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ş ikili programınızın 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. LiteRT, derlenmiş model API'sini kullanırken 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 kullanıldığında NPU, verileri doğrudan kendi belleğinde CPU'nun bu verileri açıkça kopyalamasına gerek kalmadan erişebilir. 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ş-dönüş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 derleme, özellikle modeli önceden derlemenin 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:

• Tedarikçinin 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 şunları elde ederiz:

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