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

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

শুরু করুন

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

LiteRT নিম্নলিখিত ভেন্ডরদের সাথে NPU অ্যাক্সিলারেশন সমর্থন করে:

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

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

গুগল টেনসর

গুগল টেনসর এসডিকে পরীক্ষামূলকভাবে ব্যবহারের জন্য উপলব্ধ। এখানে নিবন্ধন করুন।

ইন্টেল ওপেনভিনো

  • CompiledModel API-এর মাধ্যমে AOT এবং অন-ডিভাইস কম্পাইলেশন এক্সিকিউশন সমর্থন করুন।
  • সেটআপের বিস্তারিত তথ্যের জন্য ইন্টেল ওপেনভিনো দেখুন।

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

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

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

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

ধাপ ১: টার্গেট এনপিইউ এসওসিগুলোর জন্য এওটি কম্পাইলেশন

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

ধাপ ২: অ্যান্ড্রয়েডে হলে গুগল প্লে-এর মাধ্যমে স্থাপন করুন।

অ্যান্ড্রয়েডে, আপনার অ্যাপের সাথে মডেল এবং এনপিইউ রানটাইম লাইব্রেরিগুলো স্থাপন করতে গুগল প্লে ফর অন-ডিভাইস এআই (PODAI) ব্যবহার করুন।

  • ডিভাইসে কম্পাইল করার মডেলগুলির জন্য : মূল .tflite মডেল ফাইলটি সরাসরি আপনার অ্যাপের assets/ ডিরেক্টরিতে যুক্ত করুন।
  • AOT কম্পাইলেশনের মডেলগুলির জন্য : আপনার কম্পাইল করা মডেলগুলিকে একটি একক Google Play AI Pack- এ এক্সপোর্ট করতে LiteRT ব্যবহার করুন। এরপর, ব্যবহারকারীদের ডিভাইসে সঠিক কম্পাইল করা মডেলগুলি স্বয়ংক্রিয়ভাবে পৌঁছে দেওয়ার জন্য আপনি AI প্যাকটি Google Play-তে আপলোড করুন।
  • NPU রানটাইম লাইব্রেরিগুলোর ক্ষেত্রে , ব্যবহারকারীদের ডিভাইসে সঠিক রানটাইম লাইব্রেরিগুলো বিতরণ করতে প্লে ফিচার ডেলিভারি (Play Feature Delivery) ব্যবহার করুন।

Play AI Pack এবং Play Feature Delivery ব্যবহার করে কীভাবে ডেপ্লয় করতে হয়, তা জানতে নিচের সেকশনগুলো দেখুন।

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

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

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

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

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

প্রতিটি এআই প্যাক গ্রেডল বিল্ড কনফিগে যোগ করুন:

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

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

জেনারেট করা এআই প্যাকগুলো থেকে 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")
}

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

অন-ডিমান্ড ডেলিভারি আপনাকে রানটাইমে মডেলের জন্য অনুরোধ করার সুযোগ দেয়, যা তখন কাজে আসে যখন মডেলটি শুধুমাত্র নির্দিষ্ট ইউজার-ফ্লোর জন্য প্রয়োজন হয়। আপনার মডেলটি আপনার অ্যাপের অভ্যন্তরীণ স্টোরেজ স্পেসে ডাউনলোড করা হবে। build.gradle.kts ফাইলে অ্যান্ড্রয়েড এআই প্যাক ফিচারটি কনফিগার করা থাকলে, ডিভাইসের ক্যাপাবিলিটিগুলো পরীক্ষা করুন। এছাড়াও 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 রানটাইম লাইব্রেরি যোগ করুন

AOT কম্পাইলেশনের জন্য litert_npu_runtime_libraries.zip অথবা অন-ডিভাইস কম্পাইলেশনের জন্য litert_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

এনপিইউ সাপোর্ট লাইব্রেরিগুলো ডাউনলোড করতে স্ক্রিপ্টটি চালান। উদাহরণস্বরূপ, কোয়ালকম এনপিইউ-এর জন্য নিম্নলিখিতটি চালান:

$ ./litert_npu_runtime_libraries/fetch_qualcomm_library.sh

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

জেনারেট করা এআই প্যাকগুলো থেকে 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"))
  ...
}

ধাপ ৩: LiteRT রানটাইম ব্যবহার করে NPU-তে ইনফারেন্স

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

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

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

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

আপনি আপনার build.gradle dependencies-এ সর্বশেষ 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 ) প্যাকেজ করে, তার জন্য নিম্নলিখিত রানটাইম কম্পোনেন্টগুলোর প্রয়োজন হয়:

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

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

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

কিছু 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));

এনপিইউ ত্বরণ সহ জিরো-কপি

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

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

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

এনপিইউ অন-ডিভাইস কম্পাইলেশন ক্যাশিং

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

তবে, ব্যবহারকারীর দেওয়া মডেলকে চাহিদা অনুযায়ী এনপিইউ বাইটকোড নির্দেশাবলীতে রূপান্তর করার জন্য জেআইটি কম্পাইলেশনে কিছু ল্যাটেন্সি এবং মেমরি ওভারহেড থাকতে পারে। পারফরম্যান্সের উপর প্রভাব কমাতে এনপিইউ কম্পাইলেশন আর্টিফ্যাক্টগুলো ক্যাশ করা যেতে পারে।

যখন ক্যাশিং সক্রিয় থাকে, LiteRT শুধুমাত্র প্রয়োজনের সময়ই মডেলের পুনঃ-সংকলন শুরু করবে, যেমন:

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

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 কম্পাইলেশনের সাথে মেমরি ফুটপ্রিন্ট শুরু করুন ক্যাশড কম্পাইলেশন সহ ইনিশিয়ালাইজ মেমরি
torchvision_resnet152.tflite ৭৪৬৫.২২ মিলিসেকেন্ড ১৯৮.৩৪ মিলিসেকেন্ড ১৫২৫.২৪ এমবি ৩৫৫.০৭ এমবি
torchvision_lraspp_mobilenet_v3_large.tflite ১৫৯২.৫৪ মিলিসেকেন্ড ১৬৬.৪৭ মিলিসেকেন্ড ২৫৪.৯০ এমবি ৩৩.৭৮ এমবি

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

টিএফলাইট মডেল NPU কম্পাইলেশন সহ মডেল ইনিট ক্যাশড কম্পাইলেশন সহ মডেল ইনিট NPU কম্পাইলেশনের সাথে মেমরি ফুটপ্রিন্ট শুরু করুন ক্যাশড কম্পাইলেশন সহ ইনিশিয়ালাইজ মেমরি
torchvision_resnet152.tflite ২৭৬৬.৪৪ মিলিসেকেন্ড ৩৭৯.৮৬ মিলিসেকেন্ড ৬৫৩.৫৪ এমবি ৫০১.২১ এমবি
torchvision_lraspp_mobilenet_v3_large.tflite ৭৮৪.১৪ মিলিসেকেন্ড ২৩১.৭৬ মিলিসেকেন্ড ১১৩.১৪ এমবি ৬৭.৪৯ এমবি