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

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

मशीन लर्निंग के साथ ऑब्जेक्ट डिटेक्शन

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

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

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

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

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

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

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

  1. git रिपॉजिटरी को क्लोन करें
    git clone https://github.com/android/camera-samples.git
    
  2. स्पैस चेकआउट का उपयोग करने के लिए अपने गिट इंस्टेंस को कॉन्फ़िगर करें, ताकि आपके पास ऑब्जेक्ट डिटेक्शन उदाहरण ऐप के लिए केवल फाइलें हों:

    cd camera-samples
    git sparse-checkout init --cone
    git sparse-checkout set CameraXAdvanced
    

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

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

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

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

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

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

  1. प्रोजेक्ट निर्देशिका में build.gradle फ़ाइल खोलें।
  2. Android टूल संस्करण को इस प्रकार बदलें:

    // from:
    classpath 'com.android.tools.build:gradle:4.2.2'
    // to:
    classpath 'com.android.tools.build:gradle:4.1.2'
    
  3. प्रोजेक्ट को सिलेक्ट करके सिंक करें: File > Sync Project with Gradle Files

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

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

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

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

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

ऑब्जेक्ट डिटेक्शन मशीन लर्निंग मॉडल के निष्पादन को सक्षम करने के लिए उदाहरण ऐप कई TensorFlow लाइट लाइब्रेरी का उपयोग करता है:

  • TensorFlow Lite मुख्य पुस्तकालय - आवश्यक डेटा इनपुट कक्षाएं, मशीन लर्निंग मॉडल का निष्पादन और मॉडल प्रसंस्करण से आउटपुट परिणाम प्रदान करता है।
  • TensorFlow Lite सपोर्ट लाइब्रेरी - यह लाइब्रेरी कैमरे से छवियों को TensorImage डेटा ऑब्जेक्ट में अनुवाद करने के लिए एक सहायक वर्ग प्रदान करती है जिसे मशीन लर्निंग मॉडल द्वारा संसाधित किया जा सकता है।
  • TensorFlow Lite GPU लाइब्रेरी - यह लाइब्रेरी उपलब्ध होने पर डिवाइस पर GPU प्रोसेसर का उपयोग करके मॉडल निष्पादन में तेजी लाने के लिए समर्थन प्रदान करती है।

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

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

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

    ...
    dependencies {
    ...
        // Tensorflow lite dependencies
        implementation 'org.tensorflow:tensorflow-lite:2.8.0'
        implementation 'org.tensorflow:tensorflow-lite-gpu:2.8.0'
        implementation 'org.tensorflow:tensorflow-lite-support:2.8.0'
    ...
    }
    
  2. Android Studio में, प्रोजेक्ट निर्भरता को चुनकर सिंक करें: File > Sync Project with Gradle Files

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

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

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

  • CameraXAdvanced/tflite/src/main/assets/coco_ssd_mobilenet_v1_1.0_quant.tflite
  • CameraXAdvanced/tflite/src/main/assets/coco_ssd_mobilenet_v1_1.0_labels.txt

सुविधा और कोड पठनीयता के लिए, उदाहरण एक साथी ऑब्जेक्ट की घोषणा करता है जो मॉडल के लिए सेटिंग्स को परिभाषित करता है।

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

  1. मॉडल के लिए सेटिंग्स को परिभाषित करने के लिए एक साथी ऑब्जेक्ट बनाएं: ( कोड संदर्भ )

    companion object {
       private val TAG = CameraActivity::class.java.simpleName
    
       private const val ACCURACY_THRESHOLD = 0.5f
       private const val MODEL_PATH = "coco_ssd_mobilenet_v1_1.0_quant.tflite"
       private const val LABELS_PATH = "coco_ssd_mobilenet_v1_1.0_labels.txt"
    }
    
  2. एक TensorFlow लाइट इंटरप्रेटर ऑब्जेक्ट बनाने के लिए इस ऑब्जेक्ट की सेटिंग्स का उपयोग करें जिसमें मॉडल शामिल है: ( कोड संदर्भ )

    private val tflite by lazy {
       Interpreter(
           FileUtil.loadMappedFile(this, MODEL_PATH),
           Interpreter.Options().addDelegate(nnApiDelegate))
    }
    

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

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

Interpreter.Options().addDelegate(nnApiDelegate)

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

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

मॉडल को डेटा प्रदान करें

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

मॉडल के लिए आवश्यक टेंसर आकार निर्धारित करने के लिए:

  • अपने मॉडल द्वारा उपयोग किए गए टेंसर के आकार को निर्धारित करने के लिए आरंभिक इंटरप्रेटर ऑब्जेक्ट का उपयोग करें, जैसा कि नीचे दिए गए कोड स्निपेट में दिखाया गया है: ( कोड संदर्भ )

    private val tfInputSize by lazy {
       val inputIndex = 0
       val inputShape = tflite.getInputTensor(inputIndex).shape()
       Size(inputShape[2], inputShape[1]) // Order of axis is: {1, height, width, 3}
    }
    

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

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

एक मॉडल के लिए छवि डेटा बदलने के लिए:

  1. छवि डेटा को एक प्रारूप में बदलने के लिए ऑब्जेक्ट बनाने के लिए सपोर्ट लाइब्रेरी इमेजप्रोसेसर का उपयोग करें जिसे आपका मॉडल भविष्यवाणियों को चलाने के लिए उपयोग कर सकता है: ( कोड संदर्भ )

    private val tfImageProcessor by lazy {
       val cropSize = minOf(bitmapBuffer.width, bitmapBuffer.height)
       ImageProcessor.Builder()
           .add(ResizeWithCropOrPadOp(cropSize, cropSize))
           .add(ResizeOp(
               tfInputSize.height, tfInputSize.width, ResizeOp.ResizeMethod.NEAREST_NEIGHBOR))
           .add(Rot90Op(-imageRotationDegrees / 90))
           .add(NormalizeOp(0f, 1f))
           .build()
    }
    
  2. एंड्रॉइड कैमरा सिस्टम से छवि डेटा की प्रतिलिपि बनाएँ और इसे अपने इमेजप्रोसेसर ऑब्जेक्ट के साथ विश्लेषण के लिए तैयार करें: ( कोड संदर्भ )

    // Copy out RGB bits to the shared buffer
    image.use { bitmapBuffer.copyPixelsFromBuffer(image.planes[0].buffer)  }
    
    // Process the image in Tensorflow
    val tfImage =  tfImageProcessor.process(tfImageBuffer.apply { load(bitmapBuffer) })
    

भविष्यवाणियां चलाएं

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

छवि डेटा के एक सेट पर पूर्वानुमान चलाने के लिए:

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

    // Perform the object detection for the current frame
    val predictions = detector.predict(tfImage)
    
  2. भविष्यवाणियां उत्पन्न करने के लिए छवि डेटा के साथ अपने tflite ऑब्जेक्ट इंस्टेंस पर रन विधि को कॉल करें: ( कोड संदर्भ )

    fun predict(image: TensorImage): List<ObjectPrediction> {
       tflite.runForMultipleInputsOutputs(arrayOf(image.buffer), outputBuffer)
       return predictions
    }
    

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

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

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

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

val predictions get() = (0 until OBJECT_COUNT).map {
   ObjectPrediction(

       // The locations are an array of [0, 1] floats for [top, left, bottom, right]
       location = locations[0][it].let {
           RectF(it[1], it[0], it[3], it[2])
       },

       // SSD Mobilenet V1 Model assumes class 0 is background class
       // in label file and class labels start from 1 to number_of_classes + 1,
       // while outputClasses correspond to class index from 0 to number_of_classes
       label = labels[1 + labelIndices[0][it].toInt()],

       // Score is a single value of [0, 1]
       score = scores[0][it]
   )
}

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

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

अगले कदम

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