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; });
अनुवादक एपीआई के साथ जीपीयू
अनुवादक एपीआई के साथ जीपीयू डेलिगेट का इस्तेमाल करने के लिए:
Play services से जीपीयू डेलिगेट का इस्तेमाल करने के लिए, प्रोजेक्ट डिपेंडेंसी अपडेट करें:
implementation 'com.google.android.gms:play-services-tflite-gpu:16.1.0'
TFlite शुरू करने में जीपीयू डेलिगेट विकल्प को चालू करें:
Kotlin
TfLite.initialize(context, TfLiteInitializationOptions.builder() .setEnableGpuDelegateSupport(true) .build())
Java
TfLite.initialize(context, TfLiteInitializationOptions.builder() .setEnableGpuDelegateSupport(true) .build());
अनुवादक विकल्पों में जीपीयू डेलिगेट को चालू करें:
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());
स्टैंड-अलोन TensorFlow Lite से माइग्रेट करना
अगर आपको अपने ऐप्लिकेशन को स्टैंड-अलोन TensorFlow Lite से Play services API में माइग्रेट करना है, तो अपने ऐप्लिकेशन प्रोजेक्ट कोड को अपडेट करने के लिए यहां दिए गए अतिरिक्त दिशा-निर्देश पढ़ें:
- इस पेज के सीमाएं सेक्शन को देखें, ताकि यह पक्का किया जा सके कि आपके ऐप्लिकेशन के इस्तेमाल का उदाहरण मान्य है.
- अपने कोड को अपडेट करने से पहले, अपने मॉडल की परफ़ॉर्मेंस और उनके सटीक होने की जांच कर लें. खास तौर पर, अगर आपके पास TensorFlow Lite के, वर्शन 2.1 से पहले के वर्शन हैं, तो आपके पास नए वर्शन के साथ तुलना करने के लिए एक बेसलाइन हो.
- अगर आपने TensorFlow Lite के लिए Play services API का इस्तेमाल करने के लिए, अपने सभी कोड माइग्रेट कर लिए हैं, तो आपको अपनी create.gradle फ़ाइल से मौजूदा TensorFlow Lite runtime
लाइब्रेरी डिपेंडेंसी (
org.tensorflow:tensorflow-lite:*
से एंट्री) हटानी होगी, ताकि आप अपने ऐप्लिकेशन का साइज़ कम कर सकें. - अपने कोड में हर बार
new Interpreter
ऑब्जेक्ट बनने की घटनाओं की पहचान करें और हर एक में बदलाव करें, ताकि वह InteracterApi.create() कॉल का इस्तेमाल कर सके. नया TfLite.Initialize, एसिंक्रोनस है. इसका मतलब है कि ज़्यादातर मामलों में, यह कॉल में शामिल नहीं होंगी: कॉल पूरा होने के बाद, आपको इसके लिए लिसनर रजिस्टर करना होगा. चरण 3 के कोड में कोड स्निपेट देखें. org.tensorflow.lite.Interpreter
याorg.tensorflow.lite.InterpreterApi
क्लास का इस्तेमाल करके, किसी भी सोर्स फ़ाइल मेंimport org.tensorflow.lite.InterpreterApi;
औरimport org.tensorflow.lite.InterpreterApi.Options.TfLiteRuntime;
जोड़ें.- अगर
InterpreterApi.create()
को मिले किसी भी कॉल में सिर्फ़ एक तर्क है, तो उस तर्क की सूची मेंnew InterpreterApi.Options()
को जोड़ें. InterpreterApi.create()
को किए गए किसी भी कॉल के आखिरी आर्ग्युमेंट में.setRuntime(TfLiteRuntime.FROM_SYSTEM_ONLY)
जोड़ें.org.tensorflow.lite.Interpreter
क्लास की अन्य सभी घटनाओं कोorg.tensorflow.lite.InterpreterApi
से बदलें.
अगर आपको स्टैंडअलोन TensorFlow Lite और Play services API को साथ-साथ इस्तेमाल करना है, तो आपको TensorFlow Lite 2.9 या इसके बाद के वर्शन का इस्तेमाल करना होगा. TensorFlow Lite 2.8 और उससे पहले के वर्शन, Play services API के वर्शन पर काम नहीं करते.