Android पर TensorFlow Lite की मदद से, फूलों की पहचान करें

1. परिचय

657431be3173fa86.png android.png

ध्यान दें: इस कोडलैब के लिए, असली डिवाइस पर टेस्ट करना ज़रूरी है

TensorFlow, मशीन लर्निंग का एक ऐसा फ़्रेमवर्क है जिसका इस्तेमाल कई कामों के लिए किया जा सकता है. TensorFlow का इस्तेमाल, क्लाउड में क्लस्टर के बीच बड़े मॉडल को ट्रेन करने से लेकर, आपके फ़ोन जैसे एम्बेड किए गए सिस्टम पर स्थानीय तौर पर मॉडल चलाने तक, कहीं भी किया जा सकता है.

इस कोडलैब में, Android डिवाइस पर इमेज की पहचान करने वाला मॉडल चलाने के लिए, TensorFlow Lite का इस्तेमाल किया गया है.

Android Studio 4.1 या इसके बाद का वर्शन इंस्टॉल करना

अगर आपने Android Studio 4.1 या इसके बाद का वर्शन इंस्टॉल नहीं किया है, तो TensorFlow Lite मॉडल को ट्रेन करते समय, इसे डाउनलोड और इंस्टॉल करें.

आपको क्या सीखने को मिलेगा

आप क्या बनाएंगे

एक सामान्य कैमरा ऐप्लिकेशन. यह ऐप्लिकेशन, फूलों की पहचान करने के लिए, TensorFlow की मदद से इमेज की पहचान करने वाला प्रोग्राम चलाता है.

f11c2821f2c8311d.png

लाइसेंस: इस्तेमाल करने के लिए कोई शुल्क नहीं

2. Colab का इस्तेमाल करके, फूलों की पहचान करने वाला मॉडल ट्रेन करना

मॉडल की ट्रेनिंग शुरू करने से पहले, Android Studio 4.1 या इसके बाद का वर्शन डाउनलोड और इंस्टॉल करें.

Colab खोलें. इसमें बताया गया है कि TensorFlow Lite ट्रांसफ़र लर्निंग का इस्तेमाल करके, फूलों की पहचान करने के लिए, Keras की मदद से क्लासिफ़ायर को कैसे ट्रेन किया जाता है.

3. वर्किंग डायरेक्ट्री सेट अप करना

Git डेटा स्टोर करने की जगह को क्लोन करना

इस कोडलैब के लिए ज़रूरी फ़ाइलों वाली Git डेटा स्टोर करने की जगह को क्लोन करने के लिए, यह कमांड इस्तेमाल करें:

git clone https://github.com/hoitab/TFLClassify.git

इसके बाद, उस डायरेक्ट्री पर जाएं जहां आपने डेटा स्टोर करने की जगह को क्लोन किया है. इस कोडलैब के बाकी हिस्से के लिए, आपको इस डायरेक्ट्री में काम करना होगा:

cd TFLClassify

4. Android के लिए, बुनियादी ढांचे वाला ऐप्लिकेशन सेट अप करना

android.png

Android Studio 4.1 या इसके बाद का वर्शन इंस्टॉल करना

अगर आपने Android Studio 4.1 या इसके बाद का वर्शन इंस्टॉल नहीं किया है, तो इसे इंस्टॉल करें.

Android Studio से प्रोजेक्ट खोलना

Android Studio से कोई प्रोजेक्ट खोलने के लिए, यह तरीका अपनाएं:

  1. Android Studio खोलें 7f2480ded53a193b.png. इसके लोड होने के बाद, इस पॉप-अप में "मौजूदा प्रोजेक्ट खोलें" को चुनें:

f3b8bea7e3b39376.png

  1. फ़ाइल सिलेक्टर में, अपनी वर्किंग डायरेक्ट्री से TFLClassify/build.gradle चुनें.
  1. प्रोजेक्ट को पहली बार खोलने पर, आपको "Gradle सिंक करें" पॉप-अप दिखेगा. इसमें gradle रैपर का इस्तेमाल करने के बारे में पूछा जाएगा. "ठीक है" पर क्लिक करें.

d68b4d7189e6c1e4.png

  1. अगर आपने पहले से डेवलपर मॉडल और यूएसबी डीबगिंग की सुविधा चालू नहीं की है, तो अपने फ़ोन पर इन्हें चालू करें. यह एक बार किया जाने वाला सेटअप है. इन निर्देशों का पालन करें.
  2. प्रोजेक्ट और फ़ोन, दोनों के तैयार हो जाने के बाद, इन्हें असली डिवाइस पर चलाया जा सकता है. इसके लिए, TFL_Classify.start को चुनें और टूलबार पर मौजूद, रन बटन 86934b7b01ad7565.png दबाएं:

60a77ef126c1373d.png

  1. अब Tensorflow डेमो को अपना कैमरा ऐक्सेस करने की अनुमति दें:

b63cba02bb36b7e3.png

  1. आपको अपने फ़ोन पर यह स्क्रीन दिखेगी. इसमें असली नतीजे दिखने की जगह, रैंडम नंबर दिखेंगे.

82c603596afa35f1.png

5. Android ऐप्लिकेशन में TensorFlow Lite जोड़ना

  1. बाईं ओर मौजूद प्रोजेक्ट एक्सप्लोरर में, start मॉड्यूल चुनें:

cede7f2b8b23c1a7.png

  1. start मॉड्यूल पर राइट क्लिक करें या File पर क्लिक करें. इसके बाद, New > Other > TensorFlow Lite Model पर क्लिक करें

bf243d9fdd27e20a.png

  1. मॉडल की उस जगह को चुनें जहां आपने पहले, कस्टम तरीके से ट्रेन किया गया FlowerModel.tflite डाउनलोड किया था.

cfee18cc6674a408.png

  1. Finish पर क्लिक करें.
  2. आपको आखिर में यह दिखेगा. FlowerModel.tflite को इंपोर्ट कर लिया गया है. इसमें मॉडल के बारे में सामान्य जानकारी दिखती है. जैसे, इनपुट / आउटपुट के साथ-साथ, शुरू करने के लिए कुछ सैंपल कोड भी दिखते हैं.

82840065f0d59def.png

6. ज़रूरी नहीं है: टू-डू लिस्ट देखना

टू-डू लिस्ट की मदद से, उस जगह पर आसानी से जाया जा सकता है जहां आपको कोडलैब को अपडेट करना है. इसका इस्तेमाल, Android प्रोजेक्ट में भी किया जा सकता है, ताकि आपको आने वाले समय में किए जाने वाले काम के बारे में याद दिलाया जा सके. कोड के लिए टिप्पणियां इस्तेमाल करके, टू-डू आइटम जोड़े जा सकते हैं. इसके लिए, TODO कीवर्ड टाइप करें. TODO की सूची ऐक्सेस करने के लिए:

  1. यह देखने के लिए कि हम क्या करने वाले हैं, TODO की सूची देखें. इसके लिए, सबसे ऊपर मौजूद मेन्यू बार में जाकर, View > Tool Windows > TODO को चुनें

5de29b413574f25c.png

  1. डिफ़ॉल्ट रूप से, इसमें सभी मॉड्यूल में मौजूद सभी TODO दिखते हैं. इस वजह से, यह थोड़ी भ्रमित करने वाली हो सकती है. सिर्फ़ स्टार्ट TODO को क्रम से लगाने के लिए, TODO पैनल के साइड में मौजूद, ग्रुप के हिसाब से क्रम में लगाएं बटन पर क्लिक करें और Modules को चुनें

5d8fe7b102340208.png

  1. स्टार्ट मॉड्यूल में मौजूद सभी आइटम की सूची को बड़ा करें:

8d0f14a039995b20.png

7. TensorFlow Lite की मदद से, कस्टम मॉडल चलाना

  1. TODO की सूची में, TODO 1 पर क्लिक करें या MainActivity.kt फ़ाइल खोलें और TODO 1 ढूंढें. इसके बाद, यह लाइन जोड़कर मॉडल को शुरू करें:
private class ImageAnalyzer(ctx: Context, private val listener: RecognitionListener) :
        ImageAnalysis.Analyzer {

  ...
  // TODO 1: Add class variable TensorFlow Lite Model
  private val flowerModel = FlowerModel.newInstance(ctx)

  ...
}
  1. CameraX Analyzer के लिए, analyze तरीके में, हमें कैमरे के इनपुट ImageProxy को Bitmap में बदलना होगा. साथ ही, अनुमान की प्रोसेस के लिए, TensorImage ऑब्जेक्ट बनाना होगा.
override fun analyze(imageProxy: ImageProxy) {
  ...
  // TODO 2: Convert Image to Bitmap then to TensorImage
  val tfImage = TensorImage.fromBitmap(toBitmap(imageProxy))
  ...
}
  1. इमेज को प्रोसेस करें और नतीजे पर ये कार्रवाइयां करें:
  • score एट्रिब्यूट में, संभावना के हिसाब से नतीजों को घटते क्रम में लगाएं. इसमें सबसे ज़्यादा संभावना वाले नतीजे सबसे पहले दिखेंगे.
  • MAX_RESULT_DISPLAY कॉन्स्टैंट के हिसाब से, सबसे ऊपर के k नतीजे लें. ज़्यादा या कम नतीजे पाने के लिए, इस वैरिएबल की वैल्यू को बदला जा सकता है.
override fun analyze(imageProxy: ImageProxy) {
  ...
  // TODO 3: Process the image using the trained model, sort and pick out the top results
  val outputs = flowerModel.process(tfImage)
      .probabilityAsCategoryList.apply {
          sortByDescending { it.score } // Sort with highest confidence first
      }.take(MAX_RESULT_DISPLAY) // take the top results

  ...
}
  1. क्रम से लगाए गए और फ़िल्टर किए गए नतीजों को, डेटा ऑब्जेक्ट Recognition में बदलें. इन्हें RecyclerView डेटा बाइंडिंग की मदद से, इस्तेमाल कर सकता है:
override fun analyze(imageProxy: ImageProxy) {
  ...
  // TODO 4: Converting the top probability items into a list of recognitions
  for (output in outputs) {
      items.add(Recognition(output.label, output.score))
  }
  ...
}
  1. इन लाइनों पर टिप्पणी करें या इन्हें मिटा दें. इनकी मदद से, नकली नतीजे जनरेट होते हैं, जो हमें पहले दिखते थे:
// START - Placeholder code at the start of the codelab. Comment this block of code out.
for (i in 0..MAX_RESULT_DISPLAY-1){
    items.add(Recognition("Fake label $i", Random.nextFloat()))
}
// END - Placeholder code at the start of the codelab. Comment this block of code out.
  1. असली डिवाइस पर ऐप्लिकेशन चलाएं. इसके लिए, TFL_Classify.start चुनें और टूलबार पर मौजूद, रन बटन 86934b7b01ad7565.png दबाएं:

60a77ef126c1373d.png

  1. आपको अपने फ़ोन पर यह स्क्रीन दिखेगी. इसमें असली नतीजे दिखने की जगह, रैंडम नंबर दिखेंगे:

f11c2821f2c8311d.png

8. ज़रूरी नहीं है: जीपीयू डेलिगेट की मदद से, अनुमान की प्रोसेस को तेज़ करना

TensorFlow Lite, आपके फ़ोन पर अनुमान की प्रोसेस को तेज़ करने के लिए, कई हार्डवेयर ऐक्सेलरेटर के साथ काम करता है. जीपीयू, उन ऐक्सेलरेटर में से एक है जिनका इस्तेमाल TensorFlow Lite, डेलिगेट मैकेनिज़्म की मदद से कर सकता है. इसका इस्तेमाल करना काफ़ी आसान है.

  1. start मॉड्यूल में मौजूद build.gradle खोलें. इसके अलावा, TODO की सूची में मौजूद TODO 5 पर क्लिक करके, यह डिपेंडेंसी जोड़ी जा सकती है:
// TODO 5: Optional GPU Delegates    
implementation 'org.tensorflow:tensorflow-lite-gpu:2.3.0'
  1. MainActivity.kt फ़ाइल पर वापस जाएं या TODO की सूची में मौजूद TODO 6 पर क्लिक करें. flowerModel को शुरू करने के सामान्य तरीके को इससे बदलें: जीपीयू के साथ काम करने वाले डिवाइसों की सूची का इंस्टेंस पाएं और जीपीयू को शुरू करें. यह इस पर निर्भर करता है कि वह सूची में शामिल, जीपीयू के साथ काम करने वाले डिवाइसों में से एक है या नहीं. अगर ऐसा नहीं है, तो मॉडल को चलाने के लिए, चार सीपीयू थ्रेड शुरू करें:
private class ImageAnalyzer(ctx: Context, private val listener: RecognitionListener) :
        ImageAnalysis.Analyzer {
  ...

  // TODO 1: Add class variable TensorFlow Lite Model
  // Initializing the flowerModel by lazy so that it runs in the same thread when the process
  // method is called.
  private val flowerModel: FlowerModel by lazy{

    // TODO 6. Optional GPU acceleration
    val compatList = CompatibilityList()

    val options = if(compatList.isDelegateSupportedOnThisDevice){
        Log.d(TAG, "This device is GPU Compatible ")
        Model.Options.Builder().setDevice(Model.Device.GPU).build()
    } else {
        Log.d(TAG, "This device is GPU Incompatible ")
        Model.Options.Builder().setNumThreads(4).build()
    }

  ...
}
  1. मॉडल के इनिशियलाइज़र को इसका इस्तेमाल करने के लिए बदलें. इसके लिए, तरीके के इनपुट में options जोड़ें:
private class ImageAnalyzer(ctx: Context, private val listener: RecognitionListener) :
        ImageAnalysis.Analyzer {

  private val flowerModel: FlowerModel by lazy{

    ...

    // Initialize the Flower Model
    FlowerModel.newInstance(ctx, options)
  }
}
  1. असली डिवाइस पर ऐप्लिकेशन चलाएं. इसके लिए, TFL_Classify.start चुनें और टूलबार पर मौजूद, रन बटन 86934b7b01ad7565.png दबाएं:

60a77ef126c1373d.png

9. आगे क्या करें?

ज़्यादा जानकारी के लिए, यहां कुछ लिंक दिए गए हैं:

  • tfhub.dev से, एमएल मॉडल बाइंडिंग के साथ काम करने वाले अन्य TFLite मॉडल आज़माएं.
  • tensorflow.org पर मौजूद दस्तावेज़ों और कोड रेपो से, TFLite के बारे में ज़्यादा जानें.
  • TFLite के कुछ अन्य पहले से ट्रेन किए गए मॉडल आज़माएं. इनमें, स्पीच हॉटवर्ड डिटेक्टर और स्मार्ट-रिप्लाई का ऑन-डिवाइस वर्शन शामिल है.
  • शुरू करने के लिए बने हमारे दस्तावेज़ों की मदद से, TensorFlow के बारे में ज़्यादा जानें.