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

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

البدء

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

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

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

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

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

في ما يلي كيفية تفعيل النموذج باستخدام خيارَي الترجمة المسبقة (AOT) أو الترجمة على الجهاز فقط:

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

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

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

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

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

راجِع الأقسام التالية للتعرّف على كيفية النشر باستخدام حزمة الذكاء الاصطناعي من 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 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,
)

نشر مكتبات وقت تشغيل NPU باستخدام ميزة "عرض الميزات في Play"

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

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

نزِّل litert_npu_runtime_libraries.zip من أحدث إصدار للتجميع المسبق (AOT) أو litert_npu_runtime_libraries_jit.zip من أحدث إصدار للتجميع على الجهاز فقط، وفكِّ ضغطه في الدليل الجذر للمشروع:

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) من 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: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:

// 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: الاستدلال على وحدة المعالجة العصبية باستخدام وقت تشغيل LiteRT

تجرِّد LiteRT عملية التطوير من التعقيد المرتبط بإصدارات معيّنة من SoC، ما يتيح لك تشغيل النموذج على وحدة المعالجة العصبية (NPU) باستخدام بضعة أسطر من الرموز البرمجية. توفّر هذه المكتبة أيضًا آلية احتياطية مدمجة وفعّالة: يمكنك تحديد وحدة المعالجة المركزية أو وحدة معالجة الرسومات أو كليهما كخيارات، وستستخدم LiteRT هذه الخيارات تلقائيًا إذا لم تتوفّر وحدة المعالجة العصبية. من الميزات المفيدة أنّ عملية الترجمة المسبقة (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));

النسخ بدون الحاجة إلى ذاكرة خارجية مع تسريع وحدة المعالجة العصبية

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

في ما يلي مثال على تنفيذ 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) باستخدام وحدة المعالجة العصبية. يمكن أن تكون ميزة التجميع أثناء التنفيذ مفيدة بشكل خاص في الحالات التي لا يمكن فيها تجميع النموذج مسبقًا.

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

عند تفعيل التخزين المؤقت، لن يؤدي 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) استنادًا إلى عدة عوامل، مثل شريحة وحدة المعالجة العصبية الأساسية ومدى تعقيد نموذج الإدخال وما إلى ذلك.

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

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