LiterRT এর সাথে NPU ত্বরণ

LiterRT আপনাকে বিক্রেতা-নির্দিষ্ট কম্পাইলার, রানটাইম বা লাইব্রেরি নির্ভরতা নেভিগেট করার অনুরোধ না করেই নিউরাল প্রসেসিং ইউনিট (NPU) ব্যবহার করার জন্য একটি ইউনিফাইড ইন্টারফেস প্রদান করে। NPU ত্বরণের জন্য LiterRT ব্যবহার রিয়েল-টাইম এবং বৃহৎ-মডেল ইনফারেন্সের জন্য কর্মক্ষমতা বৃদ্ধি করে এবং শূন্য-কপি হার্ডওয়্যার বাফার ব্যবহারের মাধ্যমে মেমরি কপিগুলিকে কমিয়ে দেয়।

শুরু করুন

• ক্লাসিক্যাল এমএল মডেলের জন্য , নিম্নলিখিত ডেমো অ্যাপ্লিকেশনগুলি দেখুন।
  • ইমেজ সেগমেন্টেশন কোটলিন অ্যাপ : যথাক্রমে AOT কম্পাইলেশন এবং অন-ডিভাইস (JIT) কম্পাইলেশনের উদাহরণ প্রদান করে।
  • অ্যাসিঙ্ক্রোনাস সেগমেন্টেশন সি++ অ্যাপ : একই অ্যাপে AOT কম্পাইলেশন এবং অন-ডিভাইস (JIT) কম্পাইলেশন উভয়ই প্রদর্শন করে।
• লার্জ ল্যাঙ্গুয়েজ মডেল (LLM) এর জন্য , LiterRT-LM ব্যবহার করে NPU তে LLM কার্যকর করার নির্দেশিকা দেখুন।

এনপিইউ বিক্রেতারা

LiterRT নিম্নলিখিত বিক্রেতাদের সাথে NPU ত্বরণ সমর্থন করে:

কোয়ালকম এআই ইঞ্জিন ডাইরেক্ট

• CompiledModel API এর মাধ্যমে AOT এবং ডিভাইসে সংকলন সম্পাদন সমর্থন করে।
• সেটআপের বিস্তারিত জানার জন্য Qualcomm AI Engine Direct দেখুন।
• সর্বশেষ আপডেটের জন্য LiterRT দিয়ে Qualcomm NPU-তে আনলকিং পিক পারফরম্যান্স দেখুন।

মিডিয়াটেক নিউরোপাইলট

• CompiledModel API এর মাধ্যমে AOT এবং ডিভাইসে সংকলন সম্পাদন সমর্থন করে।
• সেটআপের বিস্তারিত জানার জন্য মিডিয়াটেক নিউরোপাইলট দেখুন।
• সর্বশেষ আপডেটের জন্য MediaTek NPU এবং LiterRT: Powering the next generation of on-device AI দেখুন।

গুগল টেনসর

গুগল টেনসর এসডিকে পরীক্ষামূলক অ্যাক্সেসে রয়েছে। এখানে সাইন আপ করুন।

AOT এবং ডিভাইসে সংকলন

LiterRT NPU আপনার নির্দিষ্ট স্থাপনার প্রয়োজনীয়তা পূরণের জন্য AOT এবং অন-ডিভাইস সংকলন উভয়কেই সমর্থন করে:

• অফলাইন (AOT) সংকলন : এটি বৃহৎ, জটিল মডেলগুলির জন্য সবচেয়ে উপযুক্ত যেখানে লক্ষ্য SoC জানা থাকে। আগে থেকে সংকলন করলে প্রারম্ভিক খরচ উল্লেখযোগ্যভাবে হ্রাস পায় এবং ব্যবহারকারী যখন আপনার অ্যাপ চালু করে তখন মেমরির ব্যবহার হ্রাস পায়।
• অনলাইন (ডিভাইস-অন) সংকলন : এটি JIT সংকলন নামেও পরিচিত। এটি ছোট মডেলের প্ল্যাটফর্ম-অ্যাগনস্টিক মডেল বিতরণের জন্য আদর্শ। মডেলটি ব্যবহারকারীর ডিভাইসে প্রারম্ভিককরণের সময় সংকলিত হয়, কোনও অতিরিক্ত প্রস্তুতির পদক্ষেপের প্রয়োজন হয় না তবে প্রথম-রান খরচ বেশি হয়।

নিম্নলিখিত নির্দেশিকাটি তিনটি ধাপে AOT এবং অন-ডিভাইস সংকলনের জন্য কীভাবে স্থাপন করতে হয় তা দেখায়।

ধাপ ১: লক্ষ্য NPU SoC গুলির জন্য AOT সংকলন

আপনি LiterRT AOT (সময়ের আগেই) কম্পাইলার ব্যবহার করে আপনার .tflite মডেলটি সমর্থিত SoC গুলিতে কম্পাইল করতে পারেন। আপনি একই সংকলন প্রক্রিয়ার মধ্যে একসাথে একাধিক SoC বিক্রেতা এবং সংস্করণগুলিকে লক্ষ্য করতে পারেন। এই Litert AOT কম্পাইলেশন নোটবুকে আরও বিশদ দেখুন। যদিও ঐচ্ছিক, বৃহত্তর মডেলগুলির জন্য AOT কম্পাইলেশন অত্যন্ত সুপারিশ করা হয় যাতে অন-ডিভাইস প্রারম্ভিক সময় কমানো যায়। অন-ডিভাইস কম্পাইলেশনের জন্য এই পদক্ষেপটি প্রয়োজন হয় না।

ধাপ ২: অ্যান্ড্রয়েড থাকলে গুগল প্লে দিয়ে ডিপ্লয় করুন

অ্যান্ড্রয়েডে, আপনার অ্যাপের সাথে মডেল এবং NPU রানটাইম লাইব্রেরি স্থাপন করতে Google Play for On-device AI (PODAI) ব্যবহার করুন।

• অন-ডিভাইস সংকলনের মডেলগুলির জন্য : আপনার অ্যাপের assets/ ডিরেক্টরিতে সরাসরি আসল .tflite মডেল ফাইলটি যুক্ত করুন।
  • সেগমেন্টেশন অন-ডিভাইস সংকলন কোটলিন অ্যাপে বাস্তবায়নের উদাহরণ দেখুন।
• AOT সংকলনের মডেলগুলির জন্য : আপনার সংকলিত মডেলগুলিকে একটি একক Google Play AI প্যাকে রপ্তানি করতে LiterRT ব্যবহার করুন। তারপরে আপনি ব্যবহারকারীদের ডিভাইসে সঠিক সংকলিত মডেলগুলি স্বয়ংক্রিয়ভাবে সরবরাহ করার জন্য AI প্যাকটি Google Play তে আপলোড করুন।
  • কম্পাইল করা মডেলগুলিকে প্লে এআই প্যাকে রপ্তানি করার নির্দেশাবলীর জন্য LiterRT AOT কম্পাইলেশন নোটবুকটি দেখুন।
  • সেগমেন্টেশন AOT সংকলন Kotlin অ্যাপে বাস্তবায়নের উদাহরণ দেখুন।
• NPU রানটাইম লাইব্রেরির জন্য , ব্যবহারকারীদের ডিভাইসে সঠিক রানটাইম লাইব্রেরি বিতরণ করতে Play Feature Delivery ব্যবহার করুন।

প্লে এআই প্যাক এবং প্লে ফিচার ডেলিভারি কীভাবে ব্যবহার করবেন সে সম্পর্কে নিম্নলিখিত বিভাগগুলি দেখুন।

প্লে এআই প্যাক সহ AOT মডেল স্থাপন করুন

Play AI প্যাক ব্যবহার করে আপনার AOT কম্পাইল করা মডেলগুলি স্থাপনের ক্ষেত্রে নিম্নলিখিত ধাপগুলি আপনাকে গাইড করবে।

প্রকল্পে এআই প্যাক যোগ করুন

গ্র্যাডেল প্রজেক্টের রুট ডিরেক্টরিতে এআই প্যাক(গুলি) কপি করে গ্র্যাডেল প্রজেক্টে এআই প্যাকগুলি আমদানি করুন। উদাহরণস্বরূপ:

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

প্রতিটি AI প্যাক Gradle বিল্ড কনফিগারেশনে যোগ করুন:

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

গ্র্যাডেল কনফিগারেশনে এআই প্যাক যোগ করুন

জেনারেট করা AI প্যাকগুলি থেকে device_targeting_configuration.xml মূল অ্যাপ মডিউলের ডিরেক্টরিতে কপি করুন। তারপর settings.gradle.kts আপডেট করুন:

// my_app/setting.gradle.kts

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

build.gradle.kts আপডেট করুন :

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

অন-ডিমান্ড ডেলিভারির জন্য AI প্যাক কনফিগার করুন

অন-ডিমান্ড ডেলিভারি আপনাকে রানটাইমে মডেলটি অনুরোধ করতে দেয়, যা কেবলমাত্র নির্দিষ্ট ব্যবহারকারী-প্রবাহের জন্য মডেলটি প্রয়োজন হলে কার্যকর। আপনার মডেলটি আপনার অ্যাপের অভ্যন্তরীণ স্টোরেজ স্পেসে ডাউনলোড করা হবে। build.gradle.kts ফাইলে কনফিগার করা Android AI প্যাক বৈশিষ্ট্য সহ, ডিভাইসের ক্ষমতা পরীক্ষা করুন। PODAI থেকে ইনস্টল-টাইম ডেলিভারি এবং দ্রুত-অনুসরণ ডেলিভারির জন্য নির্দেশাবলীও দেখুন।

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

প্লে ফিচার ডেলিভারির মাধ্যমে NPU রানটাইম লাইব্রেরি স্থাপন করুন

প্লে ফিচার ডেলিভারি প্রাথমিক ডাউনলোডের আকার অপ্টিমাইজ করার জন্য একাধিক ডেলিভারি বিকল্প সমর্থন করে, যার মধ্যে রয়েছে ইনস্টল-টাইম ডেলিভারি, অন-ডিমান্ড ডেলিভারি, কন্ডিশনাল ডেলিভারি এবং তাৎক্ষণিক ডেলিভারি। এখানে, আমরা মৌলিক ইনস্টল-টাইম ডেলিভারি নির্দেশিকা দেখাই।

প্রকল্পে NPU রানটাইম লাইব্রেরি যোগ করুন

AOT কম্পাইলেশনের জন্য littert_npu_runtime_libraries.zip অথবা অন-ডিভাইস কম্পাইলেশনের জন্য littert_npu_runtime_libraries_jit.zip ডাউনলোড করুন এবং প্রকল্পের রুট ডিরেক্টরিতে এটি আনপ্যাক করুন:

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 সাপোর্ট লাইব্রেরি ডাউনলোড করতে স্ক্রিপ্টটি চালান। উদাহরণস্বরূপ, Qualcomm NPU গুলির জন্য নিম্নলিখিতটি চালান:

$ ./litert_npu_runtime_libraries/fetch_qualcomm_library.sh

গ্র্যাডেল কনফিগারেশনে NPU রানটাইম লাইব্রেরি যোগ করুন

জেনারেট করা AI প্যাকগুলি থেকে device_targeting_configuration.xml মূল অ্যাপ মডিউলের ডিরেক্টরিতে কপি করুন। তারপর settings.gradle.kts আপডেট করুন:

// 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 আপডেট করুন :

// 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"))
  ...
}

ধাপ ৩: LiterRT রানটাইম ব্যবহার করে NPU সম্পর্কে অনুমান

LiterRT নির্দিষ্ট SoC সংস্করণের বিপরীতে ডেভেলপ করার জটিলতা দূর করে, আপনাকে মাত্র কয়েকটি লাইন কোডের মাধ্যমে NPU-তে আপনার মডেলটি চালাতে দেয়। এটি একটি শক্তিশালী, অন্তর্নির্মিত ফলব্যাক প্রক্রিয়াও প্রদান করে: আপনি CPU, GPU, অথবা উভয়ই বিকল্প হিসাবে নির্দিষ্ট করতে পারেন এবং NPU অনুপলব্ধ থাকলে LiterT স্বয়ংক্রিয়ভাবে সেগুলি ব্যবহার করবে। সুবিধাজনকভাবে, AOT সংকলনও ফলব্যাক সমর্থন করে। এটি NPU-তে আংশিক ডেলিগেশান প্রদান করে যেখানে অসমর্থিত সাবগ্রাফগুলি নির্দিষ্টভাবে CPU বা GPU-তে চালিত হয়।

কোটলিনে চালান

নিম্নলিখিত ডেমো অ্যাপগুলিতে বাস্তবায়নের উদাহরণ দেখুন:

• ডিভাইসে বিভাজন সংকলন কোটলিন অ্যাপ
• সেগমেন্টেশন AOT সংকলন কোটলিন অ্যাপ

অ্যান্ড্রয়েড নির্ভরতা যোগ করুন

আপনি আপনার build.gradle নির্ভরতাগুলিতে সর্বশেষ LiterT Maven প্যাকেজ যোগ করতে পারেন:

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

রানটাইম ইন্টিগ্রেশন

// 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++ ক্রস-প্ল্যাটফর্মে চালান

অ্যাসিঙ্ক্রোনাস সেগমেন্টেশন C++ অ্যাপে বাস্তবায়নের উদাহরণ দেখুন।

ব্যাজেল বিল্ড নির্ভরতা

C++ ব্যবহারকারীদের LiteRT NPU ত্বরণের মাধ্যমে অ্যাপ্লিকেশনের নির্ভরতা তৈরি করতে হবে। cc_binary নিয়ম যা মূল অ্যাপ্লিকেশন লজিক (যেমন, main.cc ) প্যাকেজ করে তার জন্য নিম্নলিখিত রানটাইম উপাদানগুলির প্রয়োজন:

• LiterRT C API শেয়ার্ড লাইব্রেরি : data অ্যাট্রিবিউটে অবশ্যই LiterRT C API শেয়ার্ড লাইব্রেরি ( //litert/c:litert_runtime_c_api_shared_lib ) এবং NPU ( //litert/vendors/qualcomm/dispatch:dispatch_api_so ) এর জন্য বিক্রেতা-নির্দিষ্ট ডিসপ্যাচ শেয়ার্ড অবজেক্ট অন্তর্ভুক্ত থাকতে হবে।
• NPU-নির্দিষ্ট ব্যাকএন্ড লাইব্রেরি : উদাহরণস্বরূপ, অ্যান্ড্রয়েড হোস্টের জন্য Qualcomm AI RT (QAIRT) লাইব্রেরি (যেমন libQnnHtp.so , libQnnHtpPrepare.so ) এবং সংশ্লিষ্ট Hexagon DSP লাইব্রেরি ( libQnnHtpV79Skel.so )। এটি নিশ্চিত করে যে LiterRT রানটাইম NPU-তে গণনা অফলোড করতে পারে।
• অ্যাট্রিবিউট ডিপেন্ডেন্সি : deps অ্যাট্রিবিউট লিংকগুলি প্রয়োজনীয় কম্পাইল-টাইম ডিপেন্ডেন্সির সাথে সংযুক্ত করে, যেমন LiterT এর টেনসর বাফার ( //litert/cc:litert_tensor_buffer ) এবং NPU ডিসপ্যাচ লেয়ারের API ( //litert/vendors/qualcomm/dispatch:dispatch_api )। এটি আপনার অ্যাপ্লিকেশন কোডকে LiteRT এর মাধ্যমে NPU এর সাথে ইন্টারঅ্যাক্ট করতে সক্ষম করে।
• মডেল ফাইল এবং অন্যান্য সম্পদ : data অ্যাট্রিবিউটের মাধ্যমে অন্তর্ভুক্ত।

এই সেটআপটি আপনার কম্পাইল করা বাইনারিকে গতিশীলভাবে লোড করতে এবং ত্বরিত মেশিন লার্নিং ইনফারেন্সের জন্য NPU ব্যবহার করতে দেয়।

একটি NPU পরিবেশ সেট আপ করুন

কিছু NPU ব্যাকএন্ডের জন্য রানটাইম নির্ভরতা বা লাইব্রেরি প্রয়োজন হয়। কম্পাইল করা মডেল API ব্যবহার করার সময়, LiteRT একটি Environment অবজেক্টের মাধ্যমে এই প্রয়োজনীয়তাগুলি সংগঠিত করে। উপযুক্ত NPU লাইব্রেরি বা ড্রাইভার খুঁজে পেতে নিম্নলিখিত কোডটি ব্যবহার করুন:

// 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)));

রানটাইম ইন্টিগ্রেশন

নিম্নলিখিত কোড স্নিপেটটি C++ এ সম্পূর্ণ প্রক্রিয়াটির একটি মৌলিক বাস্তবায়ন দেখায়:

// 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 ত্বরণ সহ শূন্য-অনুলিপি

জিরো-কপি ব্যবহার করলে একটি NPU সরাসরি তার নিজস্ব মেমোরিতে ডেটা অ্যাক্সেস করতে পারে, CPU-কে স্পষ্টভাবে সেই ডেটা কপি করার প্রয়োজন হয় না। CPU মেমোরিতে এবং থেকে ডেটা কপি না করে, জিরো-কপি এন্ড-টু-এন্ড ল্যাটেন্সি উল্লেখযোগ্যভাবে হ্রাস করতে পারে।

নিচের কোডটি AHardwareBuffer সহ Zero-Copy NPU বাস্তবায়নের একটি উদাহরণ, যা সরাসরি NPU-তে ডেটা প্রেরণ করে। এই বাস্তবায়ন CPU মেমোরিতে ব্যয়বহুল রাউন্ড-ট্রিপ এড়ায়, ইনফারেন্স ওভারহেড উল্লেখযোগ্যভাবে হ্রাস করে।

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

একাধিক NPU অনুমানের শৃঙ্খল

জটিল পাইপলাইনের জন্য, আপনি একাধিক NPU ইনফারেন্স চেইন করতে পারেন। যেহেতু প্রতিটি ধাপে একটি অ্যাক্সিলারেটর-বান্ধব বাফার ব্যবহার করা হয়, তাই আপনার পাইপলাইন বেশিরভাগই NPU-পরিচালিত মেমোরিতে থাকে:

// 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 অন-ডিভাইস সংকলন ক্যাশিং

LiterRT .tflite মডেলের NPU অন-ডিভাইস (যা JIT নামে পরিচিত) সংকলন সমর্থন করে। JIT সংকলন বিশেষ করে সেই পরিস্থিতিতে কার্যকর হতে পারে যেখানে আগে থেকে মডেলটি সংকলন করা সম্ভব নয়।

তবে JIT সংকলনটি ব্যবহারকারী-প্রদত্ত মডেলটিকে NPU বাইটকোডে অন-ডিমান্ড নির্দেশাবলীতে অনুবাদ করার জন্য কিছু ল্যাটেন্সি এবং মেমোরি ওভারহেডের সাথে আসতে পারে। কর্মক্ষমতা প্রভাব কমাতে NPU সংকলন শিল্পকর্মগুলি ক্যাশে করা যেতে পারে।

যখন ক্যাশিং সক্ষম করা থাকে তখন LiterRT শুধুমাত্র প্রয়োজনের সময় মডেলটির পুনঃসংকলন ট্রিগার করবে, যেমন:

• বিক্রেতার NPU কম্পাইলার প্লাগইন সংস্করণ পরিবর্তিত হয়েছে;
• অ্যান্ড্রয়েড বিল্ড ফিঙ্গারপ্রিন্ট পরিবর্তন করা হয়েছে;
• ব্যবহারকারী-প্রদত্ত মডেলটি পরিবর্তিত হয়েছে;
• সংকলনের বিকল্পগুলি পরিবর্তিত হয়েছে।

NPU কম্পাইলেশন ক্যাশিং সক্ষম করার জন্য, পরিবেশ বিকল্পগুলিতে CompilerCacheDir পরিবেশ ট্যাগটি নির্দিষ্ট করুন। মানটি অ্যাপ্লিকেশনের একটি বিদ্যমান লেখার যোগ্য পথে সেট করতে হবে।

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

ল্যাটেন্সি এবং মেমরি সাশ্রয়ের উদাহরণ:

NPU সংকলনের জন্য প্রয়োজনীয় সময় এবং মেমোরি বিভিন্ন কারণের উপর নির্ভর করে পরিবর্তিত হতে পারে, যেমন অন্তর্নিহিত NPU চিপ, ইনপুট মডেলের জটিলতা ইত্যাদি।

নিচের টেবিলে NPU কম্পাইলেশনের প্রয়োজন হলে রানটাইম ইনিশিয়ালাইজেশনের সময় এবং মেমোরি খরচ তুলনা করা হয়েছে, যেখানে ক্যাশিংয়ের কারণে কম্পাইলেশন এড়িয়ে যাওয়ার সম্ভাবনা তুলনা করা হয়েছে। একটি নমুনা ডিভাইসে আমরা নিম্নলিখিত তথ্য পাই:

অন্য একটি ডিভাইসে আমরা নিম্নলিখিতগুলি পাই: