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

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

ऑब्जेक्ट डिटेक्शन एनिमेटेड डेमो

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

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

  • एंड्रॉइड स्टूडियो 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
    

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

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

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

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

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

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

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

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

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

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

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

ऐप बनाएं

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

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

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

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

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

  1. एंड्रॉइड ऐप मॉड्यूल में जो TensorFlow Lite का उपयोग करता है, निम्नलिखित निर्भरताओं को शामिल करने के लिए मॉड्यूल की 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. एंड्रॉइड स्टूडियो में, चयन करके प्रोजेक्ट निर्भरता को सिंक करें: फ़ाइल > ग्रैडल फ़ाइलों के साथ प्रोजेक्ट सिंक करें

Google Play सेवाएँ आरंभ करें

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

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

  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()
        }
    }
    

अगले कदम