एंड्रॉइड के साथ ऑब्जेक्ट डिटेक्शन

यह ट्यूटोरियल आपको दिखाता है कि डिवाइस कैमरे द्वारा कैप्चर किए गए फ़्रेम में वस्तुओं का लगातार पता लगाने के लिए TensorFlow Lite का उपयोग करके एक एंड्रॉइड ऐप कैसे बनाया जाए। यह एप्लिकेशन भौतिक Android डिवाइस के लिए डिज़ाइन किया गया है। यदि आप किसी मौजूदा प्रोजेक्ट को अपडेट कर रहे हैं, तो आप संदर्भ के रूप में कोड नमूने का उपयोग कर सकते हैं और अपने प्रोजेक्ट को संशोधित करने के निर्देशों पर आगे बढ़ सकते हैं।

ऑब्जेक्ट डिटेक्शन सिंहावलोकन

ऑब्जेक्ट डिटेक्शन एक छवि के भीतर वस्तुओं के कई वर्गों की उपस्थिति और स्थान की पहचान करने का मशीन सीखने का कार्य है। एक ऑब्जेक्ट डिटेक्शन मॉडल को एक डेटासेट पर प्रशिक्षित किया जाता है जिसमें ज्ञात वस्तुओं का एक सेट होता है।

प्रशिक्षित मॉडल इनपुट के रूप में छवि फ़्रेम प्राप्त करता है और ज्ञात वर्गों के सेट से छवियों में वस्तुओं को वर्गीकृत करने का प्रयास करता है जिसे पहचानने के लिए इसे प्रशिक्षित किया गया था। प्रत्येक छवि फ्रेम के लिए, ऑब्जेक्ट डिटेक्शन मॉडल उन वस्तुओं की एक सूची आउटपुट करता है जिनका वह पता लगाता है, प्रत्येक ऑब्जेक्ट के लिए एक बाउंडिंग बॉक्स का स्थान और एक स्कोर जो ऑब्जेक्ट के सही ढंग से वर्गीकृत होने के विश्वास को इंगित करता है।

मॉडल और डेटासेट

यह ट्यूटोरियल उन मॉडलों का उपयोग करता है जिन्हें COCO डेटासेट का उपयोग करके प्रशिक्षित किया गया था। COCO एक बड़े पैमाने का ऑब्जेक्ट डिटेक्शन डेटासेट है जिसमें 330K छवियां, 1.5 मिलियन ऑब्जेक्ट इंस्टेंस और 80 ऑब्जेक्ट श्रेणियां शामिल हैं।

आपके पास निम्नलिखित पूर्व-प्रशिक्षित मॉडलों में से किसी एक का उपयोग करने का विकल्प है:

• EfficientDet-Lite0 [अनुशंसित] - BiFPN फीचर एक्सट्रैक्टर, शेयर्ड बॉक्स प्रेडिक्टर और फोकल लॉस के साथ एक हल्का ऑब्जेक्ट डिटेक्शन मॉडल। COCO 2017 सत्यापन डेटासेट के लिए एमएपी (औसत औसत परिशुद्धता) 25.69% है।

• EfficientDet-Lite1 - एक मध्यम आकार का EfficientDet ऑब्जेक्ट डिटेक्शन मॉडल। COCO 2017 सत्यापन डेटासेट के लिए एमएपी 30.55% है।

• EfficientDet-Lite2 - एक बड़ा EfficientDet ऑब्जेक्ट डिटेक्शन मॉडल। COCO 2017 सत्यापन डेटासेट के लिए एमएपी 33.97% है।

• MobileNetV1-SSD - ऑब्जेक्ट डिटेक्शन के लिए TensorFlow Lite के साथ काम करने के लिए अनुकूलित एक बेहद हल्का मॉडल। COCO 2017 सत्यापन डेटासेट के लिए एमएपी 21% है।

इस ट्यूटोरियल के लिए, EfficientDet-Lite0 मॉडल आकार और सटीकता के बीच एक अच्छा संतुलन बनाता है।

मॉडलों को डाउनलोड करना, निकालना और एसेट फ़ोल्डर में रखना स्वचालित रूप से download.gradle फ़ाइल द्वारा प्रबंधित किया जाता है, जो बिल्ड समय पर चलाया जाता है। आपको प्रोजेक्ट में TFLite मॉडल को मैन्युअल रूप से डाउनलोड करने की आवश्यकता नहीं है।

सेटअप और रन उदाहरण

ऑब्जेक्ट डिटेक्शन ऐप सेटअप करने के लिए, GitHub से नमूना डाउनलोड करें और इसे Android Studio का उपयोग करके चलाएं। इस ट्यूटोरियल के निम्नलिखित अनुभाग कोड उदाहरण के प्रासंगिक अनुभागों का पता लगाते हैं, ताकि आप उन्हें अपने एंड्रॉइड ऐप्स पर लागू कर सकें।

सिस्टम आवश्यकताएं

• एंड्रॉइड स्टूडियो संस्करण 2021.1.1 (भौंरा) या उच्चतर।
• एंड्रॉइड एसडीके संस्करण 31 या उच्चतर
• डेवलपर मोड सक्षम के साथ एसडीके 24 (एंड्रॉइड 7.0 - नूगट) के न्यूनतम ओएस संस्करण वाला एंड्रॉइड डिवाइस।

उदाहरण कोड प्राप्त करें

उदाहरण कोड की एक स्थानीय प्रतिलिपि बनाएँ। आप एंड्रॉइड स्टूडियो में एक प्रोजेक्ट बनाने और नमूना एप्लिकेशन चलाने के लिए इस कोड का उपयोग करेंगे।

उदाहरण कोड को क्लोन और सेटअप करने के लिए:

1. Git रिपॉजिटरी

   git clone https://github.com/tensorflow/examples.git
   

   क्लोन करें
2. वैकल्पिक रूप से, अपने git इंस्टेंस को विरल चेकआउट का उपयोग करने के लिए कॉन्फ़िगर करें, ताकि आपके पास केवल ऑब्जेक्ट डिटेक्शन उदाहरण ऐप के लिए फ़ाइलें हों:

   cd examples
   git sparse-checkout init --cone
   git sparse-checkout set lite/examples/object_detection/android
   

प्रोजेक्ट आयात करें और चलाएं

डाउनलोड किए गए उदाहरण कोड से एक प्रोजेक्ट बनाएं, प्रोजेक्ट बनाएं और फिर उसे चलाएं।

उदाहरण कोड प्रोजेक्ट आयात करने और बनाने के लिए:

1. एंड्रॉइड स्टूडियो प्रारंभ करें।
2. एंड्रॉइड स्टूडियो से, फ़ाइल > नया > प्रोजेक्ट आयात करें चुनें।
3. बिल्ड.ग्रेडल फ़ाइल ( .../examples/lite/examples/object_detection/android/build.gradle ) वाली उदाहरण कोड निर्देशिका पर नेविगेट करें और उस निर्देशिका का चयन करें।
4. यदि एंड्रॉइड स्टूडियो ग्रैडल सिंक का अनुरोध करता है, तो ठीक चुनें।
5. सुनिश्चित करें कि आपका एंड्रॉइड डिवाइस आपके कंप्यूटर से कनेक्ट है और डेवलपर मोड सक्षम है। हरे Run तीर पर क्लिक करें।

यदि आप सही निर्देशिका का चयन करते हैं, तो एंड्रॉइड स्टूडियो एक नया प्रोजेक्ट बनाता है और उसे बनाता है। आपके कंप्यूटर की गति और यदि आपने अन्य परियोजनाओं के लिए एंड्रॉइड स्टूडियो का उपयोग किया है, तो इस प्रक्रिया में कुछ मिनट लग सकते हैं। जब निर्माण पूरा हो जाता है, तो एंड्रॉइड स्टूडियो बिल्ड आउटपुट स्थिति पैनल में एक BUILD SUCCESSFUL संदेश प्रदर्शित करता है।

वैकल्पिक: एंड्रॉइड प्लगइन संस्करण को अपडेट करके बिल्ड त्रुटियों को ठीक करने के लिए:

1. प्रोजेक्ट निर्देशिका में बिल्ड.ग्रेडल फ़ाइल खोलें।

2. Android टूल संस्करण को इस प्रकार बदलें:

   // from: classpath
   'com.android.tools.build:gradle:4.2.2'
   // to: classpath
   'com.android.tools.build:gradle:4.1.2'
   

3. चयन करके प्रोजेक्ट को सिंक करें: फ़ाइल > ग्रैडल फ़ाइलों के साथ प्रोजेक्ट को सिंक करें ।

प्रोजेक्ट चलाने के लिए:

1. एंड्रॉइड स्टूडियो से, रन > रन… का चयन करके प्रोजेक्ट चलाएं।
2. ऐप का परीक्षण करने के लिए कैमरे के साथ संलग्न एंड्रॉइड डिवाइस का चयन करें।

अगले अनुभाग आपको संदर्भ बिंदु के रूप में इस उदाहरण ऐप का उपयोग करके, इस कार्यक्षमता को अपने ऐप में जोड़ने के लिए अपने मौजूदा प्रोजेक्ट में किए जाने वाले संशोधनों को दिखाते हैं।

प्रोजेक्ट निर्भरताएँ जोड़ें

अपने स्वयं के एप्लिकेशन में, आपको TensorFlow Lite मशीन लर्निंग मॉडल चलाने के लिए विशिष्ट प्रोजेक्ट निर्भरताएं जोड़नी होंगी, और उपयोगिता फ़ंक्शंस तक पहुंच प्राप्त करनी होगी जो छवियों जैसे डेटा को टेंसर डेटा प्रारूप में परिवर्तित करते हैं जिसे आपके द्वारा उपयोग किए जा रहे मॉडल द्वारा संसाधित किया जा सकता है।

उदाहरण ऐप ऑब्जेक्ट डिटेक्शन मशीन लर्निंग मॉडल के निष्पादन को सक्षम करने के लिए विज़न के लिए टेन्सरफ्लो लाइट टास्क लाइब्रेरी का उपयोग करता है। निम्नलिखित निर्देश बताते हैं कि अपने स्वयं के एंड्रॉइड ऐप प्रोजेक्ट में आवश्यक लाइब्रेरी निर्भरताएं कैसे जोड़ें।

निम्नलिखित निर्देश बताते हैं कि अपने स्वयं के एंड्रॉइड ऐप प्रोजेक्ट में आवश्यक प्रोजेक्ट और मॉड्यूल निर्भरता कैसे जोड़ें।

मॉड्यूल निर्भरताएँ जोड़ने के लिए:

1. TensorFlow Lite का उपयोग करने वाले मॉड्यूल में, निम्नलिखित निर्भरताओं को शामिल करने के लिए मॉड्यूल की build.gradle फ़ाइल को अपडेट करें। उदाहरण कोड में, यह फ़ाइल यहां स्थित है: ...examples/lite/examples/object_detection/android/app/build.gradle ( कोड संदर्भ )

   dependencies {
     ...
     implementation 'org.tensorflow:tensorflow-lite-task-vision:0.4.0'
     // Import the GPU delegate plugin Library for GPU inference
     implementation 'org.tensorflow:tensorflow-lite-gpu-delegate-plugin:0.4.0'
     implementation 'org.tensorflow:tensorflow-lite-gpu:2.9.0'
   }
   

   प्रोजेक्ट में विज़न टास्क लाइब्रेरी ( tensorflow-lite-task-vision ) शामिल होनी चाहिए। ग्राफ़िक्स प्रोसेसिंग यूनिट (GPU) लाइब्रेरी ( tensorflow-lite-gpu-delegate-plugin ) GPU पर ऐप चलाने के लिए बुनियादी ढाँचा प्रदान करती है, और Delegate ( tensorflow-lite-gpu ) संगतता सूची प्रदान करती है।

2. एंड्रॉइड स्टूडियो में, चयन करके प्रोजेक्ट निर्भरता को सिंक करें: फ़ाइल > ग्रैडल फ़ाइलों के साथ प्रोजेक्ट सिंक करें ।

एमएल मॉडल प्रारंभ करें

अपने एंड्रॉइड ऐप में, आपको मॉडल के साथ पूर्वानुमान चलाने से पहले मापदंडों के साथ TensorFlow Lite मशीन लर्निंग मॉडल को आरंभ करना होगा। ये आरंभीकरण पैरामीटर ऑब्जेक्ट डिटेक्शन मॉडल में सुसंगत हैं और इसमें भविष्यवाणियों के लिए न्यूनतम सटीकता सीमा जैसी सेटिंग्स शामिल हो सकती हैं।

TensorFlow Lite मॉडल में एक .tflite फ़ाइल शामिल होती है जिसमें मॉडल कोड होता है और अक्सर एक लेबल फ़ाइल शामिल होती है जिसमें मॉडल द्वारा अनुमानित कक्षाओं के नाम होते हैं। वस्तु पहचान के मामले में, वर्ग वस्तुएँ हैं जैसे कोई व्यक्ति, कुत्ता, बिल्ली या कार।

यह उदाहरण कई मॉडल डाउनलोड करता है जो download_models.gradle में निर्दिष्ट हैं, और ObjectDetectorHelper वर्ग मॉडल के लिए एक चयनकर्ता प्रदान करता है:

val modelName =
  when (currentModel) {
    MODEL_MOBILENETV1 -> "mobilenetv1.tflite"
    MODEL_EFFICIENTDETV0 -> "efficientdet-lite0.tflite"
    MODEL_EFFICIENTDETV1 -> "efficientdet-lite1.tflite"
    MODEL_EFFICIENTDETV2 -> "efficientdet-lite2.tflite"
    else -> "mobilenetv1.tflite"
  }

अपने ऐप में मॉडल आरंभ करने के लिए:

1. अपने विकास प्रोजेक्ट की src/main/assets निर्देशिका में एक .tflite मॉडल फ़ाइल जोड़ें, जैसे: EfficientDet-Lite0 ।
2. अपने मॉडल के फ़ाइल नाम के लिए एक स्थिर चर सेट करें। उदाहरण ऐप में, आप EfficientDet-Lite0 डिटेक्शन मॉडल का उपयोग करने के लिए modelName वैरिएबल को MODEL_EFFICIENTDETV0 पर सेट करते हैं।

3. मॉडल के लिए विकल्प सेट करें, जैसे भविष्यवाणी सीमा, परिणाम सेट आकार, और वैकल्पिक रूप से, हार्डवेयर त्वरण प्रतिनिधि:

   val optionsBuilder =
     ObjectDetector.ObjectDetectorOptions.builder()
       .setScoreThreshold(threshold)
       .setMaxResults(maxResults)
   

4. मॉडल युक्त TensorFlow Lite ObjectDetector ऑब्जेक्ट बनाने के लिए इस ऑब्जेक्ट से सेटिंग्स का उपयोग करें:

   objectDetector =
     ObjectDetector.createFromFileAndOptions(
       context, modelName, optionsBuilder.build())
   

setupObjectDetector निम्नलिखित मॉडल पैरामीटर सेट करता है:

• पता लगाने की सीमा
• पता लगाने के परिणामों की अधिकतम संख्या
• उपयोग करने के लिए प्रोसेसिंग थ्रेड्स की संख्या ( BaseOptions.builder().setNumThreads(numThreads) )
• वास्तविक मॉडल ( modelName )
• ऑब्जेक्टडिटेक्टर ऑब्जेक्ट ( objectDetector )

हार्डवेयर त्वरक कॉन्फ़िगर करें

अपने एप्लिकेशन में TensorFlow Lite मॉडल को प्रारंभ करते समय, आप मॉडल की भविष्यवाणी गणनाओं को तेज़ करने के लिए हार्डवेयर त्वरण सुविधाओं का उपयोग कर सकते हैं।

टेन्सरफ्लो लाइट प्रतिनिधि सॉफ्टवेयर मॉड्यूल हैं जो मोबाइल डिवाइस पर विशेष प्रोसेसिंग हार्डवेयर, जैसे ग्राफिक्स प्रोसेसिंग यूनिट (जीपीयू), टेन्सर प्रोसेसिंग यूनिट (टीपीयू) और डिजिटल सिग्नल प्रोसेसर (डीएसपी) का उपयोग करके मशीन लर्निंग मॉडल के निष्पादन में तेजी लाते हैं। TensorFlow Lite मॉडल चलाने के लिए प्रतिनिधियों का उपयोग करने की अनुशंसा की जाती है, लेकिन इसकी आवश्यकता नहीं है।

ऑब्जेक्ट डिटेक्टर को उस थ्रेड पर वर्तमान सेटिंग्स का उपयोग करके प्रारंभ किया जाता है जो इसका उपयोग कर रहा है। आप सीपीयू और एनएनएपीआई प्रतिनिधियों का उपयोग डिटेक्टरों के साथ कर सकते हैं जो मुख्य थ्रेड पर बनाए जाते हैं और पृष्ठभूमि थ्रेड पर उपयोग किए जाते हैं, लेकिन डिटेक्टर को आरंभ करने वाले थ्रेड को जीपीयू प्रतिनिधि का उपयोग करना चाहिए।

प्रतिनिधियों को ObjectDetectionHelper.setupObjectDetector() फ़ंक्शन के भीतर सेट किया गया है:

when (currentDelegate) {
    DELEGATE_CPU -> {
        // Default
    }
    DELEGATE_GPU -> {
        if (CompatibilityList().isDelegateSupportedOnThisDevice) {
            baseOptionsBuilder.useGpu()
        } else {
            objectDetectorListener?.onError("GPU is not supported on this device")
        }
    }
    DELEGATE_NNAPI -> {
        baseOptionsBuilder.useNnapi()
    }
}

TensorFlow Lite के साथ हार्डवेयर त्वरण प्रतिनिधियों का उपयोग करने के बारे में अधिक जानकारी के लिए, TensorFlow Lite Delegates देखें।

मॉडल के लिए डेटा तैयार करें

आपके एंड्रॉइड ऐप में, आपका कोड मौजूदा डेटा जैसे छवि फ़्रेम को टेन्सर डेटा प्रारूप में परिवर्तित करके व्याख्या के लिए मॉडल को डेटा प्रदान करता है जिसे आपके मॉडल द्वारा संसाधित किया जा सकता है। टेंसर में जो डेटा आप किसी मॉडल को पास करते हैं, उसमें विशिष्ट आयाम या आकार होना चाहिए, जो मॉडल को प्रशिक्षित करने के लिए उपयोग किए गए डेटा के प्रारूप से मेल खाता हो।

इस कोड उदाहरण में उपयोग किया गया EfficientDet-Lite0 मॉडल प्रति पिक्सेल तीन चैनलों (लाल, नीला और हरा) के साथ 320 x 320 के आयाम वाली छवियों का प्रतिनिधित्व करने वाले टेंसर को स्वीकार करता है। टेंसर में प्रत्येक मान 0 और 255 के बीच एक एकल बाइट है। इसलिए, नई छवियों पर पूर्वानुमान चलाने के लिए, आपके ऐप को उस छवि डेटा को उस आकार और आकार के टेंसर डेटा ऑब्जेक्ट में बदलना होगा। TensorFlow Lite टास्क लाइब्रेरी विज़न API आपके लिए डेटा परिवर्तन को संभालता है।

ऐप कैमरे से छवियां खींचने के लिए एक ImageAnalysis ऑब्जेक्ट का उपयोग करता है। यह ऑब्जेक्ट कैमरे से बिटमैप के साथ detectObject फ़ंक्शन को कॉल करता है। ImageProcessor द्वारा डेटा को स्वचालित रूप से आकार दिया और घुमाया जाता है ताकि यह मॉडल की छवि डेटा आवश्यकताओं को पूरा कर सके। फिर छवि को TensorImage ऑब्जेक्ट में अनुवादित किया जाता है।

एमएल मॉडल द्वारा संसाधित किए जाने वाले कैमरा सबसिस्टम से डेटा तैयार करने के लिए:

1. आवश्यक प्रारूप में छवियां निकालने के लिए एक ImageAnalysis ऑब्जेक्ट बनाएं:

   imageAnalyzer =
       ImageAnalysis.Builder()
           .setTargetAspectRatio(AspectRatio.RATIO_4_3)
           .setTargetRotation(fragmentCameraBinding.viewFinder.display.rotation)
           .setBackpressureStrategy(ImageAnalysis.STRATEGY_KEEP_ONLY_LATEST)
           .setOutputImageFormat(OUTPUT_IMAGE_FORMAT_RGBA_8888)
           .build()
           ...
   

2. विश्लेषक को कैमरा सबसिस्टम से कनेक्ट करें और कैमरे से प्राप्त डेटा को समाहित करने के लिए एक बिटमैप बफर बनाएं:

   .also {
     it.setAnalyzer(cameraExecutor) {
       image -> if (!::bitmapBuffer.isInitialized)
       { bitmapBuffer = Bitmap.createBitmap( image.width, image.height,
       Bitmap.Config.ARGB_8888 ) } detectObjects(image)
       }
     }
   

3. मॉडल के लिए आवश्यक विशिष्ट छवि डेटा निकालें, और छवि रोटेशन जानकारी पास करें:

   private fun detectObjects(image: ImageProxy) {
     //Copy out RGB bits to the shared bitmap buffer
     image.use {bitmapBuffer.copyPixelsFromBuffer(image.planes[0].buffer) }
       val imageRotation = image.imageInfo.rotationDegrees
       objectDetectorHelper.detect(bitmapBuffer, imageRotation)
     }
   

4. किसी भी अंतिम डेटा परिवर्तन को पूरा करें और छवि डेटा को TensorImage ऑब्जेक्ट में जोड़ें, जैसा कि उदाहरण ऐप के ObjectDetectorHelper.detect() विधि में दिखाया गया है:

   val imageProcessor = ImageProcessor.Builder().add(Rot90Op(-imageRotation / 90)).build()
   // Preprocess the image and convert it into a TensorImage for detection.
   val tensorImage = imageProcessor.process(TensorImage.fromBitmap(image))
   

पूर्वानुमान चलाएँ

अपने एंड्रॉइड ऐप में, एक बार जब आप सही प्रारूप में छवि डेटा के साथ एक TensorImage ऑब्जेक्ट बनाते हैं, तो आप भविष्यवाणी, या अनुमान उत्पन्न करने के लिए उस डेटा के विरुद्ध मॉडल चला सकते हैं।

उदाहरण ऐप के fragments/CameraFragment.kt क्लास में, जब ऐप कैमरे से कनेक्ट होता है, तो bindCameraUseCases फ़ंक्शन के भीतर imageAnalyzer ऑब्जेक्ट स्वचालित रूप से भविष्यवाणियों के लिए मॉडल को डेटा भेजता है।

कैमरा चयनकर्ता, पूर्वावलोकन विंडो और एमएल मॉडल प्रोसेसिंग को संभालने के लिए ऐप cameraProvider.bindToLifecycle() विधि का उपयोग करता है। ObjectDetectorHelper.kt क्लास छवि डेटा को मॉडल में पास करने का काम संभालता है। मॉडल चलाने और छवि डेटा से पूर्वानुमान उत्पन्न करने के लिए:

• छवि डेटा को अपने पूर्वानुमान फ़ंक्शन में पास करके पूर्वानुमान चलाएँ:

  val results = objectDetector?.detect(tensorImage)
  

TensorFlow Lite इंटरप्रेटर ऑब्जेक्ट इस डेटा को प्राप्त करता है, इसे मॉडल के विरुद्ध चलाता है, और भविष्यवाणियों की एक सूची तैयार करता है। मॉडल द्वारा डेटा के निरंतर प्रसंस्करण के लिए, runForMultipleInputsOutputs() विधि का उपयोग करें ताकि प्रत्येक पूर्वानुमान रन के लिए इंटरप्रेटर ऑब्जेक्ट न बनाए जाएं और फिर सिस्टम द्वारा हटा दिए जाएं।

मॉडल आउटपुट संभालें

आपके एंड्रॉइड ऐप में, ऑब्जेक्ट डिटेक्शन मॉडल के विरुद्ध छवि डेटा चलाने के बाद, यह भविष्यवाणियों की एक सूची तैयार करता है जिसे आपके ऐप कोड को अतिरिक्त व्यावसायिक तर्क निष्पादित करके, उपयोगकर्ता को परिणाम प्रदर्शित करके, या अन्य क्रियाएं करके संभालना होगा।

किसी भी दिए गए TensorFlow Lite मॉडल का आउटपुट उसके द्वारा उत्पादित भविष्यवाणियों की संख्या (एक या कई) और प्रत्येक भविष्यवाणी के लिए वर्णनात्मक जानकारी के संदर्भ में भिन्न होता है। ऑब्जेक्ट डिटेक्शन मॉडल के मामले में, भविष्यवाणियों में आम तौर पर एक बाउंडिंग बॉक्स के लिए डेटा शामिल होता है जो इंगित करता है कि छवि में ऑब्जेक्ट का पता कहां लगाया गया है। उदाहरण कोड में, परिणाम CameraFragment.kt में onResults फ़ंक्शन को पास कर दिए जाते हैं, जो ऑब्जेक्ट डिटेक्शन प्रक्रिया पर डिटेक्टर लिस्टनर के रूप में कार्य करता है।

interface DetectorListener {
  fun onError(error: String)
  fun onResults(
    results: MutableList<Detection>?,
    inferenceTime: Long,
    imageHeight: Int,
    imageWidth: Int
  )
}

इस उदाहरण में उपयोग किए गए मॉडल के लिए, प्रत्येक भविष्यवाणी में ऑब्जेक्ट के लिए एक बाउंडिंग बॉक्स स्थान, ऑब्जेक्ट के लिए एक लेबल और भविष्यवाणी के आत्मविश्वास का प्रतिनिधित्व करने वाले फ्लोट के रूप में 0 और 1 के बीच एक भविष्यवाणी स्कोर शामिल है, जिसमें 1 उच्चतम आत्मविश्वास रेटिंग है। . सामान्य तौर पर, 50% (0.5) से कम स्कोर वाली भविष्यवाणियों को अनिर्णायक माना जाता है। हालाँकि, आप कम-मूल्य वाले पूर्वानुमान परिणामों को कैसे संभालते हैं यह आप पर और आपके एप्लिकेशन की ज़रूरतों पर निर्भर करता है।

मॉडल पूर्वानुमान परिणामों को संभालने के लिए:

1. अपने ऐप कोड या उपयोगकर्ता इंटरफ़ेस ऑब्जेक्ट पर परिणाम भेजने के लिए श्रोता पैटर्न का उपयोग करें। उदाहरण ऐप ObjectDetectorHelper ऑब्जेक्ट से CameraFragment ऑब्जेक्ट तक डिटेक्शन परिणाम पास करने के लिए इस पैटर्न का उपयोग करता है:

   objectDetectorListener.onResults(
   // instance of CameraFragment
       results,
       inferenceTime,
       tensorImage.height,
       tensorImage.width)
   

2. परिणामों पर कार्य करें, जैसे उपयोगकर्ता को पूर्वानुमान प्रदर्शित करना। उदाहरण परिणाम दिखाने के लिए कैमरा प्रीव्यू ऑब्जेक्ट पर एक ओवरले बनाता है:

   override fun onResults(
     results: MutableList<Detection>?,
     inferenceTime: Long,
     imageHeight: Int,
     imageWidth: Int
   ) {
       activity?.runOnUiThread {
           fragmentCameraBinding.bottomSheetLayout.inferenceTimeVal.text =
               String.format("%d ms", inferenceTime)
   
           // Pass necessary information to OverlayView for drawing on the canvas
           fragmentCameraBinding.overlay.setResults(
               results ?: LinkedList<Detection>(),
               imageHeight,
               imageWidth
           )
   
           // Force a redraw
           fragmentCameraBinding.overlay.invalidate()
       }
   }
   

एक बार जब मॉडल भविष्यवाणी परिणाम लौटा देता है, तो आपका एप्लिकेशन आपके उपयोगकर्ता को परिणाम प्रस्तुत करके या अतिरिक्त तर्क निष्पादित करके उस भविष्यवाणी पर कार्य कर सकता है। उदाहरण कोड के मामले में, एप्लिकेशन पहचाने गए ऑब्जेक्ट के चारों ओर एक बाउंडिंग बॉक्स खींचता है और स्क्रीन पर क्लास का नाम प्रदर्शित करता है।

अगले कदम

• उदाहरणों में TensorFlow Lite के विभिन्न उपयोगों का अन्वेषण करें।
• मॉडल अनुभाग में TensorFlow Lite के साथ मशीन लर्निंग मॉडल का उपयोग करने के बारे में अधिक जानें।
• TensorFlow Lite डेवलपर गाइड में अपने मोबाइल एप्लिकेशन में मशीन लर्निंग लागू करने के बारे में और जानें।