Google Play services Java API में TensorFlow Lite

Google Play सेवाओं में TensorFlow Lite को Native API के अलावा Java API का इस्तेमाल करके भी ऐक्सेस किया जा सकता है. खास तौर पर, Google Play Services में TensorFlow Lite TensorFlow Lite Interpreter API के ज़रिए उपलब्ध है.

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

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

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

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

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

2. TensorFlow Lite को शुरू करने का तरीका जोड़ें

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

Kotlin

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

Java

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

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

InterpreterApi.create() का इस्तेमाल करके अनुवादक बनाएं और उसे Google Play services के रनटाइम का इस्तेमाल करने के लिए कॉन्फ़िगर करें. इसके लिए, 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);

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

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

GPU प्रतिनिधि को Google Play services की मदद से दी जाती है. साथ ही, इसे डाइनैमिक तौर पर लोड किया जाता है, जैसा कि अनुवादक एपीआई के Play services के वर्शन में होता है.

डिवाइस पर काम करने की सुविधा की जांच की जा रही है

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

इस तरीके का इस्तेमाल करके पुष्टि करें कि डिवाइस, जीपीयू के साथ काम करता है या नहीं. साथ ही, जीपीयू का इस्तेमाल न होने पर, फ़ॉलबैक के तौर पर सीपीयू का इस्तेमाल करें.

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

अनुवादक एपीआई के साथ जीपीयू

अनुवादक एपीआई के साथ जीपीयू डेलिगेट का इस्तेमाल करने के लिए:

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

    implementation 'com.google.android.gms:play-services-tflite-gpu:16.1.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()` को कॉल करके, डेलिगेट फ़ैक्ट्री को GpuDelegateफ़ैक्ट्री पर सेट करें:

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

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

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

  1. इस पेज के सीमाएं सेक्शन को देखें, ताकि यह पक्का किया जा सके कि आपके ऐप्लिकेशन के इस्तेमाल का उदाहरण मान्य है.
  2. अपने कोड को अपडेट करने से पहले, अपने मॉडल की परफ़ॉर्मेंस और उनके सटीक होने की जांच कर लें. खास तौर पर, अगर आपके पास TensorFlow Lite के, वर्शन 2.1 से पहले के वर्शन हैं, तो आपके पास नए वर्शन के साथ तुलना करने के लिए एक बेसलाइन हो.
  3. अगर आपने TensorFlow Lite के लिए Play services API का इस्तेमाल करने के लिए, अपने सभी कोड माइग्रेट कर लिए हैं, तो आपको अपनी create.gradle फ़ाइल से मौजूदा TensorFlow Lite runtime लाइब्रेरी डिपेंडेंसी (org.tensorflow:tensorflow-lite:* से एंट्री) हटानी होगी, ताकि आप अपने ऐप्लिकेशन का साइज़ कम कर सकें.
  4. अपने कोड में हर बार new Interpreter ऑब्जेक्ट बनने की घटनाओं की पहचान करें और हर एक में बदलाव करें, ताकि वह InteracterApi.create() कॉल का इस्तेमाल कर सके. नया TfLite.Initialize, एसिंक्रोनस है. इसका मतलब है कि ज़्यादातर मामलों में, यह कॉल में शामिल नहीं होंगी: कॉल पूरा होने के बाद, आपको इसके लिए लिसनर रजिस्टर करना होगा. चरण 3 के कोड में कोड स्निपेट देखें.
  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 से बदलें.

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