تسريع وحدة المعالجة العصبية باستخدام LiteRT

توفّر LiteRT واجهة موحّدة لاستخدام وحدات المعالجة العصبية (NPUs) بدون الحاجة إلى التنقّل بين برامج التجميع أو أوقات التشغيل أو تبعيات المكتبات الخاصة بمورّد معيّن. يؤدي استخدام LiteRT لتسريع NPU إلى تحسين الأداء في الاستدلال في الوقت الفعلي والنماذج الكبيرة، كما يقلّل من عمليات نسخ الذاكرة من خلال استخدام مخزن مؤقت للأجهزة بدون نسخ.

البدء

• بالنسبة إلى نماذج تعلُّم الآلة الكلاسيكية، يمكنك الاطّلاع على التطبيقات التجريبية التالية.
  • تطبيق Kotlin لتصنيف الصور: يقدّم أمثلة على الترجمة المسبقة (AOT) والترجمة الفورية (JIT) على الجهاز على التوالي.
  • تطبيق C++ لتقسيم المحتوى غير المتزامن: يوضّح عملية التجميع المسبق (AOT) والتجميع أثناء التنفيذ (JIT) في التطبيق نفسه.
• بالنسبة إلى النماذج اللغوية الكبيرة (LLMs)، يمكنك الاطّلاع على الدليل الخاص بتنفيذ النماذج اللغوية الكبيرة على وحدة المعالجة العصبية باستخدام LiteRT-LM.

مورّدو وحدات المعالجة العصبية

تتيح LiteRT تسريع وحدة المعالجة العصبية (NPU) مع المورّدين التاليين:

Qualcomm AI Engine Direct

• إتاحة تنفيذ الترجمة الفورية والترجمة المسبقة على الجهاز من خلال واجهة برمجة التطبيقات CompiledModel
• اطّلِع على Qualcomm AI Engine Direct لمعرفة تفاصيل الإعداد.
• يمكنك الاطّلاع على تحقيق أفضل أداء على وحدة المعالجة العصبية من Qualcomm باستخدام LiteRT للحصول على آخر الأخبار.

‫MediaTek NeuroPilot

• إتاحة تنفيذ الترجمة الفورية والترجمة المسبقة على الجهاز من خلال واجهة برمجة التطبيقات CompiledModel
• راجِع MediaTek NeuroPilot لمعرفة تفاصيل الإعداد.
• يمكنك الاطّلاع على وحدة المعالجة العصبية (NPU) من MediaTek وLiteRT: تعزيز الجيل التالي من الذكاء الاصطناعي على الأجهزة للحصول على آخر الأخبار.

Google Tensor

تتوفّر حزمة تطوير البرامج (SDK) من Google Tensor في إصدار تجريبي. يمكنك الاشتراك هنا.

الترجمة المسبقة والترجمة على الجهاز

تتوافق وحدة المعالجة العصبية (NPU) في LiteRT مع كل من الترجمة المسبقة (AOT) والتجميع على الجهاز لتلبية متطلبات النشر المحدّدة:

• الترجمة البرمجية بلا إنترنت (AOT): هذا الخيار هو الأنسب للنماذج الكبيرة والمعقّدة التي تكون فيها منظومة SoC المستهدَفة معروفة. تؤدي عملية الترجمة المسبقة إلى تقليل تكاليف التهيئة بشكل كبير وتقليل استخدام الذاكرة عند تشغيل المستخدم لتطبيقك.
• التجميع على الإنترنت (على الجهاز): يُعرف أيضًا باسم التجميع أثناء التنفيذ. هذا الخيار مثالي لتوزيع النماذج الصغيرة التي لا تعتمد على منصة معيّنة. يتم تجميع النموذج على جهاز المستخدم أثناء عملية الإعداد، ما لا يتطلّب أي خطوة إعداد إضافية ولكن يؤدي إلى ارتفاع تكلفة التشغيل الأول.

يوضّح الدليل التالي كيفية نشر التطبيق باستخدام كلّ من الترجمة المسبقة (AOT) والترجمة على الجهاز في ثلاث خطوات.

الخطوة 1: تجميع AOT لشرائح NPU المستهدَفة

يمكنك استخدام برنامج LiteRT AOT (الترجمة المسبقة) لترجمة نموذج ‎ .tflite إلى أنظمة على شرائح متوافقة. يمكنك أيضًا استهداف العديد من مورّدي ونسخ نظام SoC في الوقت نفسه ضمن عملية تجميع واحدة. يمكنك الاطّلاع على مزيد من التفاصيل في دفتر ملاحظات تجميع LiteRT AOT. على الرغم من أنّ تجميع AOT اختياري، ننصح بشدة باستخدامه مع النماذج الأكبر حجمًا لتقليل وقت الإعداد على الجهاز. هذه الخطوة غير مطلوبة لإجراء عملية تجميع على الجهاز.

الخطوة 2: النشر باستخدام Google Play إذا كان الجهاز يعمل بنظام التشغيل Android

على Android، استخدِم Play للذكاء الاصطناعي على الجهاز (PODAI) لنشر النموذج ومكتبات وقت التشغيل الخاصة بوحدة المعالجة العصبية مع تطبيقك.

• بالنسبة إلى نماذج التجميع على الجهاز: أضِف ملف نموذج .tflite الأصلي مباشرةً إلى دليل assets/ في تطبيقك.
  • يمكنك الاطّلاع على مثال على التنفيذ في تطبيق Kotlin لتجميع بيانات التجزئة على الجهاز.
• بالنسبة إلى نماذج تجميع AOT: استخدِم LiteRT لتصدير النماذج المجمَّعة إلى حزمة الذكاء الاصطناعي من Google Play واحدة. بعد ذلك، يمكنك تحميل حزمة الذكاء الاصطناعي إلى Google Play لتسليم النماذج المجمَّعة الصحيحة تلقائيًا إلى أجهزة المستخدمين.
  • راجِع دفتر ملاحظات تجميع AOT في LiteRT للحصول على تعليمات حول تصدير النماذج المجمَّعة إلى حزمة الذكاء الاصطناعي من Play.
  • يمكنك الاطّلاع على مثال التنفيذ في تطبيق Kotlin الذي يتيح تجميع AOT للتصنيف.
• بالنسبة إلى مكتبات وقت التشغيل الخاصة بوحدة المعالجة العصبية، استخدِم Play Feature Delivery لتوزيع مكتبات وقت التشغيل الصحيحة على أجهزة المستخدمين.

راجِع الأقسام التالية للتعرّف على كيفية النشر باستخدام حزمة الذكاء الاصطناعي من Play و عرض الميزات في Play.

نشر نماذج AOT باستخدام حزمة Play AI

ترشدك الخطوات التالية إلى كيفية نشر النماذج التي تم تجميعها مسبقًا (AOT) باستخدام "حِزم الذكاء الاصطناعي على Play".

إضافة حزمة الذكاء الاصطناعي إلى المشروع

استورِد حِزم الذكاء الاصطناعي إلى مشروع Gradle من خلال نسخ حِزم الذكاء الاصطناعي إلى الدليل الجذر لمشروع Gradle. على سبيل المثال:

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

أضِف كل حزمة AI Pack إلى إعدادات الإصدار في 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")
}

ضبط "حزمة الذكاء الاصطناعي" لخدمة التوصيل عند الطلب

تتيح لك ميزة العرض عند الطلب طلب النموذج في وقت التشغيل، وهو أمر مفيد إذا كان النموذج مطلوبًا فقط لبعض مسارات المستخدمين. سيتم تنزيل النموذج إلى مساحة التخزين الداخلية للتطبيق. بعد ضبط ميزة "حزمة الذكاء الاصطناعي من Android" في ملف 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 باستخدام ميزة "عرض الميزات في Play"

تتيح عرض الميزات في Play خيارات عرض متعددة لتحسين حجم التنزيل الأولي، بما في ذلك العرض في وقت التثبيت والعرض عند الطلب والعرض الشرطي والعرض الفوري. في ما يلي دليل أساسي حول التسليم أثناء التثبيت.

إضافة مكتبات وقت تشغيل وحدة المعالجة العصبية إلى المشروع

نزِّل litert_npu_runtime_libraries.zip للتجميع المسبق (AOT) أو 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:

$ ./litert_npu_runtime_libraries/fetch_qualcomm_library.sh

إضافة مكتبات وقت تشغيل وحدة المعالجة العصبية إلى إعدادات Gradle

انسخ 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"))
  ...
}

الخطوة 3: الاستنتاج على وحدة المعالجة العصبية باستخدام LiteRT Runtime

تجرِّد LiteRT تعقيد التطوير على إصدارات معيّنة من نظام على شريحة، ما يتيح لك تشغيل النموذج على وحدة المعالجة العصبية باستخدام بضعة أسطر من الرموز البرمجية فقط. توفّر هذه المكتبة أيضًا آلية احتياطية مدمجة وفعّالة: يمكنك تحديد وحدة المعالجة المركزية (CPU) أو وحدة معالجة الرسومات (GPU) أو كليهما كخيارات، وستستخدمها LiteRT تلقائيًا في حال عدم توفّر وحدة المعالجة العصبية (NPU). من الملائم أنّ عملية الترجمة المسبقة (AOT) تتيح أيضًا استخدام رمز احتياطي. توفّر هذه الميزة تفويضًا جزئيًا على وحدة المعالجة العصبية (NPU) حيث يتم تشغيل الرسومات البيانية الفرعية غير المتوافقة بسلاسة على وحدة المعالجة المركزية (CPU) أو وحدة معالجة الرسومات (GPU) على النحو المحدّد.

التنفيذ بلغة Kotlin

يمكنك الاطّلاع على مثال على عملية التنفيذ في تطبيقات العرض التوضيحي التالية:

• تقسيم تجميع تطبيق Kotlin على الجهاز
• تجميع AOT لتقسيم تطبيق Kotlin

إضافة حِزم Android التابعة

يمكنك إضافة أحدث حزمة LiteRT Maven إلى تبعيات build.gradle:

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).
• مكتبات الخلفية الخاصة بوحدة المعالجة العصبية: على سبيل المثال، مكتبات Qualcomm AI RT (QAIRT) الخاصة بمضيف Android (مثل libQnnHtp.so وlibQnnHtpPrepare.so) ومكتبة 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));

نقل البيانات بدون نسخ مع تسريع وحدة المعالجة العصبية

يتيح استخدام ميزة "النسخ بدون وسيط" لوحدة المعالجة العصبية (NPU) الوصول إلى البيانات مباشرةً في الذاكرة الخاصة بها بدون أن تحتاج وحدة المعالجة المركزية (CPU) إلى نسخ هذه البيانات بشكل صريح. من خلال عدم نسخ البيانات إلى ذاكرة وحدة المعالجة المركزية ومنها، يمكن أن تقلّل عملية النسخ بدون وسيط بشكل كبير من وقت الاستجابة من البداية إلى النهاية.

يوضّح الرمز التالي مثالاً على تنفيذ Zero-Copy NPU باستخدام 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();

تسلسل استنتاجات متعددة من وحدة المعالجة العصبية

بالنسبة إلى خطوط الإنتاج المعقّدة، يمكنك ربط عدة استنتاجات من وحدة المعالجة العصبية. بما أنّ كل خطوة تستخدم مخزنًا مؤقتًا متوافقًا مع أداة التسريع، يظل خط أنابيبك في الغالب في الذاكرة التي تديرها وحدة المعالجة العصبية:

// 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 على الجهاز

تتيح LiteRT تجميع نماذج .tflite على الجهاز (المعروف باسم 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));

مثال على تقليل وقت الاستجابة وتوفير الذاكرة:

يمكن أن يختلف الوقت والذاكرة اللازمَين لتجميع وحدة المعالجة العصبية (NPU) استنادًا إلى عدة عوامل، مثل شريحة وحدة المعالجة العصبية الأساسية ومدى تعقيد نموذج الإدخال وما إلى ذلك.

يقارن الجدول التالي بين وقت تهيئة وقت التشغيل واستهلاك الذاكرة عند الحاجة إلى تجميع وحدة المعالجة العصبية (NPU) وعند إمكانية تخطّي التجميع بسبب التخزين المؤقت. على أحد الأجهزة النموذجية، نحصل على ما يلي:

على جهاز آخر، نحصل على ما يلي: