एंड्रॉइड पर ऑटोएमएल-प्रशिक्षित मॉडल के साथ छवियों में ऑब्जेक्ट का पता लगाएं

ऑटोएमएल विज़न एज का उपयोग करके अपने स्वयं के मॉडल को प्रशिक्षित करने के बाद, आप छवियों में वस्तुओं का पता लगाने के लिए इसे अपने ऐप में उपयोग कर सकते हैं।

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

मॉडल बंडलिंग विकल्प
आपके ऐप में बंडल किया गया
  • मॉडल आपके ऐप के एपीके का हिस्सा है
  • एंड्रॉइड डिवाइस ऑफ़लाइन होने पर भी मॉडल तुरंत उपलब्ध होता है
  • फ़ायरबेस प्रोजेक्ट की कोई आवश्यकता नहीं
फायरबेस के साथ होस्ट किया गया
  • मॉडल को फायरबेस मशीन लर्निंग पर अपलोड करके होस्ट करें
  • एपीके आकार कम कर देता है
  • मॉडल मांग पर डाउनलोड किया जाता है
  • अपने ऐप को दोबारा प्रकाशित किए बिना मॉडल अपडेट पुश करें
  • फायरबेस रिमोट कॉन्फ़िगरेशन के साथ आसान ए/बी परीक्षण
  • फ़ायरबेस प्रोजेक्ट की आवश्यकता है

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

  1. यदि आप कोई मॉडल डाउनलोड करना चाहते हैं , तो सुनिश्चित करें कि आपने अपने एंड्रॉइड प्रोजेक्ट में फायरबेस जोड़ा है , यदि आपने पहले से ऐसा नहीं किया है। जब आप मॉडल को बंडल करते हैं तो इसकी आवश्यकता नहीं होती है।

  2. 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'
}

    फ़ायरबेस से किसी मॉडल को गतिशील रूप से डाउनलोड करने के लिए, फ़ायरबेस एमएल निर्भरता भी जोड़ें:

    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 क्लाउड कंसोल से डाउनलोड किए गए ज़िप संग्रह से मॉडल निकालें।
  2. अपने मॉडल को अपने ऐप पैकेज में शामिल करें:
    1. यदि आपके प्रोजेक्ट में एसेट फ़ोल्डर नहीं है, तो app/ फ़ोल्डर पर राइट-क्लिक करके एक बनाएं, फिर न्यू > फ़ोल्डर > एसेट फ़ोल्डर पर क्लिक करें।
    2. एम्बेडेड मेटाडेटा के साथ अपनी tflite मॉडल फ़ाइल को संपत्ति फ़ोल्डर में कॉपी करें।

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

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

    मॉडल फ़ाइल को ऐप पैकेज में शामिल किया जाएगा और कच्ची संपत्ति के रूप में उपलब्ध कराया जाएगा।

फ़ायरबेस-होस्टेड मॉडल स्रोत कॉन्फ़िगर करें

दूरस्थ रूप से होस्ट किए गए मॉडल का उपयोग करने के लिए, एक RemoteModel ऑब्जेक्ट बनाएं, जिसमें मॉडल को प्रकाशित करते समय आपने जो नाम निर्दिष्ट किया था उसे निर्दिष्ट करें:

जावा

// 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()

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

जावा

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 ऑब्जेक्ट बनाएं।

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

जावा

// 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() विधि का उपयोग करके मॉडल डाउनलोड कार्य की स्थिति की जांच कर सकते हैं।

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

जावा

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

Kotlin

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

        }

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

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

जावा

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

जावा

TensorImage image = TensorImage.fromBitmap(bitmap);

Kotlin

val image = TensorImage.fromBitmap(bitmap)

यदि आपका छवि डेटा Bitmap में नहीं है, तो आप एक पिक्सेल सरणी लोड कर सकते हैं जैसा कि TensorFlow Lite डॉक्स में दिखाया गया है।

3. ऑब्जेक्ट डिटेक्टर चलाएँ

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

जावा

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

Kotlin

val results = objectDetector.detect(image)

4. लेबल वाली वस्तुओं के बारे में जानकारी प्राप्त करें

यदि ऑब्जेक्ट डिटेक्शन ऑपरेशन सफल होता है, तो यह Detection ऑब्जेक्ट्स की एक सूची लौटाता है। प्रत्येक Detection ऑब्जेक्ट किसी ऐसी चीज़ का प्रतिनिधित्व करता है जो छवि में पाई गई थी। आप प्रत्येक ऑब्जेक्ट का बाउंडिंग बॉक्स और उसके लेबल प्राप्त कर सकते हैं।

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

जावा

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 कक्षाएं देखें।

  • यदि आप कैमरा2 एपीआई का उपयोग करते हैं, तो ImageFormat.YUV_420_888 प्रारूप में छवियां कैप्चर करें।

    यदि आप पुराने कैमरा एपीआई का उपयोग करते हैं, तो ImageFormat.NV21 प्रारूप में छवियां कैप्चर करें।