C/C++ एपीआई का इस्तेमाल करके, जीपीयू ऐक्सेलरेशन का डेलिगेट

मशीन लर्निंग (एमएल) मॉडल को चलाने के लिए, ग्राफ़िक प्रोसेसिंग यूनिट (जीपीयू) का इस्तेमाल करने से, मशीन लर्निंग (एमएल) की सुविधा वाले ऐप्लिकेशन की परफ़ॉर्मेंस और उनका उपयोगकर्ता अनुभव काफ़ी बेहतर हो सकता है. Android डिवाइसों पर, डेलीगेट और इनमें से किसी एक एपीआई का इस्तेमाल करके, अपने मॉडल को जीपीयू से तेज़ी से चलाने की सुविधा चालू की जा सकती है:

अनुवादक एपीआई - गाइड
Native (C/C++) API - यह गाइड

इस गाइड में C API, C++ API के लिए जीपीयू डेलिगेट के बेहतर इस्तेमाल, और संख्या वाले मॉडल के इस्तेमाल के बारे में जानकारी दी गई है. TensorFlow Lite के लिए जीपीयू डेलिगेट का इस्तेमाल करने के बारे में ज़्यादा जानने के लिए, जीपीयू डेलिगेट पेज देखें. इसमें सबसे सही तरीके और बेहतर तकनीकें भी शामिल हैं.

यह विकल्प जीपीयू से तेज़ी लाने की सुविधा चालू करता है

C या C++ में Android के लिए, TensorFlow Lite जीपीयू डेलिगेट का इस्तेमाल करें. इसके लिए, TfLiteGpuDelegateV2Create() के साथ डेलिगेट बनाएं और TfLiteGpuDelegateV2Delete() की मदद से उसे मिटा दें, जैसा कि इस कोड में दिखाया गया है:

// Set up interpreter.
auto model = FlatBufferModel::BuildFromFile(model_path);
if (!model) return false;
ops::builtin::BuiltinOpResolver op_resolver;
std::unique_ptr<Interpreter> interpreter;
InterpreterBuilder(*model, op_resolver)(&interpreter);

// NEW: Prepare GPU delegate.
auto* delegate = TfLiteGpuDelegateV2Create(/*default options=*/nullptr);
if (interpreter->ModifyGraphWithDelegate(delegate) != kTfLiteOk) return false;

// Run inference.
WriteToInputTensor(interpreter->typed_input_tensor<float>(0));
if (interpreter->Invoke() != kTfLiteOk) return false;
ReadFromOutputTensor(interpreter->typed_output_tensor<float>(0));

// NEW: Clean up.
TfLiteGpuDelegateV2Delete(delegate);

पसंद के मुताबिक विकल्पों वाला डेलिगेट इंस्टेंस बनाने के लिए, TfLiteGpuDelegateOptionsV2 ऑब्जेक्ट कोड की समीक्षा करें. डिफ़ॉल्ट विकल्पों को TfLiteGpuDelegateOptionsV2Default() से शुरू किया जा सकता है. इसके बाद, ज़रूरत के हिसाब से उनमें बदलाव किया जा सकता है.

C या C++ में Android के लिए TensorFlow Lite जीपीयू डेलिगेट, Bazel बिल्ड सिस्टम का इस्तेमाल करता है. आप नीचे दिए गए निर्देश का इस्तेमाल करके किसी और को अपने ईमेल खाते का ऐक्सेस दे सकते हैं:

bazel build -c opt --config android_arm64 tensorflow/lite/delegates/gpu:delegate                           # for static library
bazel build -c opt --config android_arm64 tensorflow/lite/delegates/gpu:libtensorflowlite_gpu_delegate.so  # for dynamic library

Interpreter::ModifyGraphWithDelegate() या Interpreter::Invoke() को कॉल करते समय, कॉल करने वाले के पास मौजूदा थ्रेड में EGLContext होना चाहिए. साथ ही, Interpreter::Invoke() को उसी EGLContext से कॉल किया जाना चाहिए. अगर EGLContext मौजूद नहीं है, तो प्रतिनिधि अंदरूनी तौर पर एक प्रॉपर्टी बनाता है. इसके बाद, आपको यह पक्का करना होगा कि Interpreter::Invoke() को हमेशा उसी थ्रेड से कॉल किया जाए जिसमें Interpreter::ModifyGraphWithDelegate() को कॉल किया गया था.

Google Play Services में TensorFlow Lite के साथ:

अगर Google Play Services C API में TensorFlow Lite का इस्तेमाल किया जा रहा है, तो आपको Java/Kotlin API का इस्तेमाल करना होगा, ताकि यह पता किया जा सके कि TensorFlow Lite रनटाइम शुरू करने से पहले, आपके डिवाइस के लिए जीपीयू डेलिगेट उपलब्ध है या नहीं.

अपने ऐप्लिकेशन में जीपीयू डेलिगेट ग्रेडल डिपेंडेंसी जोड़ें:

implementation 'com.google.android.gms:play-services-tflite-gpu:16.2.0'

इसके बाद, जीपीयू की उपलब्धता देखें और जांच पूरी होने पर TfLiteNative शुरू करें:

Java

Task<Void> tfLiteHandleTask =
TfLiteGpu.isGpuDelegateAvailable(this)
   .onSuccessTask(gpuAvailable -> {
      TfLiteInitializationOptions options =
        TfLiteInitializationOptions.builder()
          .setEnableGpuDelegateSupport(gpuAvailable).build();
        return TfLiteNative.initialize(this, options);
      }
    );

Kotlin

val tfLiteHandleTask = TfLiteGpu.isGpuDelegateAvailable(this)
    .onSuccessTask { gpuAvailable ->
        val options = TfLiteInitializationOptions.Builder()
            .setEnableGpuDelegateSupport(gpuAvailable)
            .build()
        TfLiteNative.initialize(this, options)
    }

TFLITE_USE_OPAQUE_DELEGATE कंपाइलर फ़्लैग को शामिल करने के लिए, आपको अपना Cमेक कॉन्फ़िगरेशन भी अपडेट करना होगा:

add_compile_definitions(TFLITE_USE_OPAQUE_DELEGATE)

FlatBuffers लाइब्रेरी का इस्तेमाल, डेलिगेट प्लग इन को कॉन्फ़िगर करने के लिए किया जाता है. इसलिए, आपको इसे अपने नेटिव कोड की डिपेंडेंसी से जोड़ना होगा. CMake के आधिकारिक कॉन्फ़िगरेशन का इस्तेमाल इस तरह किया जा सकता है:

target_include_directories(tflite-jni PUBLIC
        third_party/headers # flatbuffers
     ...)

अपने ऐप्लिकेशन में हेडर को भी शामिल किया जा सकता है.

आखिर में, अपने सी कोड में जीपीयू के अनुमान का इस्तेमाल करने के लिए, TFLiteSettings का इस्तेमाल करके जीपीयू डेलिगेट बनाएं:

#include "flatbuffers/flatbuffers.h"
#include "tensorflow/lite/acceleration/configuration/configuration_generated.h"

flatbuffers::FlatBufferBuilder fbb;
tflite::TFLiteSettingsBuilder builder(fbb);
const tflite::TFLiteSettings* tflite_settings =
    flatbuffers::GetTemporaryPointer(fbb, builder.Finish());

const TfLiteOpaqueDelegatePlugin* pluginCApi = TfLiteGpuDelegatePluginCApi();
TfLiteOpaqueDelegate* gpu_delegate = pluginCApi->create(tflite_settings);

क्वांटाइज़्ड मॉडल

Android जीपीयू डेलिगेट की गई लाइब्रेरी, डिफ़ॉल्ट रूप से संख्या वाले मॉडल के साथ काम करती हैं. जीपीयू डेलिगेट के साथ संख्या वाले मॉडल इस्तेमाल करने के लिए, आपको किसी कोड में बदलाव करने की ज़रूरत नहीं है. नीचे दिए गए सेक्शन में, टेस्टिंग या प्रयोग के लिए, संख्या के आधार पर मिलने वाली सहायता को बंद करने का तरीका बताया गया है.

संख्या वाले मॉडल की सुविधा बंद करें

इस कोड में, संख्या वाले मॉडल के लिए सहायता बंद करने का तरीका बताया गया है.

C++

TfLiteGpuDelegateOptionsV2 options = TfLiteGpuDelegateOptionsV2Default();
options.experimental_flags = TFLITE_GPU_EXPERIMENTAL_FLAGS_NONE;

auto* delegate = TfLiteGpuDelegateV2Create(options);
if (interpreter->ModifyGraphWithDelegate(delegate) != kTfLiteOk) return false;

जीपीयू की रफ़्तार के साथ संख्या वाले मॉडल चलाने के बारे में ज़्यादा जानकारी के लिए, GPU प्रतिनिधि की खास जानकारी देखें.