Google Play services के Java (और Kotlin) API में LiteRT

Google Play services में LiteRT को Java API का इस्तेमाल करके भी ऐक्सेस किया जा सकता है. इनका इस्तेमाल Java या Kotlin कोड से किया जा सकता है. इसके अलावा, इनका इस्तेमाल नेटिव एपीआई से भी किया जा सकता है. खास तौर पर, Google Play services में LiteRT, LiteRT Interpreter API के ज़रिए उपलब्ध है.

अनुवादक एपीआई का इस्तेमाल करना

TensorFlow रनटाइम की ओर से उपलब्ध कराया गया LiteRT Interpreter API, एमएल मॉडल बनाने और उन्हें चलाने के लिए एक सामान्य इंटरफ़ेस उपलब्ध कराता है. Google Play services के रनटाइम में TensorFlow Lite का इस्तेमाल करके, Interpreter API की मदद से अनुमान लगाने के लिए, यह तरीका अपनाएं.

1. प्रोजेक्ट डिपेंडेंसी जोड़ना

LiteRT के लिए Play services API को ऐक्सेस करने के लिए, अपने ऐप्लिकेशन प्रोजेक्ट कोड में ये डिपेंडेंसी जोड़ें:

dependencies {
...
    // LiteRT dependencies for Google Play services
    implementation 'com.google.android.gms:play-services-tflite-java:16.1.0'
    // Optional: include LiteRT Support Library
    implementation 'com.google.android.gms:play-services-tflite-support:16.1.0'
...
}

2. LiteRT को शुरू करने के लिए कोड जोड़ना

LiteRT API का इस्तेमाल करने से पहले, Google Play services API के LiteRT कॉम्पोनेंट को शुरू करें:

Kotlin

val initializeTask: Task<Void> by lazy { TfLite.initialize(this) }

Java

Task<Void> initializeTask = TfLite.initialize(context);

3. इंटरप्रेटर बनाना और रनटाइम का विकल्प सेट करना

InterpreterApi.create() का इस्तेमाल करके इंटरप्रेटर बनाएं और उसे Google Play services runtime का इस्तेमाल करने के लिए कॉन्फ़िगर करें. इसके लिए, InterpreterApi.Options.setRuntime() को कॉल करें. इसे यहां दिए गए उदाहरण कोड में दिखाया गया है:

Kotlin

import org.tensorflow.lite.InterpreterApi
import org.tensorflow.lite.InterpreterApi.Options.TfLiteRuntime
...
private lateinit var interpreter: InterpreterApi
...
initializeTask.addOnSuccessListener {
  val interpreterOption =
    InterpreterApi.Options().setRuntime(TfLiteRuntime.FROM_SYSTEM_ONLY)
  interpreter = InterpreterApi.create(
    modelBuffer,
    interpreterOption
  )}
  .addOnFailureListener { e ->
    Log.e("Interpreter", "Cannot initialize interpreter", e)
  }

Java

import org.tensorflow.lite.InterpreterApi
import org.tensorflow.lite.InterpreterApi.Options.TfLiteRuntime
...
private InterpreterApi interpreter;
...
initializeTask.addOnSuccessListener(a -> {
    interpreter = InterpreterApi.create(modelBuffer,
      new InterpreterApi.Options().setRuntime(TfLiteRuntime.FROM_SYSTEM_ONLY));
  })
  .addOnFailureListener(e -> {
    Log.e("Interpreter", String.format("Cannot initialize interpreter: %s",
          e.getMessage()));
  });

आपको ऊपर दिया गया तरीका इस्तेमाल करना चाहिए, क्योंकि इससे Android के उपयोगकर्ता इंटरफ़ेस थ्रेड को ब्लॉक नहीं किया जाता. अगर आपको थ्रेड के एक्ज़ीक्यूशन को ज़्यादा बारीकी से मैनेज करना है, तो इंटरप्रेटर बनाने के लिए Tasks.await() कॉल जोड़ा जा सकता है:

Kotlin

import androidx.lifecycle.lifecycleScope
...
lifecycleScope.launchWhenStarted { // uses coroutine
  initializeTask.await()
}

Java

@BackgroundThread
InterpreterApi initializeInterpreter() {
    Tasks.await(initializeTask);
    return InterpreterApi.create(...);
}

4. अनुमान लगाना

आपने जो interpreter ऑब्जेक्ट बनाया है उसका इस्तेमाल करके, run() तरीके को कॉल करें, ताकि अनुमान जनरेट किया जा सके.

Kotlin

interpreter.run(inputBuffer, outputBuffer)

Java

interpreter.run(inputBuffer, outputBuffer);

हार्डवेयर की मदद से तेज़ी लाने की सुविधा

LiteRT की मदद से, ग्राफ़िक्स प्रोसेसिंग यूनिट (जीपीयू) जैसे खास हार्डवेयर प्रोसेसर का इस्तेमाल करके, अपने मॉडल की परफ़ॉर्मेंस को बेहतर बनाया जा सकता है. डेलिगेट नाम के हार्डवेयर ड्राइवर का इस्तेमाल करके, इन खास प्रोसेसर का फ़ायदा लिया जा सकता है.

GPU डेलिगेट, Google Play services के ज़रिए उपलब्ध कराया जाता है. साथ ही, इसे डाइनैमिक तरीके से लोड किया जाता है. ठीक उसी तरह जैसे Interpreter API के Play services वर्शन को लोड किया जाता है.

यह देखना कि सुविधा किन डिवाइसों पर उपलब्ध है

सभी डिवाइसों पर, TFLite के साथ जीपीयू हार्डवेयर ऐक्सलरेशन की सुविधा काम नहीं करती. गड़बड़ियों और क्रैश होने की संभावित समस्याओं को कम करने के लिए, TfLiteGpu.isGpuDelegateAvailable तरीके का इस्तेमाल करके यह पता लगाएं कि कोई डिवाइस, GPU डेलिगेट के साथ काम करता है या नहीं.

इस तरीके का इस्तेमाल करके, यह पुष्टि करें कि कोई डिवाइस GPU के साथ काम करता है या नहीं. साथ ही, जब GPU काम न करे, तब CPU का इस्तेमाल करें.

useGpuTask = TfLiteGpu.isGpuDelegateAvailable(context)

useGpuTask जैसे वैरिएबल का इस्तेमाल करके, यह पता लगाया जा सकता है कि डिवाइस, जीपीयू डेलिगेट का इस्तेमाल करते हैं या नहीं.

Kotlin

val interpreterTask = useGpuTask.continueWith { task ->
  val interpreterOptions = InterpreterApi.Options()
      .setRuntime(TfLiteRuntime.FROM_SYSTEM_ONLY)
  if (task.result) {
      interpreterOptions.addDelegateFactory(GpuDelegateFactory())
  }
  InterpreterApi.create(FileUtil.loadMappedFile(context, MODEL_PATH), interpreterOptions)
}

Java

Task<InterpreterApi.Options> interpreterOptionsTask = useGpuTask.continueWith({ task ->
  InterpreterApi.Options options =
      new InterpreterApi.Options().setRuntime(TfLiteRuntime.FROM_SYSTEM_ONLY);
  if (task.getResult()) {
     options.addDelegateFactory(new GpuDelegateFactory());
  }
  return options;
});

Interpreter API के साथ GPU

Interpreter API के साथ GPU डेलिगेट का इस्तेमाल करने के लिए:

  1. Play services से GPU डेलिगेट का इस्तेमाल करने के लिए, प्रोजेक्ट की डिपेंडेंसी अपडेट करें:

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

  2. TFlite को शुरू करते समय, जीपीयू डेलिगेट विकल्प चालू करें:

    Kotlin

    TfLite.initialize(context,
  TfLiteInitializationOptions.builder()
    .setEnableGpuDelegateSupport(true)
    .build())

    Java

    TfLite.initialize(context,
  TfLiteInitializationOptions.builder()
    .setEnableGpuDelegateSupport(true)
    .build());

  3. इंटरप्रेटर के विकल्पों में जीपीयू डेलिगेट चालू करें: addDelegateFactory() withinInterpreterApi.Options()` को कॉल करके, डेलिगेट फ़ैक्ट्री को GpuDelegateFactory पर सेट करें:

    Kotlin

    val interpreterOption = InterpreterApi.Options()
  .setRuntime(TfLiteRuntime.FROM_SYSTEM_ONLY)
  .addDelegateFactory(GpuDelegateFactory())

    Java

    Options interpreterOption = InterpreterApi.Options()
  .setRuntime(TfLiteRuntime.FROM_SYSTEM_ONLY)
  .addDelegateFactory(new GpuDelegateFactory());

स्टैंड-अलोन LiteRT से माइग्रेट करना

अगर आपको अपने ऐप्लिकेशन को स्टैंड-अलोन LiteRT से Play services API पर माइग्रेट करना है, तो अपने ऐप्लिकेशन प्रोजेक्ट कोड को अपडेट करने के लिए, यहां दिए गए अतिरिक्त दिशा-निर्देश पढ़ें:

  1. सीमाएं सेक्शन देखें. इससे यह पक्का किया जा सकेगा कि आपके इस्तेमाल के मामले में, इस सुविधा का इस्तेमाल किया जा सकता है या नहीं.
  2. हमारा सुझाव है कि कोड अपडेट करने से पहले, अपने मॉडल की परफ़ॉर्मेंस और सटीकता की जांच करें. खास तौर पर, अगर LiteRT (TF Lite) के 2.1 से पहले के वर्शन का इस्तेमाल किया जा रहा है, तो ऐसा ज़रूर करें. इससे आपको नए वर्शन की तुलना करने के लिए एक बेसलाइन मिल जाएगी.
  3. अगर आपने अपने सभी कोड को LiteRT के लिए Play services API का इस्तेमाल करने के लिए माइग्रेट कर दिया है, तो आपको अपने build.gradle फ़ाइल से LiteRT की मौजूदा रनटाइम लाइब्रेरी डिपेंडेंसी (org.tensorflow:tensorflow-lite:* वाली एंट्री) हटानी चाहिए. इससे आपके ऐप्लिकेशन का साइज़ कम हो जाएगा.
  4. अपने कोड में new Interpreter ऑब्जेक्ट बनाने के सभी उदाहरणों की पहचान करें. इसके बाद, हर उदाहरण में बदलाव करें, ताकि वह new Interpreter कॉल का इस्तेमाल करे.InterpreterApi.create() नया TfLite.initialize एसिंक्रोनस है. इसका मतलब है कि ज़्यादातर मामलों में, यह ड्रॉप-इन रिप्लेसमेंट नहीं है: कॉल पूरा होने पर, आपको एक लिसनर रजिस्टर करना होगा. तीसरे चरण के कोड में दिए गए कोड स्निपेट को देखें.
  5. org.tensorflow.lite.Interpreter या org.tensorflow.lite.InterpreterApi क्लास का इस्तेमाल करके, किसी भी सोर्स फ़ाइल में import org.tensorflow.lite.InterpreterApi; और import org.tensorflow.lite.InterpreterApi.Options.TfLiteRuntime; जोड़ें.
  6. अगर InterpreterApi.create() को किए गए किसी भी कॉल में सिर्फ़ एक आर्ग्युमेंट है, तो आर्ग्युमेंट की सूची में new InterpreterApi.Options() जोड़ें.
  7. InterpreterApi.create() के किसी भी कॉल के आखिरी आर्ग्युमेंट में .setRuntime(TfLiteRuntime.FROM_SYSTEM_ONLY) जोड़ें.
  8. org.tensorflow.lite.Interpreter क्लास के अन्य सभी इंस्टेंस को org.tensorflow.lite.InterpreterApi से बदलें.

अगर आपको स्टैंड-अलोन LiteRT और Play services API का इस्तेमाल एक साथ करना है, तो आपको LiteRT (TF Lite) के 2.9 या इसके बाद वाले वर्शन का इस्तेमाल करना होगा. LiteRT (TF Lite) का 2.8 और इससे पहले का वर्शन, Play services API के वर्शन के साथ काम नहीं करता.