Google Play services Java API में LiteRT

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

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

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

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

Play को ऐक्सेस करने के लिए, अपने ऐप्लिकेशन के प्रोजेक्ट कोड में इन डिपेंडेंसी जोड़ें LiteRT के लिए सेवाएं एपीआई:

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

2. LiteRT को शुरू करने की प्रोसेस जोड़ें

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

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

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

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

GPU डेलिगेट, Google 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() within interpreterApi.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());

LiteRT की मदद से, अलग से माइग्रेट किया जा रहा है

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

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

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