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

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

Interpreter API का इस्तेमाल करना

TensorFlow रनटाइम से मिलने वाला LiteRT Translator API, एमएल मॉडल बनाने और चलाने के लिए एक ऐसा इंटरफ़ेस उपलब्ध कराता है जिसे खास तौर पर इस्तेमाल किया जा सकता है. Google Play services के रनटाइम में TensorFlow Lite का इस्तेमाल करके, Translator 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 कॉम्पोनेंट को शुरू करें:

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

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

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

KotlinJava
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)
  }
 
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() कॉल जोड़ा जा सकता है:

KotlinJava
import androidx.lifecycle.lifecycleScope
...
lifecycleScope.launchWhenStarted { // uses coroutine
  initializeTask.await()
}
 
@BackgroundThread
InterpreterApi initializeInterpreter() {
    Tasks.await(initializeTask);
    return InterpreterApi.create(...);
}

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

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

KotlinJava
interpreter.run(inputBuffer, outputBuffer)
 
interpreter.run(inputBuffer, outputBuffer);

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

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

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

यह देखना कि यह सुविधा आपके डिवाइस पर काम करती है या नहीं

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

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

useGpuTask = TfLiteGpu.isGpuDelegateAvailable(context)

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

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

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

इंटरप्रेटर एपीआई के साथ GPU डेलिगेट का इस्तेमाल करने के लिए:

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

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

  2. TFlite शुरू करने के दौरान, जीपीयू डेलिगेट का विकल्प चालू करें:

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

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

    KotlinJava
    val interpreterOption = InterpreterApi.Options()
  .setRuntime(TfLiteRuntime.FROM_SYSTEM_ONLY)
  .addDelegateFactory(GpuDelegateFactory())
     
    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 का इस्तेमाल करने के लिए, अपने सभी कोड माइग्रेट कर लिए हैं, तो आपको बिल्ड.gradle फ़ाइल से मौजूदा LiteRT रनटाइम लाइब्रेरी डिपेंडेंसी (org.tensorflow:tensorflow-lite:* से जुड़ी एंट्री) को हटा देना चाहिए, ताकि आप अपने ऐप्लिकेशन का साइज़ कम कर सकें.
  4. अपने कोड में 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 के वर्शन के साथ काम नहीं करते.