इस पेज का अनुवाद Cloud Translation API से किया गया है.

TensorFlow Lite (Android) की मदद से, कस्टम ऑब्जेक्ट का पता लगाने वाला मॉडल बनाना और उसे डिप्लॉय करना

1. शुरू करने से पहले

इस कोडलैब में, आप TFLite मॉडल मेकर की मदद से ट्रेनिंग इमेज के सेट का इस्तेमाल करके, कस्टम ऑब्जेक्ट डिटेक्शन मॉडल को ट्रेनिंग देने का तरीका जानेंगे. इसके बाद, TFLite टास्क लाइब्रेरी का इस्तेमाल करके, अपने मॉडल को Android ऐप्लिकेशन में डिप्लॉय करेंगे. आप:

ऐसा Android ऐप्लिकेशन बनाएं जो खाने की इमेज में मौजूद सामग्री की पहचान करता हो.
TFLite से पहले से प्रशिक्षित ऑब्जेक्ट का पता लगाने वाले मॉडल को इंटिग्रेट करें. साथ ही, देखें कि मॉडल किस तरह का पता लगा सकता है.
सलाद और TFLite मॉडल मेकर नाम के कस्टम डेटासेट का इस्तेमाल करके, फ़ूड के कॉम्पोनेंट का पता लगाने के लिए, कस्टम ऑब्जेक्ट डिटेक्शन मॉडल को ट्रेनिंग दें.
TFLite टास्क लाइब्रेरी का इस्तेमाल करके, Android ऐप्लिकेशन में कस्टम मॉडल को डिप्लॉय करें.

आखिर में, आप नीचे दी गई इमेज से मिलती-जुलती कुछ इमेज बनाएंगे:

ज़रूरी शर्तें

यह कोडलैब ऐसे मोबाइल डेवलपर के लिए डिज़ाइन किया गया है जो मशीन लर्निंग का इस्तेमाल करना चाहते हैं. आपको इनके बारे में पता होना चाहिए:

Kotlin और Android Studio का इस्तेमाल करके Android डेवलपमेंट
बुनियादी Python सिंटैक्स

आप क्या #39;जानेंगे

TFLite मॉडल मेकर का इस्तेमाल करके, कस्टम ऑब्जेक्ट डिटेक्शन मॉडल को ट्रेनिंग देने का तरीका.
TFLite टास्क लाइब्रेरी का इस्तेमाल करके, TFLite ऑब्जेक्ट डिटेक्शन मॉडल को डिप्लॉय करने का तरीका.

आपको इनकी ज़रूरत होगी

Android Studio का नया वर्शन (v4.2+)
Android Studio एम्युलेटर या फ़िज़िकल Android डिवाइस
सैंपल कोड
Kotlin में Android डेवलपमेंट की बुनियादी जानकारी

2. ऑब्जेक्ट की पहचान

ऑब्जेक्ट का पता लगाना, कंप्यूटर दृष्टि वाले टास्क का एक सेट है, जो डिजिटल इमेज में ऑब्जेक्ट का पता लगा सकता है और उन्हें ढूंढ सकता है. किसी इमेज या वीडियो स्ट्रीम को देखते हुए, ऑब्जेक्ट का पता लगाने वाला मॉडल यह पहचान कर सकता है कि ऑब्जेक्ट का कौनसा सेट मौजूद है और इमेज में उनकी क्या स्थिति है.

Tenor हालांकि, हो सकता है कि आपको ज़्यादा खास या ऑफ़बीट कैटगरी में ऑब्जेक्ट का पता लगाना हो या आपको ऐसा करना पड़े. इसके लिए, आपको अपनी ट्रेनिंग की इमेज इकट्ठा करने और उसके बाद अपने आप पहचान करने वाले मॉडल को डिप्लॉय करने की ज़रूरत होगी.

TensorFlow Lite

TensorFlow Lite एक क्रॉस-प्लैटफ़ॉर्म मशीन लर्निंग लाइब्रेरी है, जिसे Android और iOS मोबाइल डिवाइसों के साथ-साथ, एज डिवाइस पर मशीन लर्निंग मॉडल चलाने के लिए ऑप्टिमाइज़ किया गया है.

TensorFlow Lite असल में ML Kit में मौजूद मुख्य इंजन है, जिसका इस्तेमाल मशीन लर्निंग मॉडल को चलाने के लिए किया जाता है. TensorFlow Lite नेटवर्क में दो कॉम्पोनेंट हैं, जो मोबाइल डिवाइस पर मशीन लर्निंग मॉडल को ट्रेनिंग और डिप्लॉय करना आसान बनाते हैं:

Model Maker एक Python लाइब्रेरी है जो कोड की कुछ लाइनों की मदद से TensorFlow Lite के मॉडल को ट्रेनिंग देना आसान बनाती है. इसके लिए, किसी मशीन लर्निंग की ज़रूरत नहीं होती.
Task Library क्रॉस-प्लैटफ़ॉर्म लाइब्रेरी है. इसकी मदद से, मोबाइल ऐप्लिकेशन में TensorFlow Lite के कुछ मॉडल की मदद से, आसानी से डिप्लॉय किया जा सकता है.

यह कोडलैब TFLite पर फ़ोकस करता है. ऐसे कॉन्सेप्ट और कोड ब्लॉक जो TFLite से काम के नहीं हैं और ऑब्जेक्ट का पता नहीं लगाते हैं. इस बारे में पूरी जानकारी नहीं दी जाती है. साथ ही, इन्हें आसानी से कॉपी करके चिपकाने के लिए कहा जाता है.

3. सेट अप करें

कोड डाउनलोड करें

इस कोडलैब के सभी कोड डाउनलोड करने के लिए, इस लिंक पर क्लिक करें:

डाउनलोड की गई zip फ़ाइल को अनपैक करें. यह एक रूट फ़ोल्डर (odml-pathways-main) को ज़रूरत के मुताबिक सभी संसाधनों से अनपैक कर देगा. इस कोडलैब के लिए, आपको सिर्फ़ object-detection/codelab2/android सबडायरेक्ट्री के सोर्स की ज़रूरत होगी.

object-detection/codelab2/android रिपॉज़िटरी में android सबडायरेक्ट्री में दो डायरेक्ट्री होती हैं:

स्टार्टर—इस कोडलैब के लिए बनाया गया शुरुआती कोड.
फ़ाइनल—खत्म हो चुके सैंपल ऐप्लिकेशन के लिए पूरा कोड.

स्टार्टर ऐप्लिकेशन इंपोर्ट करना

Android Studio में स्टार्टर ऐप्लिकेशन इंपोर्ट करके, शुरू करें'

Android Studio खोलें और प्रोजेक्ट इंपोर्ट करें (Gradle, Eclipse ADT वगैरह) चुनें.
पहले डाउनलोड किए गए सोर्स कोड से starter फ़ोल्डर खोलें.

यह पक्का करने के लिए कि आपके ऐप्लिकेशन में सभी डिपेंडेंसी उपलब्ध हों, आपको प्रोजेक्ट को Gradle फ़ाइलों के साथ सिंक करना चाहिए. ऐसा तब करें, जब इंपोर्ट की प्रोसेस पूरी हो जाए.

Android Studio टूलबार से प्रोजेक्ट प्रोजेक्ट को Gradle फ़ाइलों के साथ सिंक करें () चुनें. starter/app/build.gradle इंपोर्ट करें

स्टार्टर ऐप्लिकेशन चलाना

अब जब आपने Android Studio में प्रोजेक्ट इंपोर्ट कर लिया है, तो आप #39;पहली बार ऐप्लिकेशन चलाने के लिए तैयार हैं.

अपने Android डिवाइस को यूएसबी की मदद से कंप्यूटर से कनेक्ट करें या Android Studio का एम्युलेटर खोलें. इसके बाद, Android Studio टूलबार में चलाएं () पर क्लिक करें.

4. स्टार्टर ऐप्लिकेशन को समझना

इस कोडलैब को आसान बनाने के लिए और मशीन लर्निंग बिट पर फ़ोकस करने के लिए, स्टार्टर ऐप्लिकेशन में कुछ ऐसे बॉयलरप्लेट कोड होते हैं जो आपके लिए कुछ काम करते हैं:

यह डिवाइस के कैमरे का इस्तेमाल करके, फ़ोटो ले सकता है.
इसमें कुछ स्टॉक इमेज होती हैं, जिन्हें आप Android एम्युलेटर पर ऑब्जेक्ट का पता लगाने के लिए आज़मा सकते हैं.
इनपुट बिट मैप पर ऑब्जेक्ट की पहचान का नतीजा निकालने के लिए, यह एक आसान तरीका है.

आप ऐप्लिकेशन के कंकाल में ज़्यादातर इन तरीकों से इंटरैक्ट करेंगे:

fun runObjectDetection(bitmap: Bitmap) यह तरीका तब कहा जाता है, जब आप पहले से तय की गई इमेज चुनते हैं या फ़ोटो लेते हैं. bitmap, ऑब्जेक्ट का पता लगाने के लिए इनपुट इमेज है. इस कोडलैब के बाद में, आप इस तरीके में ऑब्जेक्ट का पता लगाने वाला कोड जोड़ेंगे.
data class DetectionResult(val boundingBoxes: Rect, val text: String) यह एक डेटा क्लास है जो विज़ुअलाइज़ेशन के लिए ऑब्जेक्ट की पहचान का नतीजा दिखाती है. boundingBoxes वह आयत है जहां ऑब्जेक्ट मौजूद होता है. text, ऑब्जेक्ट और # बाउंडिंग बॉक्स के साथ दिखाने के लिए पहचान नतीजे वाली स्ट्रिंग होती है.
fun drawDetectionResult(bitmap: Bitmap, detectionResults: List<DetectionResult>): Bitmap यह तरीका, इनपुट bitmap पर detectionResults में ऑब्जेक्ट की पहचान के नतीजे दिखाता है और उसकी बदली गई कॉपी दिखाता है.

यहां, drawDetectionResult उपयोगिता के तरीके के आउटपुट का एक उदाहरण दिया गया है.

5. डिवाइस पर ऑब्जेक्ट की पहचान करें

अब आप पहले से प्रशिक्षित TFLite मॉडल को जोड़कर एक प्रोटोटाइप बनाएंगे, जो स्टार्टर ऐप्लिकेशन में सामान्य ऑब्जेक्ट का पता लगा सकता है.

T-Lite ऑब्जेक्ट की पहचान करने वाला मॉडल पहले से डाउनलोड करना

TensorFlow Hub पर कई ऑब्जेक्ट डिटेक्टर मॉडल हैं जिनका आप इस्तेमाल कर सकते हैं. इस कोडलैब के लिए, आप &CO

इसके बाद, अपने स्टार्टर ऐप्लिकेशन में पहले से प्रशिक्षित TFLite मॉडल को इंटिग्रेट करने के लिए, TFLite टास्क लाइब्रेरी का इस्तेमाल करें. TFLite टास्क लाइब्रेरी की मदद से, मोबाइल के लिए सही मशीन लर्निंग मॉडल को मोबाइल ऐप्लिकेशन में इंटिग्रेट किया जा सकता है. यह, मशीन लर्निंग के कई लोकप्रिय मामलों के साथ काम करता है, जैसे कि ऑब्जेक्ट का पता लगाना, इमेज की कैटगरी तय करना, और टेक्स्ट की कैटगरी तय करना. आप TFLite मॉडल को लोड कर सकते हैं और उसे कोड की कुछ लाइनों के साथ चला सकते हैं.

स्टार्टर ऐप्लिकेशन में मॉडल जोड़ना

वह मॉडल कॉपी करें जिसे आपने अभी-अभी स्टार्टर ऐप्लिकेशन के assets फ़ोल्डर में डाउनलोड किया है. आप Android Studio में प्रोजेक्ट नेविगेशन पैनल में इस फ़ोल्डर को देख सकते हैं.

फ़ाइल को model.tflite नाम दें.

Gradle फ़ाइल टास्क लाइब्रेरी के डिपेंडेंसी अपडेट करना

app/build.gradle फ़ाइल पर जाएं और इस लाइन को dependencies कॉन्फ़िगरेशन में जोड़ें:

implementation 'org.tensorflow:tensorflow-lite-task-vision:0.3.1'

अपने प्रोजेक्ट को Gradle फ़ाइलों के साथ सिंक करना

यह पक्का करने के लिए कि आपके ऐप्लिकेशन में सभी डिपेंडेंसी उपलब्ध हैं, आपको अपने प्रोजेक्ट को Gradle फ़ाइलों के साथ इस समय सिंक करना चाहिए. Android Studio टूलबार से प्रोजेक्ट प्रोजेक्ट को Gradle फ़ाइलों के साथ सिंक करें ( ) चुनें.

(अगर यह बटन बंद है, तो पक्का करें कि आप सिर्फ़ स्टार्टर/app/build.gradle को इंपोर्ट करें, पूरे रिपॉज़िटरी को नहीं.)

किसी इमेज पर डिवाइस में मौजूद ऑब्जेक्ट की पहचान सेट अप करना और उसे चलाना

ऑब्जेक्ट की पहचान करने वाले किसी मॉडल को लोड और चलाने के लिए, तीन एपीआई वाले सिर्फ़ तीन आसान चरण हैं:

कोई इमेज / स्ट्रीम तैयार करें: TensorImage
पहचान करने वाला ऑब्जेक्ट बनाएं: ObjectDetector
ऊपर दिए गए दो ऑब्जेक्ट को कनेक्ट करें: detect(image)

आप इन्हें MainActivity.kt फ़ाइल में runObjectDetection(bitmap: Bitmap) फ़ंक्शन के अंदर हासिल करते हैं.

/**
* TFLite Object Detection Function
*/
private fun runObjectDetection(bitmap: Bitmap) {
    //TODO: Add object detection code here
}

फ़िलहाल, फ़ंक्शन खाली है. TFLite ऑब्जेक्ट डिटेक्टर को लागू करने के लिए, नीचे दिया गया तरीका अपनाएं. साथ ही, Android Studio आपसे ज़रूरी इंपोर्ट जोड़ने का संकेत देगा:

org.tensorflow.lite.support.image.TensorImage
org.tensorflow.lite.task.vision.detector.ObjectDetector

इमेज ऑब्जेक्ट बनाएं

आप इस कोडलैब के लिए जिन इमेज का इस्तेमाल करेंगे वे या तो डिवाइस में मौजूद कैमरे से ली जाएंगी. इसके अलावा, पहले से चुनी गई इमेज को ऐप्लिकेशन और यूज़र इंटरफ़ेस (यूआई) में चुना जाएगा. इनपुट इमेज को Bitmap फ़ॉर्मैट में डिकोड करके runObjectDetection तरीके में पास किया जाता है.

TFLite, TensorImage को Bitmap से बनाने के लिए एक आसान एपीआई उपलब्ध कराता है. नीचे runObjectDetection(bitmap:Bitmap) में सबसे ऊपर दिया गया कोड जोड़ें:

// Step 1: create TFLite's TensorImage object
val image = TensorImage.fromBitmap(bitmap)

पहचानने वाला इंस्टेंस बनाना

TFLite टास्क लाइब्रेरी, बिल्डर डिज़ाइन पैटर्न का पालन करती है. आप कॉन्फ़िगरेशन को बिल्डर में भेजते हैं, फिर उससे डिटेक्टर हासिल करते हैं. कॉन्फ़िगर करने के कई विकल्प हैं. इनमें ऑब्जेक्ट डिटेक्टर की संवेदनशीलता को कम या ज़्यादा करना शामिल है:

ज़्यादा से ज़्यादा नतीजा (ऑब्जेक्ट की वह ज़्यादा से ज़्यादा संख्या जिसे मॉडल को पता लगाना चाहिए)
स्कोर थ्रेशोल्ड (किसी ऑब्जेक्ट का पता लगाने वाले ऑब्जेक्ट को रिटर्न करने के लिए ऑब्जेक्ट डिटेक्टर को कितना भरोसा होना चाहिए)
लेबल की अनुमति वाली सूची/अस्वीकार की गई सूची (पहले से तय सूची में चीज़ों को अनुमति देना या अस्वीकार करना)

TFLite मॉडल फ़ाइल के नाम और कॉन्फ़िगरेशन विकल्पों की जानकारी देकर ऑब्जेक्ट का पता लगाने वाले इंस्टेंस को शुरू करें:

// Step 2: Initialize the detector object
val options = ObjectDetector.ObjectDetectorOptions.builder()
    .setMaxResults(5)
    .setScoreThreshold(0.5f)
    .build()
val detector = ObjectDetector.createFromFileAndOptions(
    this, // the application context
    "model.tflite", // must be same as the filename in assets folder
    options
)

पहचानने वाले को इमेज का फ़ीड करना

fun runObjectDetection(bitmap:Bitmap) में यह कोड जोड़ें. इससे आपकी इमेज, पहचानने वाले टूल को फ़ीड कर दी जाएंगी.

// Step 3: feed given image to the model and print the detection result
val results = detector.detect(image)

काम पूरा होने पर, पहचान करने वाला Detection की सूची दिखाता है. हर सूची में उस ऑब्जेक्ट की जानकारी होती है जो मॉडल को इमेज में मिली है. हर ऑब्जेक्ट के साथ:

boundingBox: इमेज में मौजूद ऑब्जेक्ट और उसकी जगह के बारे में जानकारी देने वाला आयत
categories: यह किस तरह का ऑब्जेक्ट है और यह पहचान करने के नतीजे पर कितना भरोसा करता है. यह मॉडल कई श्रेणियों को दिखाता है और सबसे ज़्यादा भरोसेमंद है.
label: ऑब्जेक्ट की कैटगरी का नाम.
classificationConfidence:0, 0.0 से 1.0 के बीच का फ़्लोट, 1.0 100% का प्रतिनिधित्व करता है

पहचान करने के नतीजे प्रिंट करना

fun runObjectDetection(bitmap:Bitmap) में यह कोड जोड़ें. इससे ऑब्जेक्ट को पहचानने के नतीजों को लॉगकैट में प्रिंट करने के तरीके को कॉल किया जाता है.

// Step 4: Parse the detection result and show it
debugPrint(results)

फिर इस debugPrint()तरीका को MainActivity क्लास में जोड़ें:

private fun debugPrint(results : List<Detection>) {
    for ((i, obj) in results.withIndex()) {
        val box = obj.boundingBox

        Log.d(TAG, "Detected object: ${i} ")
        Log.d(TAG, "  boundingBox: (${box.left}, ${box.top}) - (${box.right},${box.bottom})")

        for ((j, category) in obj.categories.withIndex()) {
            Log.d(TAG, "    Label $j: ${category.label}")
            val confidence: Int = category.score.times(100).toInt()
            Log.d(TAG, "    Confidence: ${confidence}%")
        }
    }
}

अब आपका ऑब्जेक्ट पहचानने वाला टूल तैयार है! Android Studio टूलबार में चलाएं ( ) पर क्लिक करके ऐप्लिकेशन को कंपाइल करें और चलाएं. डिवाइस पर ऐप्लिकेशन दिखने के बाद, ऑब्जेक्ट की पहचान करने वाले टूल को शुरू करने के लिए पहले से तय किसी भी इमेज पर टैप करें. इसके बाद, अपने आईडीई में Logcat विंडो*(* *)* देखें और आपको इससे मिलता-जुलता कुछ दिखेगा:

D/TFLite-ODT: Detected object: 0 
D/TFLite-ODT:   boundingBox: (0.0, 15.0) - (2223.0,1645.0)
D/TFLite-ODT:     Label 0: dining table
D/TFLite-ODT:     Confidence: 77%
D/TFLite-ODT: Detected object: 1 
D/TFLite-ODT:   boundingBox: (702.0, 3.0) - (1234.0,797.0)
D/TFLite-ODT:     Label 0: cup
D/TFLite-ODT:     Confidence: 69%

इससे आपको पता चलता है कि पहचानकर्ता ने दो ऑब्जेक्ट देखे. पहला है:

कोई ऑब्जेक्ट (0, 15) – (2223, 1645) के आयत के अंदर है
लेबल डाइनिंग टेबल है
मॉडल को पूरा भरोसा है कि पहली डाइनिंग टेबल है (77%)

तकनीकी रूप से, आपको बस इतना करना है कि आप TFLite टास्क लाइब्रेरी का इस्तेमाल कर सकें: फ़िलहाल, यह सब आपके पास है! बधाई हो!

हालांकि, यूज़र इंटरफ़ेस (यूआई) के साइड पर आप अब भी शुरुआत में हैं. अब आपको मिले हुए नतीजों को प्रोसेस करने के लिए, यूज़र इंटरफ़ेस (यूआई) पर, पहचाने गए नतीजों का इस्तेमाल करना होगा.

6. इनपुट इमेज पर पहचान परिणाम निकालें

पिछले चरण में, आपने पहचान नतीजे को logcat में प्रिंट कर दिया था: आसान और तेज़. इस चरण में, आप स्टार्टर ऐप्लिकेशन में अपने लिए पहले से लागू उपयोगिता मोड का इस्तेमाल करेंगे, ताकि:

इमेज पर बाउंडिंग बॉक्स बनाएं
बाउंडिंग बॉक्स के अंदर कोई कैटगरी नाम और कॉन्फ़िडेंस प्रतिशत बनाएं

debugPrint(results) कॉल को इस कोड स्निपेट से बदलें:

val resultToDisplay = results.map {
    // Get the top-1 category and craft the display text
    val category = it.categories.first()
    val text = "${category.label}, ${category.score.times(100).toInt()}%"

    // Create a data object to display the detection result
    DetectionResult(it.boundingBox, text)
}
// Draw the detection result on the bitmap and show it.
val imgWithResult = drawDetectionResult(bitmap, resultToDisplay)
runOnUiThread {
    inputImageView.setImageBitmap(imgWithResult)
}

ध्यान दें: ऑब्जेक्ट की पहचान करने का तरीका, एक जटिल इंटेसिव प्रोसेस है और TFLite टास्क लाइब्रेरी उसी थ्रेड पर चलती है जिस पर इसे कॉल किया जाता है. इसलिए, ऐप्लिकेशन को ब्लॉक करने से बचने के लिए, इसे बैकग्राउंड थ्रेड पर चलाना ज़रूरी है. आप देख सकते हैं कि हम runObjectDetection तरीके को कॉल करने के लिए, Kotlin कोरूटीन इस्तेमाल करते हैं

lifecycleScope.launch(Dispatchers.Default) { runObjectDetection(bitmap) }

अब Android Studio टूलबार में चलाएं ( ) पर क्लिक करें.
ऐप्लिकेशन के लोड होने के बाद, पहचान के नतीजे देखने के लिए पहले से सेट की गई किसी इमेज पर टैप करें.

क्या आप अपनी फ़ोटो आज़माना चाहते हैं? फ़ोटो लें बटन पर टैप करें और अपने आस-पास मौजूद चीज़ों की कुछ तस्वीरें कैप्चर करें.

7. कस्टम ऑब्जेक्ट का पता लगाने वाले मॉडल को ट्रेनिंग देना

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

यहां एक डेटासेट है, जिसमें इमेज और लेबल हैं. इनका इस्तेमाल करके आप अपने कस्टम मॉडल की ट्रेनिंग कर सकते हैं. इसे ओपन इमेज डेटासेट V4 से इमेज का इस्तेमाल करके बनाया गया था.

Colaboratory

इसके बाद, कस्टम मॉडल को ट्रेनिंग देने के लिए, Google Colab पर जाएं.

अगर आप #39;अनजान हैं, तो Google Colaboratory या Colab एक इंटरैक्टिव एनवायरमेंट है. इसकी मदद से, कोड लिखा जा सकता है और उसे एक्ज़ीक्यूट किया जा सकता है. मशीन लर्निंग कम्यूनिटी में Colab का ज़्यादा इस्तेमाल किया जाता है. Colab की मदद से, आप किसी इमेज डेटासेट को इंपोर्ट कर सकते हैं, उस पर इमेज की कैटगरी तय करने का काम सीख सकते हैं, और मॉडल का आकलन कर सकते हैं.

Colab नोटबुक, Google के क्लाउड सर्वर पर कोड एक्ज़ीक्यूट करती हैं. इसका मतलब है कि आप जीपीयू और टीपीयू समेत Google हार्डवेयर की शक्ति का फ़ायदा ले सकते हैं, भले ही आपकी मशीन का पावर कुछ भी हो. आपको सिर्फ़ एक ब्राउज़र की ज़रूरत है.

अगर आप Colab ऐक्सेस नहीं कर पा रहे हैं, तो आप इस GitHub लिंक की मदद से, किसी दूसरे एनवायरमेंट का इस्तेमाल कर सकते हैं और कोड ऐक्सेस कर सकते हैं.

कस्टम मॉडल को ट्रेनिंग देने में करीब 30 मिनट लगेंगे.

अगर आप जल्दबाज़ी में हैं, तो आप वह मॉडल डाउनलोड कर सकते हैं जिसे हमने आपको दिए गए डेटासेट पर पहले से ट्रेनिंग दी है. इसके बाद, आप अगले चरण पर जा सकते हैं.

8. कस्टम TFLite मॉडल को Android ऐप्लिकेशन के साथ इंटिग्रेट करें

अब आपने सलाद डिटेक्शन मॉडल तैयार किया है, उसे इंटिग्रेट करें, और अपने ऐप्लिकेशन को किसी सामान्य ऑब्जेक्ट की पहचान करने वाले से बदलकर, खास तौर पर सलाद का पता लगाने वाले डिवाइस के तौर पर सेट करें.

सलाद TFLite मॉडल को assets फ़ोल्डर में कॉपी करें. नए मॉडल को नाम दें salad.tflite.

MainActivity.kt फ़ाइल खोलें और ObjectDetector शुरू करने वाला कोड ढूंढें.
efficiencyDet-Lite की इमेज (model.tflite) को सलाद मॉडल (salad.tflite) से बदलें

val detector = ObjectDetector.createFromFileAndOptions(
    this, // the application context
    "salad.tflite", // must be same as the filename in assets folder
    options
)

ऐप्लिकेशन को नए मॉडल के साथ फिर से चलाने के लिए, Android Studio टूलबार में चलाएं ( ) पर क्लिक करें. वाह! ऐप्लिकेशन अब चीज़, सलाद, और बेक किए गए प्रॉडक्ट की पहचान कर सकता है.

अगर आप ऐप्लिकेशन को किसी Android एम्युलेटर में चलाते हैं, तो आप देख सकते हैं कि ऑब्जेक्ट का पता लगाने वाले मॉडल को उसका नतीजा देने में कुछ सेकंड लग सकते हैं. ऐसा इसलिए है, क्योंकि TFLite के संख्या वाले मॉडल को एम्युलेटर पर चलने के लिए ऑप्टिमाइज़ नहीं किया गया है. इसे #39;Google शारीरिक डिवाइस पर ज़्यादा तेज़ी से चलाया जा सकता है.

9. बधाई हो!

आपने TFLite का इस्तेमाल करके, अपने मॉडल को ट्रेनिंग दी है. साथ ही, अपने ऐप्लिकेशन में ऑब्जेक्ट की पहचान करने की काबिलीयत जोड़ी है. बस इतना ही, आपको इसे चालू करके चलाना है!

हमने क्या-क्या शामिल किया है

TensorFlow Hub पर पहले से प्रशिक्षित TFLite ऑब्जेक्ट का पता लगाने वाले मॉडल ढूंढने का तरीका
TFLite टास्क लाइब्रेरी का इस्तेमाल करके, अपने Android ऐप्लिकेशन में ऑब्जेक्ट का पता लगाने वाले मॉडल को इंटिग्रेट करने का तरीका
TFLite मॉडल मेकर के साथ कस्टम ऑब्जेक्ट डिटेक्शन मॉडल को ट्रेनिंग देने का तरीका

अगले चरण

अपने TFLite मॉडल को डिप्लॉय करने के लिए Firebase का इस्तेमाल करें
ट्रेनिंग का डेटा इकट्ठा करके, अपने मॉडल को ट्रेनिंग दें
अपने Android ऐप्लिकेशन में ऑब्जेक्ट की पहचान की सुविधा लागू करें

ज़्यादा जानें

Google की टेक्नोलॉजी के साथ डिवाइस पर मौजूद मशीन लर्निंग