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

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

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

मॉडल बंडल करने के विकल्प
आपके ऐप्लिकेशन में बंडल किया गया है
  • मॉडल, आपके ऐप्लिकेशन के APK का हिस्सा है
  • Android डिवाइस के ऑफ़लाइन होने पर भी, मॉडल तुरंत उपलब्ध हो जाता है
  • Firebase प्रोजेक्ट की ज़रूरत नहीं है
Firebase की मदद से होस्ट किया गया
  • मॉडल को Firebase Machine Learning पर अपलोड करके होस्ट करें
  • इससे APK का साइज़ कम हो जाता है
  • मॉडल को ज़रूरत के हिसाब से डाउनलोड किया जाता है
  • ऐप्लिकेशन को फिर से पब्लिश किए बिना, मॉडल के अपडेट पुश करना
  • Firebase Remote Config की मदद से आसानी से 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 ऑब्जेक्ट बनाएं. इसमें वह नाम डालें जो आपने मॉडल को पब्लिश करते समय दिया था:

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

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

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

JavaKotlin 
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.
            }
        });

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

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

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

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

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

JavaKotlin 
// 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);

// 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() तरीके का इस्तेमाल करके, मॉडल डाउनलोड करने के टास्क की स्थिति देखी जा सकती है.

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

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

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

        }

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

मॉडल डाउनलोड हो जाने के बाद, मॉडल फ़ाइल से ऑब्जेक्ट डिटेक्टर बनाएं:

JavaKotlin 
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);
                }
            }
        });

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 ऑब्जेक्ट बनाया जा सकता है:

JavaKotlin 
TensorImage image = TensorImage.fromBitmap(bitmap);

val image = TensorImage.fromBitmap(bitmap)

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

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

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

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

val results = objectDetector.detect(image)

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

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

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

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

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 फ़ॉर्मैट में कैप्चर करें.