Android पर AutoML से ट्रेनिंग पाने वाले मॉडल की मदद से, इमेज में मौजूद ऑब्जेक्ट पहचानें

AutoML Vision Edge का इस्तेमाल करके, अपना मॉडल ट्रेन करने के बाद, इमेज में ऑब्जेक्ट का पता लगाने के लिए, अपने ऐप्लिकेशन में इसका इस्तेमाल किया जा सकता है.

AutoML Vision Edge से ट्रेन किए गए मॉडल को इंटिग्रेट करने के दो तरीके हैं: मॉडल को अपने ऐप्लिकेशन के ऐसेट फ़ोल्डर में डालकर बंडल किया जा सकता है या Firebase से डाइनैमिक तौर पर डाउनलोड किया जा सकता है.

मॉडल को बंडल करने के विकल्प
आपके ऐप्लिकेशन में शामिल
  • मॉडल आपके ऐप्लिकेशन के APK का हिस्सा है
  • मॉडल तुरंत उपलब्ध हो जाता है. भले ही, Android डिवाइस ऑफ़लाइन हो
  • Firebase प्रोजेक्ट की ज़रूरत नहीं है
Firebase के साथ होस्ट किया गया
  • मॉडल को Firebase मशीन लर्निंग पर अपलोड करके होस्ट करें
  • APK का साइज़ कम करता है
  • मॉडल को मांग पर डाउनलोड किया जाता है
  • अपने ऐप्लिकेशन को फिर से पब्लिश किए बिना, मॉडल के अपडेट को पुश करना
  • Firebase रिमोट कॉन्फ़िगरेशन की मदद से, आसानी से A/B टेस्टिंग करना
  • इसके लिए, Firebase प्रोजेक्ट की ज़रूरत होती है

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

  1. अगर आपको कोई मॉडल डाउनलोड करना है, तो पक्का करें कि आपने अपने Android प्रोजेक्ट में Firebase जोड़ें. अगर आपने पहले से ऐसा नहीं किया है, तो मॉडल को बंडल करते समय ऐसा करना ज़रूरी नहीं है.

  2. अपने मॉड्यूल की ऐप्लिकेशन-लेवल की Gradle फ़ाइल में, TensorFlow Lite Task लाइब्रेरी की डिपेंडेंसी जोड़ें. आम तौर पर, यह फ़ाइल app/build.gradle होती है:

    अपने ऐप्लिकेशन के साथ मॉडल को बंडल करने के लिए:

    dependencies {
  // ...
  // Object detection with a bundled Auto ML model
  implementation 'org.tensorflow:tensorflow-lite-task-vision:0.0.0-nightly-SNAPSHOT'
}

    Firebase से मॉडल को डाइनैमिक तौर पर डाउनलोड करने के लिए, Firebase ML डिपेंडेंसी भी जोड़ें:

    dependencies {
  // ...
  // Object detection with an Auto ML model deployed to Firebase
  implementation platform('com.google.firebase:firebase-bom:26.1.1')
  implementation 'com.google.firebase:firebase-ml-model-interpreter'

  implementation 'org.tensorflow:tensorflow-lite-task-vision:0.0.0-nightly'
}

1. मॉडल लोड करें

लोकल मॉडल सोर्स कॉन्फ़िगर करना

मॉडल को अपने ऐप्लिकेशन के साथ बंडल करने के लिए:

  1. Google Cloud कंसोल से डाउनलोड किए गए ZIP फ़ॉर्मैट वाले संग्रह से मॉडल निकालें.
  2. अपने ऐप्लिकेशन के पैकेज में अपना मॉडल शामिल करें:
    1. अगर आपके प्रोजेक्ट में कोई ऐसेट फ़ोल्डर नहीं है, तो app/ फ़ोल्डर पर राइट क्लिक करने के बाद, नया > फ़ोल्डर > ऐसेट फ़ोल्डर पर क्लिक करके एक ऐसेट फ़ोल्डर बनाएं.
    2. एम्बेड किए गए मेटाडेटा के साथ अपनी tflite मॉडल फ़ाइल को ऐसेट फ़ोल्डर में कॉपी करें.

  3. अपने ऐप्लिकेशन की build.gradle फ़ाइल में ये चीज़ें जोड़ें, ताकि ऐप्लिकेशन बनाते समय Gradle, मॉडल फ़ाइल को कंप्रेस न करे:

    android {
    // ...
    aaptOptions {
        noCompress "tflite"
    }
}

    मॉडल फ़ाइल को ऐप्लिकेशन पैकेज में शामिल किया जाएगा और यह रॉ एसेट के तौर पर उपलब्ध होगी.

Firebase पर होस्ट किए गए मॉडल सोर्स को कॉन्फ़िगर करना

रिमोट तौर पर होस्ट किए गए मॉडल का इस्तेमाल करने के लिए, RemoteModel ऑब्जेक्ट बनाएं. इसमें वह नाम डालें जो आपने मॉडल को पब्लिश करते समय असाइन किया था:

Java

// Specify the name you assigned when you deployed the model.
FirebaseCustomRemoteModel remoteModel =
        new FirebaseCustomRemoteModel.Builder("your_model").build();

Kotlin

// Specify the name you assigned when you deployed the model.
val remoteModel =
    FirebaseCustomRemoteModel.Builder("your_model_name").build()

इसके बाद, मॉडल डाउनलोड करने का टास्क शुरू करें. साथ ही, उन शर्तों के बारे में बताएं जिनके तहत आपको डाउनलोड करने की अनुमति देनी है. अगर मॉडल डिवाइस पर मौजूद नहीं है या मॉडल का नया वर्शन उपलब्ध है, तो टास्क, Firebase से मॉडल को असिंक्रोनस तरीके से डाउनलोड करेगा:

Java

DownloadConditions downloadConditions = new DownloadConditions.Builder()
        .requireWifi()
        .build();
RemoteModelManager.getInstance().download(remoteModel, downloadConditions)
        .addOnSuccessListener(new OnSuccessListener<Void>() {
            @Override
            public void onSuccess(@NonNull Task<Void> task) {
                // Success.
            }
        });

Kotlin

val downloadConditions = DownloadConditions.Builder()
    .requireWifi()
    .build()
RemoteModelManager.getInstance().download(remoteModel, downloadConditions)
    .addOnSuccessListener {
        // Success.
    }

कई ऐप्लिकेशन, अपने शुरुआती कोड में डाउनलोड करने का टास्क शुरू करते हैं. हालांकि, मॉडल का इस्तेमाल करने से पहले, किसी भी समय ऐसा किया जा सकता है.

अपने मॉडल से ऑब्जेक्ट डिटेक्टर बनाना

अपने मॉडल सोर्स कॉन्फ़िगर करने के बाद, उनमें से किसी एक से ObjectDetector ऑब्जेक्ट बनाएं.

अगर आपके पास सिर्फ़ स्थानीय तौर पर बंडल किया गया मॉडल है, तो अपनी मॉडल फ़ाइल से ऑब्जेक्ट डिटेक्टर बनाएं और उस कॉन्फ़िडेंस स्कोर थ्रेशोल्ड को कॉन्फ़िगर करें जिसकी आपको ज़रूरत है (अपने मॉडल का आकलन करें देखें):

Java

// Initialization
ObjectDetectorOptions options = ObjectDetectorOptions.builder()
    .setScoreThreshold(0)  // Evaluate your model in the Google Cloud console
                           // to determine an appropriate value.
    .build();
ObjectDetector objectDetector = ObjectDetector.createFromFileAndOptions(context, modelFile, options);

Kotlin

// Initialization
val options = ObjectDetectorOptions.builder()
    .setScoreThreshold(0)  // Evaluate your model in the Google Cloud console
                           // to determine an appropriate value.
    .build()
val objectDetector = ObjectDetector.createFromFileAndOptions(context, modelFile, options)

अगर आपके पास किसी दूसरे डिवाइस पर होस्ट किया गया मॉडल है, तो उसे चलाने से पहले आपको यह देखना होगा कि वह डाउनलोड हो गया है या नहीं. मॉडल मैनेजर के isModelDownloaded() तरीके का इस्तेमाल करके, मॉडल डाउनलोड करने के टास्क की स्थिति देखी जा सकती है.

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

Java

FirebaseModelManager.getInstance().isModelDownloaded(remoteModel)
        .addOnSuccessListener(new OnSuccessListener<Boolean>() {
            @Override
            public void onSuccess(Boolean isDownloaded) {
            }
        });

Kotlin

FirebaseModelManager.getInstance().isModelDownloaded(remoteModel)
        .addOnSuccessListener { success ->

        }

अगर आपके पास सिर्फ़ रिमोटली होस्ट किया गया मॉडल है, तो आपको मॉडल से जुड़ी सुविधाओं को बंद कर देना चाहिए. उदाहरण के लिए, अपने यूज़र इंटरफ़ेस (यूआई) के कुछ हिस्से को धूसर कर दें या छिपा दें. ऐसा तब तक करें, जब तक मॉडल के डाउनलोड होने की पुष्टि न हो जाए. ऐसा करने के लिए, मॉडल मैनेजर के download() तरीके में एक लिसनर अटैच करें.

जब आपको पता चल जाए कि आपका मॉडल डाउनलोड हो गया है, तो मॉडल फ़ाइल से ऑब्जेक्ट डिटेक्टर बनाएं:

Java

FirebaseModelManager.getInstance().getLatestModelFile(remoteModel)
        .addOnCompleteListener(new OnCompleteListener<File>() {
            @Override
            public void onComplete(@NonNull Task<File> task) {
                File modelFile = task.getResult();
                if (modelFile != null) {
                    ObjectDetectorOptions options = ObjectDetectorOptions.builder()
                            .setScoreThreshold(0)
                            .build();
                    objectDetector = ObjectDetector.createFromFileAndOptions(
                            getApplicationContext(), modelFile.getPath(), options);
                }
            }
        });

Kotlin

FirebaseModelManager.getInstance().getLatestModelFile(remoteModel)
        .addOnSuccessListener { modelFile ->
            val options = ObjectDetectorOptions.builder()
                    .setScoreThreshold(0f)
                    .build()
            objectDetector = ObjectDetector.createFromFileAndOptions(
                    applicationContext, modelFile.path, options)
        }

2. इनपुट इमेज तैयार करें

इसके बाद, आपको जिस इमेज को लेबल करना है उसके लिए, अपनी इमेज से TensorImage ऑब्जेक्ट बनाएं. fromBitmap तरीके का इस्तेमाल करके, Bitmap से TensorImage ऑब्जेक्ट बनाया जा सकता है:

Java

TensorImage image = TensorImage.fromBitmap(bitmap);

Kotlin

val image = TensorImage.fromBitmap(bitmap)

अगर आपकी इमेज का डेटा Bitmap में नहीं है, तो TensorFlow Lite के दस्तावेज़ों में दिखाए गए तरीके से पिक्सल कलेक्शन लोड किया जा सकता है.

3. ऑब्जेक्ट डिटेक्टर को चलाना

किसी इमेज में ऑब्जेक्ट का पता लगाने के लिए, TensorImage ऑब्जेक्ट को ObjectDetector के detect() तरीके में पास करें.

Java

List<Detection> results = objectDetector.detect(image);

Kotlin

val results = objectDetector.detect(image)

4. लेबल किए गए ऑब्जेक्ट के बारे में जानकारी पाना

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

उदाहरण के लिए:

Java

for (Detection result : results) {
    RectF bounds = result.getBoundingBox();
    List<Category> labels = result.getCategories();
}

Kotlin

for (result in results) {
    val bounds = result.getBoundingBox()
    val labels = result.getCategories()
}

रीयल-टाइम परफ़ॉर्मेंस को बेहतर बनाने के लिए सलाह

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

  • इमेज लेबलर को कॉल को कम करें. अगर इमेज लेबलर के इस्तेमाल के दौरान, कोई नया वीडियो फ़्रेम उपलब्ध हो जाता है, तो फ़्रेम को छोड़ दें. उदाहरण के लिए, क्विकस्टार्ट सैंपल ऐप्लिकेशन में VisionProcessorBase क्लास देखें.
  • अगर इनपुट इमेज पर ग्राफ़िक ओवरले करने के लिए, इमेज लेबलर के आउटपुट का इस्तेमाल किया जा रहा है, तो पहले नतीजा पाएं. इसके बाद, एक ही चरण में इमेज और ओवरले को रेंडर करें. ऐसा करने पर, हर इनपुट फ़्रेम के लिए डिसप्ले प्लैटफ़ॉर्म पर सिर्फ़ एक बार रेंडर किया जाता है. उदाहरण के लिए, क्विकस्टार्ट सैंपल ऐप्लिकेशन में CameraSourcePreview और GraphicOverlay क्लास देखें.

  • अगर Camera2 API का इस्तेमाल किया जा रहा है, तो इमेज को ImageFormat.YUV_420_888 फ़ॉर्मैट में कैप्चर करें.

    अगर पुराने Camera API का इस्तेमाल किया जा रहा है, तो इमेज को ImageFormat.NV21 फ़ॉर्मैट में कैप्चर करें.