LiteRT के साथ NPU ऐक्सेलरेट करना

LiteRT, न्यूरल प्रोसेसिंग यूनिट (एनपीयू) का इस्तेमाल करने के लिए एक यूनिफ़ाइड इंटरफ़ेस उपलब्ध कराता है. इसके लिए, आपको वेंडर के हिसाब से कंपाइलर, रनटाइम या लाइब्रेरी डिपेंडेंसी पर जाने का अनुरोध नहीं करना पड़ता. एनपीयू की मदद से LiteRT का इस्तेमाल करने पर, रीयल-टाइम और बड़े मॉडल के इन्फ़रेंस की परफ़ॉर्मेंस बेहतर होती है. साथ ही, ज़ीरो-कॉपी हार्डवेयर बफ़र का इस्तेमाल करके, मेमोरी कॉपी को कम किया जाता है.

शुरू करें

• क्लासिकल एमएल मॉडल के लिए, यहां दिए गए डेमो ऐप्लिकेशन देखें.
  • इमेज सेगमेंटेशन Kotlin ऐप्लिकेशन: इसमें AOT कंपाइलेशन और डिवाइस पर (JIT) कंपाइलेशन के उदाहरण दिए गए हैं.
  • एसिंक्रोनस सेगमेंटेशन C++ ऐप्लिकेशन: यह एक ही ऐप्लिकेशन में, एओटी कंपाइलेशन और डिवाइस पर (JIT) कंपाइलेशन, दोनों को दिखाता है.
• लार्ज लैंग्वेज मॉडल (एलएलएम) के लिए, LiteRT-LM का इस्तेमाल करके एनपीयू पर एलएलएम को लागू करने से जुड़ी गाइड देखें.

एनपीयू वेंडर

LiteRT, इन वेंडर के एनपीयू ऐक्सेलरेटर के साथ काम करता है:

Qualcomm AI Engine Direct

• CompiledModel एपीआई के ज़रिए, एओटी और डिवाइस पर कंपाइल करने की सुविधा का इस्तेमाल किया जा सकता है.
• सेटअप के बारे में जानकारी के लिए, Qualcomm AI Engine Direct देखें.
• नए अपडेट के लिए, LiteRT की मदद से Qualcomm NPU की परफ़ॉर्मेंस को बेहतर बनाना लेख पढ़ें.

MediaTek NeuroPilot

• CompiledModel एपीआई के ज़रिए, एओटी और डिवाइस पर कंपाइल करने की सुविधा का इस्तेमाल किया जा सकता है.
• सेटअप की जानकारी के लिए, MediaTek NeuroPilot देखें.
• नए अपडेट के लिए, MediaTek NPU और LiteRT: डिवाइस पर मौजूद एआई की अगली जनरेशन को बेहतर बनाना लेख पढ़ें.

Google Tensor

Google Tensor SDK, एक्सपेरिमेंट के तौर पर उपलब्ध है. यहां साइन अप करें.

AOT और ऑन-डिवाइस कंपाइलेशन

LiteRT NPU, एओटी और डिवाइस पर कंपाइल करने की सुविधा देता है. इससे आपको अपनी खास डिपार्टमेंट की ज़रूरतों को पूरा करने में मदद मिलती है:

• ऑफ़लाइन (एओटी) कंपाइलेशन: यह बड़े और जटिल मॉडल के लिए सबसे सही है. इसमें टारगेट एसओसी के बारे में पता होता है. पहले से कंपाइल करने पर, ऐप्लिकेशन शुरू करने की लागत काफ़ी कम हो जाती है. साथ ही, जब उपयोगकर्ता आपका ऐप्लिकेशन लॉन्च करता है, तब मेमोरी का इस्तेमाल भी कम हो जाता है.
• ऑनलाइन (डिवाइस पर) कंपाइलेशन: इसे JIT कंपाइलेशन भी कहा जाता है. यह छोटे मॉडल के लिए, प्लैटफ़ॉर्म से अलग मॉडल डिस्ट्रिब्यूशन के लिए सबसे सही है. मॉडल को शुरू करने के दौरान, उपयोगकर्ता के डिवाइस पर कंपाइल किया जाता है. इसके लिए, तैयारी के किसी अतिरिक्त चरण की ज़रूरत नहीं होती. हालांकि, पहली बार चलाने पर ज़्यादा लागत लगती है.

यहां दी गई गाइड में, तीन चरणों में AOT और डिवाइस पर कंपाइल करने, दोनों के लिए डिप्लॉय करने का तरीका बताया गया है.

पहला चरण: टारगेट किए गए एनपीयू एसओसी के लिए एओटी कंपाइलेशन

LiteRT AOT (ऐड ऑफ़ टाइम) कंपाइलर का इस्तेमाल करके, अपने .tflite मॉडल को उन SoCs के लिए कंपाइल किया जा सकता है जिन पर यह काम करता है. एक ही कंपाइलेशन प्रोसेस में, एक साथ कई SoC वेंडर और वर्शन को भी टारगेट किया जा सकता है. ज़्यादा जानकारी के लिए, LiteRT AOT कंपाइलेशन नोटबुक देखें. हालांकि, एओटी कंपाइलेशन का इस्तेमाल करना ज़रूरी नहीं है, लेकिन बड़े मॉडल के लिए इसका इस्तेमाल करने का सुझाव दिया जाता है. इससे डिवाइस पर मॉडल को चालू होने में लगने वाला समय कम हो जाता है. डिवाइस पर कंपाइल करने के लिए, यह चरण ज़रूरी नहीं है.

दूसरा चरण: अगर Android पर है, तो Google Play की मदद से डिप्लॉय करें

Android पर, Google Play for On-device AI (PODAI) का इस्तेमाल करके, अपने ऐप्लिकेशन के साथ मॉडल और NPU रनटाइम लाइब्रेरी डिप्लॉय करें.

• डिवाइस पर कंपाइल किए जाने वाले मॉडल के लिए: ओरिजनल .tflite मॉडल फ़ाइल को सीधे अपने ऐप्लिकेशन की assets/ डायरेक्ट्री में जोड़ें.
  • Segmentation on-device compilation Kotlin App में, लागू करने का उदाहरण देखें.
• AOT कंपाइलेशन वाले मॉडल के लिए: कंपाइल किए गए मॉडल को एक ही Google Play AI Pack में एक्सपोर्ट करने के लिए, LiteRT का इस्तेमाल करें. इसके बाद, एआई पैक को Google Play पर अपलोड करें, ताकि उपयोगकर्ताओं के डिवाइसों पर सही कंपाइल किए गए मॉडल अपने-आप डिलीवर हो सकें.
  • कंपाइल किए गए मॉडल को Play AI Pack में एक्सपोर्ट करने के निर्देशों के लिए, LiteRT AOT कंपाइलेशन नोटबुक देखें.
  • Segmentation AOT compilation Kotlin App में, लागू करने का उदाहरण देखें.
• एनपीयू रनटाइम लाइब्रेरी के लिए, Play फ़ीचर डिलीवरी का इस्तेमाल करके, उपयोगकर्ताओं के डिवाइसों पर सही रनटाइम लाइब्रेरी डिस्ट्रिब्यूट करें.

Play AI Pack और Play Feature Delivery की मदद से डिप्लॉय करने के तरीके के बारे में जानने के लिए, यहां दिए गए सेक्शन देखें.

Play AI Pack की मदद से, एओटी मॉडल डिप्लॉय करना

Play AI Packs का इस्तेमाल करके, AOT कंपाइल किए गए मॉडल को डिप्लॉय करने के लिए, यहां दिया गया तरीका अपनाएं.

प्रोजेक्ट में एआई पैक जोड़ना

Gradle प्रोजेक्ट में एआई पैक इंपोर्ट करने के लिए, एआई पैक को Gradle प्रोजेक्ट की रूट डायरेक्ट्री में कॉपी करें. उदाहरण के लिए:

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

हर एआई पैक को 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

Gradle कॉन्फ़िगरेशन में एआई पैक जोड़ना

जनरेट किए गए एआई पैक से 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 फ़ाइल में कॉन्फ़िगर की गई Android AI Pack सुविधा की मदद से, डिवाइस की क्षमताओं की जांच करें. 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,
)

Play Feature Delivery की मदद से, NPU की रनटाइम लाइब्रेरी डिप्लॉय करना

Play Feature Delivery, ऐप्लिकेशन के शुरुआती डाउनलोड साइज़ को ऑप्टिमाइज़ करने के लिए, डिलीवरी के कई विकल्प उपलब्ध कराता है. इनमें इंस्टॉल के समय डिलीवरी, मांग पर डिलीवरी, शर्त के हिसाब से डिलीवरी, और तुरंत डिलीवरी शामिल हैं. यहां, इंस्टॉल करने के समय डिलीवरी की बुनियादी गाइड दिखाई गई है.

प्रोजेक्ट में एनपीयू रनटाइम लाइब्रेरी जोड़ना

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

एनपीयू सपोर्ट लाइब्रेरी डाउनलोड करने के लिए, स्क्रिप्ट चलाएं. उदाहरण के लिए, Qualcomm NPUs के लिए यह कमांड चलाएं:

$ ./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 Runtime का इस्तेमाल करके, एनपीयू पर अनुमान लगाना

LiteRT, SoC के कुछ वर्शन के हिसाब से डेवलपमेंट की मुश्किल प्रोसेस को आसान बनाता है. इससे, कोड की कुछ ही लाइनों का इस्तेमाल करके, अपने मॉडल को एनपीयू पर चलाया जा सकता है. इसमें एक मज़बूत, पहले से मौजूद फ़ॉलबैक मैकेनिज़्म भी होता है: सीपीयू, जीपीयू या दोनों को विकल्प के तौर पर चुना जा सकता है. अगर एनपीयू उपलब्ध नहीं है, तो LiteRT अपने-आप इनका इस्तेमाल करेगा. AOT कंपाइलेशन में फ़ॉलबैक की सुविधा भी काम करती है. यह एनपीयू पर आंशिक डेलिगेशन की सुविधा देता है. इससे, काम न करने वाले सबग्राफ़, सीपीयू या जीपीयू पर आसानी से चलते हैं.

Kotlin में चलाएं

नीचे दिए गए डेमो ऐप्लिकेशन में, इसे लागू करने का उदाहरण देखें:

• डिवाइस पर सेगमेंटेशन, Kotlin ऐप्लिकेशन
• Segmentation AOT compilation Kotlin App

Android डिपेंडेंसी जोड़ना

अपने 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++ ऐप्लिकेशन में, लागू करने का उदाहरण देखें.

Bazel Build की डिपेंडेंसी

C++ का इस्तेमाल करने वाले लोगों को, ऐप्लिकेशन की डिपेंडेंसी को LiteRT NPU ऐक्सलरेशन के साथ बनाना होगा. cc_binary नियम, ऐप्लिकेशन की मुख्य लॉजिक को पैकेज करता है. उदाहरण के लिए, main.cc) के लिए, रनटाइम के इन कॉम्पोनेंट की ज़रूरत होती है:

• LiteRT C API की शेयर की गई लाइब्रेरी: data एट्रिब्यूट में, LiteRT C API की शेयर की गई लाइब्रेरी (//litert/c:litert_runtime_c_api_shared_lib) और एनपीयू के लिए वेंडर के हिसाब से डिस्पैच किया गया शेयर किया गया ऑब्जेक्ट (//litert/vendors/qualcomm/dispatch:dispatch_api_so) शामिल होना चाहिए.
• एनपीयू के लिए खास तौर पर बनाई गई बैकएंड लाइब्रेरी: उदाहरण के लिए, Android होस्ट (जैसे कि libQnnHtp.so, libQnnHtpPrepare.so) के लिए Qualcomm AI RT (QAIRT) लाइब्रेरी और इससे जुड़ी Hexagon DSP लाइब्रेरी (libQnnHtpV79Skel.so). इससे यह पक्का होता है कि LiteRT रनटाइम, कंप्यूटेशन को एनपीयू पर ऑफ़लोड कर सकता है.
• एट्रिब्यूट डिपेंडेंसी: deps एट्रिब्यूट, कंपाइल-टाइम की ज़रूरी डिपेंडेंसी से लिंक होता है. जैसे, LiteRT का टेंसर बफ़र (//litert/cc:litert_tensor_buffer) और एनपीयू डिस्पैच लेयर (//litert/vendors/qualcomm/dispatch:dispatch_api) के लिए एपीआई. इससे आपका ऐप्लिकेशन कोड, LiteRT के ज़रिए एनपीयू के साथ इंटरैक्ट कर पाता है.
• मॉडल फ़ाइलें और अन्य ऐसेट: इन्हें data एट्रिब्यूट के ज़रिए शामिल किया जाता है.

इस सेटअप की मदद से, कंपाइल की गई बाइनरी को डाइनैमिक तौर पर लोड किया जा सकता है. साथ ही, मशीन लर्निंग के अनुमान को बेहतर बनाने के लिए, NPU का इस्तेमाल किया जा सकता है.

एनपीयू एनवायरमेंट सेट अप करना

कुछ एनपीयू बैकएंड के लिए, रनटाइम डिपेंडेंसी या लाइब्रेरी की ज़रूरत होती है. कंपाइल किए गए मॉडल एपीआई का इस्तेमाल करते समय, LiteRT इन ज़रूरी शर्तों को Environment ऑब्जेक्ट के ज़रिए व्यवस्थित करता है. सही एनपीयू लाइब्रेरी या ड्राइवर ढूंढने के लिए, इस कोड का इस्तेमाल करें:

// 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-मैनेज की गई मेमोरी में रहती है:

// 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 मॉडल के JIT कंपाइलेशन के तौर पर जाना जाता है. JIT कंपाइलेशन, खास तौर पर उन स्थितियों में मददगार हो सकता है जहां मॉडल को पहले से कंपाइल करना मुमकिन नहीं होता.

हालांकि, JIT कंपाइलेशन में कुछ समय लग सकता है. साथ ही, उपयोगकर्ता के दिए गए मॉडल को ज़रूरत के हिसाब से एनपीयू बाइटकोड निर्देशों में बदलने के लिए, मेमोरी ओवरहेड की ज़रूरत पड़ सकती है. एनपीयू कंपाइलेशन आर्टफ़ैक्ट को कैश मेमोरी में सेव किया जा सकता है, ताकि परफ़ॉर्मेंस पर कम से कम असर पड़े.

कैशिंग की सुविधा चालू होने पर, LiteRT सिर्फ़ तब मॉडल को फिर से कंपाइल करेगा, जब इसकी ज़रूरत होगी. जैसे:

• वेंडर के NPU कंपाइलर प्लगिन का वर्शन बदल गया हो;
• Android बिल्ड फ़िंगरप्रिंट बदल गया है;
• उपयोगकर्ता ने मॉडल बदल दिया है;
• कंपाइलेशन के विकल्प बदल गए हैं.

एनपीयू कंपाइलेशन कैश मेमोरी को चालू करने के लिए, एनवायरमेंट के विकल्पों में 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));

विलंबता और मेमोरी सेविंग का उदाहरण:

एनपीयू कंपाइलेशन के लिए ज़रूरी समय और मेमोरी, कई बातों पर निर्भर करती है. जैसे, एनपीयू चिप, इनपुट मॉडल की जटिलता वगैरह.

नीचे दी गई टेबल में, एनपीयू कंपाइल करने की ज़रूरत होने पर, रनटाइम के दौरान शुरू होने में लगने वाले समय और मेमोरी की खपत की तुलना की गई है. साथ ही, इसमें यह भी बताया गया है कि कैश मेमोरी की वजह से कंपाइल करने की प्रोसेस को कब स्किप किया जा सकता है. हमें एक सैंपल डिवाइस पर यह जानकारी मिली:

हम किसी दूसरे डिवाइस पर यह जानकारी इकट्ठा करते हैं: