Android पर, इमेज को कस्टम मॉडल से लेबल करना

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

कस्टम मॉडल के साथ इमेज लेबलिंग को इंटिग्रेट करने के दो तरीके हैं: अपने ऐप्लिकेशन के हिस्से के रूप में पाइपलाइन को बंडल करके या Google Play सेवाओं पर निर्भर किसी बंडल न की गई पाइपलाइन का इस्तेमाल करके. अगर आपने बंडल नहीं की गई पाइपलाइन को चुना है, तो आपका ऐप्लिकेशन छोटा हो जाएगा. विवरण के लिए नीचे दी गई तालिका देखें.

	बंडल किए गए	बंडल से बाहर किया गया
लाइब्रेरी का नाम	com.google.mlkit:image-labeling-custom	com.google.android.gms:play-services-mlkit-image-labeling-custom
लागू करने का तरीका	बिल्ड के समय पाइपलाइन, आपके ऐप्लिकेशन से स्टैटिक रूप से लिंक होती है.	पाइपलाइन को, Google Play services से डाइनैमिक तौर पर डाउनलोड किया जाता है.
ऐप्लिकेशन का साइज़	साइज़ करीब 3.8 एमबी बढ़ जाता है.	करीब 200 केबी का साइज़ बढ़ाया जा सकता है.
शुरू होने का समय	पाइपलाइन तुरंत उपलब्ध है.	पहली बार इस्तेमाल करने से पहले, पाइपलाइन के डाउनलोड होने का इंतज़ार करना पड़ सकता है.
एपीआई का लाइफ़साइकल स्टेज	सामान्य उपलब्धता (GA)	बीटा

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

कस्टम मॉडल को इंटिग्रेट करने के दो तरीके हैं: मॉडल को अपने ऐप्लिकेशन के ऐसेट फ़ोल्डर में डालकर बंडल करें या Firebase से डाइनैमिक तौर पर डाउनलोड करें. नीचे दी गई टेबल में इन दोनों विकल्पों की तुलना की गई है.

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

इसे आज़माएं

• बंडल किए गए मॉडल के इस्तेमाल के उदाहरण के लिए, विज़न क्विकस्टार्ट ऐप्लिकेशन देखें. साथ ही, होस्ट किए गए मॉडल के इस्तेमाल के उदाहरण के लिए, automl क्विकस्टार्ट ऐप्लिकेशन देखें.

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

1. प्रोजेक्ट-लेवल की build.gradle फ़ाइल में, अपने buildscript और allprojects, दोनों सेक्शन में Google की Maven रिपॉज़िटरी को शामिल करना न भूलें.

2. ML Kit की Android लाइब्रेरी के लिए, अपने मॉड्यूल की ऐप्लिकेशन-लेवल की ग्रेडल फ़ाइल में डिपेंडेंसी जोड़ें. आम तौर पर, यह फ़ाइल app/build.gradle होती है. अपनी ज़रूरत के हिसाब से, इनमें से कोई एक डिपेंडेंसी चुनें:

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

   dependencies {
     // ...
     // Use this dependency to bundle the pipeline with your app
     implementation 'com.google.mlkit:image-labeling-custom:17.0.2'
   }
   

   Google Play services में पाइपलाइन का इस्तेमाल करने के लिए:

   dependencies {
     // ...
     // Use this dependency to use the dynamically downloaded pipeline in Google Play Services
     implementation 'com.google.android.gms:play-services-mlkit-image-labeling-custom:16.0.0-beta5'
   }
   

3. अगर आपने Google Play Services में पाइपलाइन का इस्तेमाल करने का विकल्प चुना है, तो अपने ऐप्लिकेशन को इस तरह से कॉन्फ़िगर किया जा सकता है कि Play Store से ऐप्लिकेशन इंस्टॉल होने के बाद, वह आपके डिवाइस पर अपने-आप डाउनलोड हो जाए. ऐसा करने के लिए, अपने ऐप्लिकेशन की AndroidManifest.xml फ़ाइल में यह एलान जोड़ें:

   <application ...>
       ...
       <meta-data
           android:name="com.google.mlkit.vision.DEPENDENCIES"
           android:value="custom_ica" />
       <!-- To use multiple downloads: android:value="custom_ica,download2,download3" -->
   </application>
   

   आपके पास यह देखने का विकल्प भी है कि पाइपलाइन की उपलब्धता की जांच की जा सकती है या नहीं. साथ ही, Google Play services के ModuleInstallClient API से, डाउनलोड करने का अनुरोध किया जा सकता है.

   अगर इंस्टॉल-टाइम पाइपलाइन डाउनलोड को चालू नहीं किया जाता है या वीडियो को अलग से डाउनलोड करने का अनुरोध नहीं किया जाता है, तो पहली बार लेबलर चलाने पर पाइपलाइन डाउनलोड हो जाएगी. डाउनलोड पूरा होने से पहले किए गए अनुरोधों का कोई नतीजा नहीं मिलता.

4. अगर आपको Firebase से डाइनैमिक तौर पर कोई मॉडल डाउनलोड करना है, तो linkFirebase डिपेंडेंसी जोड़ें:

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

   dependencies {
     // ...
     // Image labeling feature with model downloaded from Firebase
     implementation 'com.google.mlkit:image-labeling-custom:17.0.2'
     // Or use the dynamically downloaded pipeline in Google Play Services
     // implementation 'com.google.android.gms:play-services-mlkit-image-labeling-custom:16.0.0-beta5'
     implementation 'com.google.mlkit:linkfirebase:17.0.0'
   }
   

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

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

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

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

1. मॉडल फ़ाइल को अपने ऐप्लिकेशन के assets/ फ़ोल्डर में कॉपी करें. यह फ़ाइल आम तौर पर .tflite या .lite पर खत्म होती है. (आपको सबसे पहले app/ फ़ोल्डर पर राइट क्लिक करके, फिर नया > फ़ोल्डर > एसेट फ़ोल्डर पर क्लिक करके फ़ोल्डर बनाना पड़ सकता है.)

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

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

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

   ध्यान दें: Android Gradle प्लगिन के 4.1 वर्शन से, .tflite डिफ़ॉल्ट रूप से noCompress सूची में जुड़ जाएगा. इसके बाद, ऊपर दिए गए एलिमेंट की ज़रूरत नहीं होगी.

3. मॉडल फ़ाइल का पाथ बताते हुए LocalModel ऑब्जेक्ट बनाएं:

   Kotlin

   val localModel = LocalModel.Builder()
           .setAssetFilePath("model.tflite")
           // or .setAbsoluteFilePath(absolute file path to model file)
           // or .setUri(URI to model file)
           .build()

   Java

   LocalModel localModel =
       new LocalModel.Builder()
           .setAssetFilePath("model.tflite")
           // or .setAbsoluteFilePath(absolute file path to model file)
           // or .setUri(URI to model file)
           .build();

   ध्यान दें: Android 11 (एपीआई लेवल 30) को टारगेट करने वाले ऐप्लिकेशन, अब बाहरी स्टोरेज से फ़ाइलों को ऐक्सेस नहीं कर सकते. ऐसा इसलिए होता है, क्योंकि Android 11 में स्टोरेज के अपडेट होते हैं.
   ध्यान दें: अगर आपके पास ऐसा मॉडल है जिसे Firebase में AutoML Vision Edge (Google Cloud के बजाय) के साथ ट्रेनिंग दी गई है, तो हो सकता है कि ऊपर बताए गए तरीके काम न करें. निर्देशों के लिए, कृपया डेटा को दूसरी जगह भेजने से जुड़ी गाइड का पालन करें.

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

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

Kotlin

// Specify the name you assigned in the Firebase console.
val remoteModel =
    CustomRemoteModel
        .Builder(FirebaseModelSource.Builder("your_model_name").build())
        .build()

Java

// Specify the name you assigned in the Firebase console.
CustomRemoteModel remoteModel =
    new CustomRemoteModel
        .Builder(new FirebaseModelSource.Builder("your_model_name").build())
        .build();

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

Kotlin

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

Java

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

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

इमेज लेबलर कॉन्फ़िगर करें

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

ये विकल्प उपलब्ध हैं:

विकल्प
confidenceThreshold	पता लगाए गए लेबल का कम से कम कॉन्फ़िडेंस स्कोर. अगर यह नीति सेट नहीं है, तो मॉडल के मेटाडेटा में तय की गई, कैटगरी तय करने के लिए तय किए गए थ्रेशोल्ड का इस्तेमाल किया जाएगा. अगर मॉडल में कोई मेटाडेटा नहीं है या मेटाडेटा में डेटा की कैटगरी तय करने के लिए कोई थ्रेशोल्ड तय नहीं किया गया है, तो 0.0 की डिफ़ॉल्ट थ्रेशोल्ड का इस्तेमाल किया जाएगा.
maxResultCount	लौटाए जाने वाले लेबल की ज़्यादा से ज़्यादा संख्या. इस नीति को सेट न करने पर, 10 की डिफ़ॉल्ट वैल्यू का इस्तेमाल किया जाएगा.

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

Kotlin

val customImageLabelerOptions = CustomImageLabelerOptions.Builder(localModel)
    .setConfidenceThreshold(0.5f)
    .setMaxResultCount(5)
    .build()
val labeler = ImageLabeling.getClient(customImageLabelerOptions)

Java

CustomImageLabelerOptions customImageLabelerOptions =
        new CustomImageLabelerOptions.Builder(localModel)
            .setConfidenceThreshold(0.5f)
            .setMaxResultCount(5)
            .build();
ImageLabeler labeler = ImageLabeling.getClient(customImageLabelerOptions);

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

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

Kotlin

RemoteModelManager.getInstance().isModelDownloaded(remoteModel)
    .addOnSuccessListener { isDownloaded ->
    val optionsBuilder =
        if (isDownloaded) {
            CustomImageLabelerOptions.Builder(remoteModel)
        } else {
            CustomImageLabelerOptions.Builder(localModel)
        }
    val options = optionsBuilder
                  .setConfidenceThreshold(0.5f)
                  .setMaxResultCount(5)
                  .build()
    val labeler = ImageLabeling.getClient(options)
}

Java

RemoteModelManager.getInstance().isModelDownloaded(remoteModel)
        .addOnSuccessListener(new OnSuccessListener() {
            @Override
            public void onSuccess(Boolean isDownloaded) {
                CustomImageLabelerOptions.Builder optionsBuilder;
                if (isDownloaded) {
                    optionsBuilder = new CustomImageLabelerOptions.Builder(remoteModel);
                } else {
                    optionsBuilder = new CustomImageLabelerOptions.Builder(localModel);
                }
                CustomImageLabelerOptions options = optionsBuilder
                    .setConfidenceThreshold(0.5f)
                    .setMaxResultCount(5)
                    .build();
                ImageLabeler labeler = ImageLabeling.getClient(options);
            }
        });

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

Kotlin

RemoteModelManager.getInstance().download(remoteModel, conditions)
    .addOnSuccessListener {
        // Download complete. Depending on your app, you could enable the ML
        // feature, or switch from the local model to the remote model, etc.
    }

Java

RemoteModelManager.getInstance().download(remoteModel, conditions)
        .addOnSuccessListener(new OnSuccessListener() {
            @Override
            public void onSuccess(Void v) {
              // Download complete. Depending on your app, you could enable
              // the ML feature, or switch from the local model to the remote
              // model, etc.
            }
        });

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

इसके बाद, हर उस इमेज के लिए जिसे आपको लेबल करना है, अपनी इमेज से InputImage ऑब्जेक्ट बनाएं. Bitmap इस्तेमाल करने पर, इमेज लेबलर तेज़ी से काम करता है. अगर Cam2 API का इस्तेमाल किया जा रहा है, तो YUV_420_888 media.Image का इस्तेमाल किया जा सकता है. जब भी संभव होगा, तब ऐसा करने का सुझाव दिया जाता है.

अलग-अलग सोर्स से InputImage ऑब्जेक्ट बनाया जा सकता है. हर ऑब्जेक्ट के बारे में नीचे बताया गया है.

media.Image का इस्तेमाल करना

किसी media.Image ऑब्जेक्ट से InputImage ऑब्जेक्ट बनाने के लिए, जैसे कि डिवाइस के कैमरे से इमेज कैप्चर करने पर, media.Image ऑब्जेक्ट और इमेज के रोटेशन को InputImage.fromMediaImage() पर पास करें.

अगर CameraX लाइब्रेरी का इस्तेमाल किया जाता है, तो OnImageCapturedListener और ImageAnalysis.Analyzer क्लास आपके लिए, रोटेशन वैल्यू का हिसाब लगाती हैं.

Kotlin

private class YourImageAnalyzer : ImageAnalysis.Analyzer {

    override fun analyze(imageProxy: ImageProxy) {
        val mediaImage = imageProxy.image
        if (mediaImage != null) {
            val image = InputImage.fromMediaImage(mediaImage, imageProxy.imageInfo.rotationDegrees)
            // Pass image to an ML Kit Vision API
            // ...
        }
    }
}

Java

private class YourAnalyzer implements ImageAnalysis.Analyzer {

    @Override
    public void analyze(ImageProxy imageProxy) {
        Image mediaImage = imageProxy.getImage();
        if (mediaImage != null) {
          InputImage image =
                InputImage.fromMediaImage(mediaImage, imageProxy.getImageInfo().getRotationDegrees());
          // Pass image to an ML Kit Vision API
          // ...
        }
    }
}

अगर आप ऐसी कैमरा लाइब्रेरी का इस्तेमाल नहीं करते हैं जो आपको इमेज की रोटेशन डिग्री देती है, तो आप इसकी गणना डिवाइस की रोटेशन डिग्री और डिवाइस में कैमरा सेंसर के ओरिएंटेशन से कर सकते हैं:

Kotlin

private val ORIENTATIONS = SparseIntArray()

init {
    ORIENTATIONS.append(Surface.ROTATION_0, 0)
    ORIENTATIONS.append(Surface.ROTATION_90, 90)
    ORIENTATIONS.append(Surface.ROTATION_180, 180)
    ORIENTATIONS.append(Surface.ROTATION_270, 270)
}

/**
 * Get the angle by which an image must be rotated given the device's current
 * orientation.
 */
@RequiresApi(api = Build.VERSION_CODES.LOLLIPOP)
@Throws(CameraAccessException::class)
private fun getRotationCompensation(cameraId: String, activity: Activity, isFrontFacing: Boolean): Int {
    // Get the device's current rotation relative to its "native" orientation.
    // Then, from the ORIENTATIONS table, look up the angle the image must be
    // rotated to compensate for the device's rotation.
    val deviceRotation = activity.windowManager.defaultDisplay.rotation
    var rotationCompensation = ORIENTATIONS.get(deviceRotation)

    // Get the device's sensor orientation.
    val cameraManager = activity.getSystemService(CAMERA_SERVICE) as CameraManager
    val sensorOrientation = cameraManager
            .getCameraCharacteristics(cameraId)
            .get(CameraCharacteristics.SENSOR_ORIENTATION)!!

    if (isFrontFacing) {
        rotationCompensation = (sensorOrientation + rotationCompensation) % 360
    } else { // back-facing
        rotationCompensation = (sensorOrientation - rotationCompensation + 360) % 360
    }
    return rotationCompensation
}
MLKitVisionImage.kt

Java

private static final SparseIntArray ORIENTATIONS = new SparseIntArray();
static {
    ORIENTATIONS.append(Surface.ROTATION_0, 0);
    ORIENTATIONS.append(Surface.ROTATION_90, 90);
    ORIENTATIONS.append(Surface.ROTATION_180, 180);
    ORIENTATIONS.append(Surface.ROTATION_270, 270);
}

/**
 * Get the angle by which an image must be rotated given the device's current
 * orientation.
 */
@RequiresApi(api = Build.VERSION_CODES.LOLLIPOP)
private int getRotationCompensation(String cameraId, Activity activity, boolean isFrontFacing)
        throws CameraAccessException {
    // Get the device's current rotation relative to its "native" orientation.
    // Then, from the ORIENTATIONS table, look up the angle the image must be
    // rotated to compensate for the device's rotation.
    int deviceRotation = activity.getWindowManager().getDefaultDisplay().getRotation();
    int rotationCompensation = ORIENTATIONS.get(deviceRotation);

    // Get the device's sensor orientation.
    CameraManager cameraManager = (CameraManager) activity.getSystemService(CAMERA_SERVICE);
    int sensorOrientation = cameraManager
            .getCameraCharacteristics(cameraId)
            .get(CameraCharacteristics.SENSOR_ORIENTATION);

    if (isFrontFacing) {
        rotationCompensation = (sensorOrientation + rotationCompensation) % 360;
    } else { // back-facing
        rotationCompensation = (sensorOrientation - rotationCompensation + 360) % 360;
    }
    return rotationCompensation;
}

इसके बाद, media.Image ऑब्जेक्ट और रोटेशन डिग्री वैल्यू को InputImage.fromMediaImage() पर पास करें:

Kotlin

val image = InputImage.fromMediaImage(mediaImage, rotation)
MLKitVisionImage.kt

Java

InputImage image = InputImage.fromMediaImage(mediaImage, rotation);

फ़ाइल यूआरआई का इस्तेमाल करना

किसी फ़ाइल यूआरआई से InputImage ऑब्जेक्ट बनाने के लिए, ऐप्लिकेशन का कॉन्टेक्स्ट और फ़ाइल यूआरआई को InputImage.fromFilePath() पर पास करें. यह तब काम आता है, जब ACTION_GET_CONTENT इंटेंट का इस्तेमाल करके, उपयोगकर्ता से उनके गैलरी ऐप्लिकेशन से कोई इमेज चुनने का अनुरोध किया जाता है.

Kotlin

val image: InputImage
try {
    image = InputImage.fromFilePath(context, uri)
} catch (e: IOException) {
    e.printStackTrace()
}
MLKitVisionImage.kt

Java

InputImage image;
try {
    image = InputImage.fromFilePath(context, uri);
} catch (IOException e) {
    e.printStackTrace();
}

ByteBuffer या ByteArray का इस्तेमाल करना

किसी ByteBuffer या ByteArray से InputImage ऑब्जेक्ट बनाने के लिए, सबसे पहले इमेज के रोटेशन की डिग्री का हिसाब लगाएं, जैसा कि media.Image इनपुट के लिए पहले बताया गया था. इसके बाद, बफ़र या अरे की मदद से InputImage ऑब्जेक्ट बनाएं. इसके लिए, इमेज की ऊंचाई, चौड़ाई, कलर एन्कोडिंग, और रोटेशन डिग्री का इस्तेमाल करें:

Kotlin

val image = InputImage.fromByteBuffer(
        byteBuffer,
        /* image width */ 480,
        /* image height */ 360,
        rotationDegrees,
        InputImage.IMAGE_FORMAT_NV21 // or IMAGE_FORMAT_YV12
)
MLKitVisionImage.kt
// Or:
val image = InputImage.fromByteArray(
        byteArray,
        /* image width */ 480,
        /* image height */ 360,
        rotationDegrees,
        InputImage.IMAGE_FORMAT_NV21 // or IMAGE_FORMAT_YV12
)
MLKitVisionImage.kt

Java

InputImage image = InputImage.fromByteBuffer(byteBuffer,
        /* image width */ 480,
        /* image height */ 360,
        rotationDegrees,
        InputImage.IMAGE_FORMAT_NV21 // or IMAGE_FORMAT_YV12
);
MLKitVisionImage.java
// Or:
InputImage image = InputImage.fromByteArray(
        byteArray,
        /* image width */480,
        /* image height */360,
        rotation,
        InputImage.IMAGE_FORMAT_NV21 // or IMAGE_FORMAT_YV12
);
MLKitVisionImage.java

Bitmap का इस्तेमाल करना

किसी Bitmap ऑब्जेक्ट से InputImage ऑब्जेक्ट बनाने के लिए, यह एलान करें:

Kotlin

val image = InputImage.fromBitmap(bitmap, 0)
MLKitVisionImage.kt

Java

InputImage image = InputImage.fromBitmap(bitmap, rotationDegree);
MLKitVisionImage.java

इमेज को Bitmap ऑब्जेक्ट के ज़रिए रोटेशन डिग्री के साथ दिखाया गया है.

3. इमेज लेबलर चलाएं

किसी इमेज में मौजूद ऑब्जेक्ट को लेबल करने के लिए, image ऑब्जेक्ट को ImageLabeler के process() तरीके में पास करें.

Kotlin

labeler.process(image)
        .addOnSuccessListener { labels ->
            // Task completed successfully
            // ...
        }
        .addOnFailureListener { e ->
            // Task failed with an exception
            // ...
        }
ImageLabelingActivity.kt

Java

labeler.process(image)
        .addOnSuccessListener(new OnSuccessListener<List<ImageLabel>>() {
            @Override
            public void onSuccess(List<ImageLabel> labels) {
                // Task completed successfully
                // ...
            }
        })
        .addOnFailureListener(new OnFailureListener() {
            @Override
            public void onFailure(@NonNull Exception e) {
                // Task failed with an exception
                // ...
            }
        });
ImageLabelingActivity.java

ध्यान दें: अगर CameraX एपीआई का इस्तेमाल किया जा रहा है, तो ImageProxy का इस्तेमाल पूरा होने पर उसे बंद करना न भूलें. उदाहरण के लिए,process तरीके से लौटाए गए Task में OnCompleteListener जोड़कर. उदाहरण के लिए, VisionProcessorBase क्विकस्टार्ट ऐप्लिकेशन में क्लास देखें.

4. लेबल की गई इकाइयों के बारे में जानकारी पाना

अगर इमेज को लेबल किया जाता है, तो सक्सेस लिसनर को ImageLabel ऑब्जेक्ट की एक सूची भेजी जाती है. हर ImageLabel ऑब्जेक्ट कुछ ऐसा दिखाता है जिसे इमेज में लेबल किया गया था. हर लेबल के टेक्स्ट की जानकारी देखी जा सकती है. अगर यह जानकारी, TensorFlow Lite मॉडल फ़ाइल के मेटाडेटा में मौजूद है, तो कॉन्फ़िडेंस स्कोर, और इंडेक्स किया जा सकता है. उदाहरण के लिए:

Kotlin

for (label in labels) {
    val text = label.text
    val confidence = label.confidence
    val index = label.index
}
ImageLabelingActivity.kt

Java

for (ImageLabel label : labels) {
    String text = label.getText();
    float confidence = label.getConfidence();
    int index = label.getIndex();
}
ImageLabelingActivity.java

ध्यान दें: अगर कोई ऐसा TensorFlow Lite मॉडल इस्तेमाल करता है जो ML Kit के साथ काम नहीं करता, तो आपको गड़बड़ी कोड MlKitException#INVALID_ARGUMENT के साथ MlKitException मिलेगा. इसमें कुछ जानकारी भी मिलेगी कि यह ML Kit के साथ काम नहीं करता. ज़्यादा जानकारी के लिए, कस्टम मॉडल के साथ काम करने की ज़रूरी शर्तें देखें.

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

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

• अगर Camera या camera2 एपीआई का इस्तेमाल किया जा रहा है, तो इमेज लेबलर को कॉल थ्रॉटल करें. अगर इमेज लेबलर चलने के दौरान कोई नया वीडियो फ़्रेम उपलब्ध हो जाता है, तो फ़्रेम को छोड़ें. उदाहरण के लिए, क्विकस्टार्ट ऐप्लिकेशन में VisionProcessorBase क्लास देखें.
• अगर CameraX एपीआई का इस्तेमाल किया जाता है, तो पक्का करें कि बैकप्रेशर रणनीति की वैल्यू, ImageAnalysis.STRATEGY_KEEP_ONLY_LATEST डिफ़ॉल्ट वैल्यू पर सेट हो. इससे यह गारंटी मिलती है कि एक बार में विश्लेषण के लिए सिर्फ़ एक इमेज ही डिलीवर की जाएगी. अगर ऐनालाइज़र के व्यस्त होने पर और इमेज बनाई जाती हैं, तो उन्हें अपने-आप हटा दिया जाएगा और डिलीवरी के लिए सूची में नहीं रखा जाएगा. जिस इमेज की जांच की जा रही है उसे Imageप्रॉक्सी.close() को कॉल करके बंद करने के बाद, अगली सबसे नई इमेज डिलीवर की जाएगी.
• अगर इनपुट इमेज पर ग्राफ़िक ओवरले करने के लिए, इमेज लेबलर के आउटपुट का इस्तेमाल किया जाता है, तो सबसे पहले एमएल किट से नतीजा पाएं. इसके बाद, इमेज और ओवरले को एक ही चरण में रेंडर करें. यह हर इनपुट फ़्रेम के लिए, डिसप्ले प्लैटफ़ॉर्म पर सिर्फ़ एक बार रेंडर होता है. उदाहरण के लिए, क्विकस्टार्ट ऐप्लिकेशन में CameraSourcePreview और GraphicOverlay क्लास देखें.
• अगर Camera2 एपीआई का इस्तेमाल किया जा रहा है, तो ImageFormat.YUV_420_888 फ़ॉर्मैट में इमेज कैप्चर करें. अगर पुराने Camera API का इस्तेमाल किया जा रहा है, तो इमेज को ImageFormat.NV21 फ़ॉर्मैट में कैप्चर करें.