Android के लिए क्विकस्टार्ट

यह पृष्ठ आपको दिखाता है कि लाइव कैमरा फ़ीड का विश्लेषण करने और वस्तुओं की पहचान करने के लिए TensorFlow Lite के साथ एक Android ऐप कैसे बनाया जाए। इस मशीन लर्निंग यूज केस को ऑब्जेक्ट डिटेक्शन कहा जाता है। उदाहरण ऐप ऑब्जेक्ट डिटेक्शन मशीन लर्निंग मॉडल के निष्पादन को सक्षम करने के लिए Google Play सेवाओं के माध्यम से दृष्टि के लिए TensorFlow लाइट टास्क लाइब्रेरी का उपयोग करता है, जो TensorFlow लाइट के साथ एक ML एप्लिकेशन बनाने के लिए अनुशंसित दृष्टिकोण है।

उदाहरण सेट करें और चलाएँ

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

• एंड्रॉइड स्टूडियो 4.2 या उच्चतर
• एंड्रॉइड एसडीके संस्करण 21 या उच्चतर

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

उदाहरण कोड की एक स्थानीय कॉपी बनाएं ताकि आप उसे बना और चला सकें।

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

1. git रिपॉजिटरी को क्लोन करें

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

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

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

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

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

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

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

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

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

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

उदाहरण ऐप कैसे काम करता है

उदाहरण ऐप पूर्व-प्रशिक्षित ऑब्जेक्ट डिटेक्शन मॉडल का उपयोग करता है, जैसे कि mobilenetv1.tflite , TensorFlow लाइट प्रारूप में किसी Android डिवाइस के कैमरे से लाइव वीडियो स्ट्रीम में ऑब्जेक्ट की तलाश करता है। इस सुविधा के लिए कोड मुख्य रूप से इन फ़ाइलों में है:

• ObjectDetectorHelper.kt - रनटाइम वातावरण को प्रारंभ करता है, हार्डवेयर त्वरण को सक्षम करता है, और ऑब्जेक्ट डिटेक्शन एमएल मॉडल चलाता है।
• CameraFragment.kt - कैमरा छवि डेटा स्ट्रीम बनाता है, मॉडल के लिए डेटा तैयार करता है, और ऑब्जेक्ट डिटेक्शन परिणाम प्रदर्शित करता है।

अगले अनुभाग आपको इन कोड फ़ाइलों के प्रमुख घटक दिखाते हैं, ताकि आप इस कार्यक्षमता को जोड़ने के लिए किसी Android ऐप को संशोधित कर सकें।

ऐप बनाएं

निम्नलिखित अनुभाग अपना खुद का एंड्रॉइड ऐप बनाने और उदाहरण ऐप में दिखाए गए मॉडल को चलाने के लिए महत्वपूर्ण चरणों की व्याख्या करते हैं। ये निर्देश संदर्भ बिंदु के रूप में पहले दिखाए गए उदाहरण ऐप का उपयोग करते हैं।

परियोजना निर्भरता जोड़ें

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

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

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

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

   ...
   dependencies {
   ...
       // Tensorflow Lite dependencies
       implementation 'org.tensorflow:tensorflow-lite-task-vision-play-services:0.4.2'
       implementation 'com.google.android.gms:play-services-tflite-gpu:16.1.0'
   ...
   }
   

2. Android Studio में, प्रोजेक्ट निर्भरता को चुनकर सिंक करें: File > Sync Project with Gradle Files ।

Google Play सेवाएं प्रारंभ करें

जब आप TensorFlow Lite मॉडल को चलाने के लिए Google Play सेवाओं का उपयोग करते हैं, तो इसका उपयोग करने से पहले आपको सेवा को इनिशियलाइज़ करना होगा। यदि आप सेवा के साथ हार्डवेयर त्वरण समर्थन का उपयोग करना चाहते हैं, जैसे कि GPU त्वरण, तो आप उस समर्थन को इस आरंभीकरण के भाग के रूप में भी सक्षम करते हैं।

TensorFlow Lite को Google Play सेवाओं के साथ आरंभ करने के लिए:

1. एक TfLiteInitializationOptions ऑब्जेक्ट बनाएं और GPU समर्थन को सक्षम करने के लिए इसे संशोधित करें:

   val options = TfLiteInitializationOptions.builder()
       .setEnableGpuDelegateSupport(true)
       .build()
   

2. Play सेवाओं के रनटाइम के उपयोग को सक्षम करने के लिए TfLiteVision.initialize() विधि का उपयोग करें, और यह सत्यापित करने के लिए एक श्रोता सेट करें कि यह सफलतापूर्वक लोड हो गया है:

   TfLiteVision.initialize(context, options).addOnSuccessListener {
       objectDetectorListener.onInitialized()
   }.addOnFailureListener {
       // Called if the GPU Delegate is not supported on the device
       TfLiteVision.initialize(context).addOnSuccessListener {
           objectDetectorListener.onInitialized()
       }.addOnFailureListener{
           objectDetectorListener.onError("TfLiteVision failed to initialize: "
                   + it.message)
       }
   }
   

एमएल मॉडल दुभाषिया को इनिशियलाइज़ करें

मॉडल फ़ाइल लोड करके और मॉडल पैरामीटर सेट करके TensorFlow Lite मशीन लर्निंग मॉडल दुभाषिया को प्रारंभ करें। TensorFlow Lite मॉडल में मॉडल कोड वाली .tflite फ़ाइल शामिल होती है। आपको अपने मॉडल को अपनी विकास परियोजना की src/main/assets निर्देशिका में संग्रहीत करना चाहिए, उदाहरण के लिए:

.../src/main/assets/mobilenetv1.tflite`

मॉडल को इनिशियलाइज़ करने के लिए:

1. अपनी विकास परियोजना की src/main/assets निर्देशिका में .tflite मॉडल फ़ाइल जोड़ें, जैसे ssd_mobilenet_v1 ।

2. अपने एमएल मॉडल के फ़ाइल नाम को निर्दिष्ट करने के लिए modelName चर सेट करें:

   val modelName = "mobilenetv1.tflite"
   

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

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

4. विकल्पों के साथ GPU त्वरण सक्षम करें और यदि डिवाइस पर त्वरण समर्थित नहीं है तो कोड को इनायत से विफल होने दें:

   try {
       optionsBuilder.useGpu()
   } catch(e: Exception) {
       objectDetectorListener.onError("GPU is not supported on this device")
   }
   
   

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

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

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

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

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

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

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 ऑब्जेक्ट बनाते हैं, तो आप भविष्यवाणी, या अनुमान उत्पन्न करने के लिए उस डेटा के विरुद्ध मॉडल चला सकते हैं। उदाहरण ऐप में, यह कोड ObjectDetectorHelper.detect() विधि में निहित है।

एक मॉडल चलाने और छवि डेटा से भविष्यवाणियां उत्पन्न करने के लिए:

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

  val results = objectDetector?.detect(tensorImage)
  

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

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

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

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

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

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

   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 डेवलपर गाइड में अपने मोबाइल एप्लिकेशन में मशीन लर्निंग को लागू करने के बारे में अधिक जानें।