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

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

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

इस गाइड में C API, C++ API, और अन्य एपीआई के लिए जीपीयू डेलिगेट के बेहतर इस्तेमाल के बारे में बताया गया है क्वांटाइज़्ड मॉडल का इस्तेमाल करते हैं. जीपीयू डेलिगेट का इस्तेमाल करने के बारे में ज़्यादा जानकारी LiteRT के साथ-साथ, सबसे सही तरीकों और बेहतर तकनीकों के बारे में भी जानने के लिए, GPU प्रतिनिधि पेज पर जाकर सबमिट करते हैं.

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

C या C++ में Android के लिए LiteRT जीपीयू डेलिगेट का इस्तेमाल करें: 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 के लिए LiteRT जीपीयू प्रतिनिधि Bazu बिल्ड सिस्टम. प्रतिनिधि बनाने के लिए, निम्न आदेश:

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 में LiteRT के साथ:

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

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

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

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

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

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

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

add_compile_definitions(TFLITE_USE_OPAQUE_DELEGATE)

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

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

आप हेडर को अपने ऐप्लिकेशन के साथ बंडल भी कर सकते हैं.

आखिर में, अपने C कोड में जीपीयू का अनुमान इस्तेमाल करने के लिए, जीपीयू डेलिगेट बनाएं 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 जीपीयू की डेलिगेट लाइब्रेरी, डिफ़ॉल्ट रूप से क्वांट किए गए मॉडल के साथ काम करती हैं. आपको ये काम नहीं करने चाहिए जीपीयू डेलिगेट के साथ, क्वांटिफ़ाइड मॉडल का इस्तेमाल करने के लिए, कोड में किसी भी तरह का बदलाव करना होगा. कॉन्टेंट बनाने नीचे दिए गए सेक्शन में, टेस्ट के लिए क्वांटाइज़्ड सपोर्ट को बंद करने का तरीका बताया गया है या एक्सपेरिमेंट के तौर पर उपलब्ध कराया गया था.

क्वांटाइज़्ड मॉडल के साथ काम करने की सुविधा बंद करें

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

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

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

जीपीयू ऐक्सेलरेशन के साथ क्वांटाइज़्ड मॉडल चलाने के बारे में ज़्यादा जानकारी के लिए, देखें GPU डेलिगेट की खास जानकारी.