सी/सी++ एपीआई के साथ जीपीयू त्वरण प्रतिनिधि

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

दुभाषिया एपीआई - गाइड
टास्क लाइब्रेरी एपीआई - गाइड
नेटिव (सी/सी++) एपीआई - यह गाइड

यह मार्गदर्शिका C API, C++ API और परिमाणित मॉडलों के उपयोग के लिए GPU प्रतिनिधि के उन्नत उपयोग को कवर करती है। सर्वोत्तम प्रथाओं और उन्नत तकनीकों सहित, TensorFlow Lite के लिए GPU प्रतिनिधि का उपयोग करने के बारे में अधिक जानकारी के लिए, GPU प्रतिनिधि पृष्ठ देखें।

GPU त्वरण सक्षम करें

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

// 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 GPU प्रतिनिधि बेज़ेल बिल्ड सिस्टम का उपयोग करता है। आप निम्न आदेश का उपयोग करके प्रतिनिधि बना सकते हैं:

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 सेवाओं में TensorFlow Lite के साथ:

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

अपने एप्लिकेशन में GPU प्रतिनिधि ग्रेडेल निर्भरताएँ जोड़ें:

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

फिर, GPU उपलब्धता की जाँच करें और जाँच सफल होने पर TfLiteNative को आरंभ करें:

जावा

Task 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 कंपाइलर फ़्लैग को शामिल करने के लिए आपको अपने CMake कॉन्फ़िगरेशन को भी अपडेट करना होगा:

add_compile_definitions(TFLITE_USE_OPAQUE_DELEGATE)

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

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

आप हेडर को अपने ऐप में बंडल भी कर सकते हैं।

अंत में अपने C कोड में GPU अनुमान का उपयोग करने के लिए, TFLiteSettings का उपयोग करके GPU प्रतिनिधि बनाएं:

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

परिमाणित मॉडल

एंड्रॉइड जीपीयू प्रतिनिधि लाइब्रेरीज़ डिफ़ॉल्ट रूप से परिमाणित मॉडल का समर्थन करती हैं। आपको GPU प्रतिनिधि के साथ परिमाणित मॉडल का उपयोग करने के लिए कोई कोड परिवर्तन करने की आवश्यकता नहीं है। निम्नलिखित अनुभाग बताता है कि परीक्षण या प्रयोगात्मक उद्देश्यों के लिए परिमाणित समर्थन को कैसे अक्षम किया जाए।

परिमाणित मॉडल समर्थन अक्षम करें

निम्नलिखित कोड दिखाता है कि परिमाणित मॉडलों के लिए समर्थन को कैसे अक्षम किया जाए ।

सी++

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

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

GPU त्वरण के साथ क्वांटाइज़्ड मॉडल चलाने के बारे में अधिक जानकारी के लिए, GPU प्रतिनिधि अवलोकन देखें।