एमएल किट का इस्तेमाल करके, इमेज में मौजूद इकाइयों को पहचाना जा सकता है और उन्हें लेबल किया जा सकता है. यह एपीआई, पसंद के मुताबिक इमेज की कैटगरी तय करने वाले कई तरह के मॉडल के साथ काम करता है. मॉडल के साथ काम करने से जुड़ी ज़रूरी शर्तों, पहले से ट्रेनिंग दिए गए मॉडल कहां मिलेंगे, और अपने मॉडल को ट्रेनिंग कैसे दी जा सकती है, इस बारे में दिशा-निर्देश पाने के लिए, कृपया एमएल किट वाले कस्टम मॉडल देखें.
कस्टम मॉडल के साथ इमेज लेबलिंग को इंटिग्रेट करने के दो तरीके हैं: अपने ऐप्लिकेशन के हिस्से के रूप में पाइपलाइन को बंडल करके या 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 क्विकस्टार्ट ऐप्लिकेशन देखें.
शुरू करने से पहले
प्रोजेक्ट-लेवल की
build.gradle
फ़ाइल में, अपनेbuildscript
औरallprojects
, दोनों सेक्शन में Google की Maven रिपॉज़िटरी को शामिल करना न भूलें.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' }
अगर आपने 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 से, डाउनलोड करने का अनुरोध किया जा सकता है.
अगर इंस्टॉल-टाइम पाइपलाइन डाउनलोड को चालू नहीं किया जाता है या वीडियो को अलग से डाउनलोड करने का अनुरोध नहीं किया जाता है, तो पहली बार लेबलर चलाने पर पाइपलाइन डाउनलोड हो जाएगी. डाउनलोड पूरा होने से पहले किए गए अनुरोधों का कोई नतीजा नहीं मिलता.
अगर आपको 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' }
अगर आपको कोई मॉडल डाउनलोड करना है, तो पक्का करें कि आपने अपने Android प्रोजेक्ट में Firebase जोड़ा हो. ऐसा तब करें, जब आपने पहले ऐसा नहीं किया हो. मॉडल को बंडल करते समय, ऐसा करने की ज़रूरत नहीं होती.
1. मॉडल लोड करें
लोकल मॉडल के सोर्स को कॉन्फ़िगर करना
मॉडल को अपने ऐप्लिकेशन के साथ बंडल करने के लिए:
मॉडल फ़ाइल को अपने ऐप्लिकेशन के
assets/
फ़ोल्डर में कॉपी करें. यह फ़ाइल आम तौर पर.tflite
या.lite
पर खत्म होती है. (आपको सबसे पहलेapp/
फ़ोल्डर पर राइट क्लिक करके, फिर नया > फ़ोल्डर > एसेट फ़ोल्डर पर क्लिक करके फ़ोल्डर बनाना पड़ सकता है.)इसके बाद, अपने ऐप्लिकेशन की
build.gradle
फ़ाइल में ये जोड़ें, ताकि यह पक्का किया जा सके कि ऐप्लिकेशन बनाते समय Grale, मॉडल फ़ाइल को कंप्रेस न करे:android { // ... aaptOptions { noCompress "tflite" // or noCompress "lite" } }
मॉडल फ़ाइल, ऐप्लिकेशन पैकेज में शामिल की जाएगी और एमएल किट के लिए एक रॉ एसेट के तौर पर उपलब्ध होगी.
मॉडल फ़ाइल का पाथ बताते हुए
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();
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 }
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)
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() }
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 ) // Or: val image = InputImage.fromByteArray( byteArray, /* image width */ 480, /* image height */ 360, rotationDegrees, InputImage.IMAGE_FORMAT_NV21 // or IMAGE_FORMAT_YV12 )
Java
InputImage image = InputImage.fromByteBuffer(byteBuffer, /* image width */ 480, /* image height */ 360, rotationDegrees, InputImage.IMAGE_FORMAT_NV21 // or IMAGE_FORMAT_YV12 ); // Or: InputImage image = InputImage.fromByteArray( byteArray, /* image width */480, /* image height */360, rotation, InputImage.IMAGE_FORMAT_NV21 // or IMAGE_FORMAT_YV12 );
Bitmap
का इस्तेमाल करना
किसी Bitmap
ऑब्जेक्ट से InputImage
ऑब्जेक्ट बनाने के लिए, यह एलान करें:
Kotlin
val image = InputImage.fromBitmap(bitmap, 0)
Java
InputImage image = InputImage.fromBitmap(bitmap, rotationDegree);
इमेज को Bitmap
ऑब्जेक्ट के ज़रिए रोटेशन डिग्री के साथ दिखाया गया है.
3. इमेज लेबलर चलाएं
किसी इमेज में मौजूद ऑब्जेक्ट को लेबल करने के लिए, image
ऑब्जेक्ट को ImageLabeler
के process()
तरीके में पास करें.
Kotlin
labeler.process(image) .addOnSuccessListener { labels -> // Task completed successfully // ... } .addOnFailureListener { e -> // Task failed with an exception // ... }
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 // ... } });
4. लेबल की गई इकाइयों के बारे में जानकारी पाना
अगर इमेज को लेबल किया जाता है, तो सक्सेस लिसनर कोImageLabel
ऑब्जेक्ट की एक सूची भेजी जाती है. हर ImageLabel
ऑब्जेक्ट कुछ ऐसा दिखाता है जिसे इमेज में लेबल किया गया था. हर लेबल के टेक्स्ट की जानकारी देखी जा सकती है.
अगर यह जानकारी, TensorFlow Lite मॉडल फ़ाइल के मेटाडेटा में मौजूद है, तो कॉन्फ़िडेंस स्कोर, और इंडेक्स किया जा सकता है. उदाहरण के लिए:
Kotlin
for (label in labels) { val text = label.text val confidence = label.confidence val index = label.index }
Java
for (ImageLabel label : labels) { String text = label.getText(); float confidence = label.getConfidence(); int index = label.getIndex(); }
रीयल-टाइम में परफ़ॉर्मेंस बेहतर करने के लिए सलाह
अगर आपको रीयल-टाइम ऐप्लिकेशन में इमेज को लेबल करना है, तो सबसे अच्छे फ़्रेम रेट पाने के लिए, इन दिशा-निर्देशों का पालन करें:
- अगर
Camera
याcamera2
एपीआई का इस्तेमाल किया जा रहा है, तो इमेज लेबलर को कॉल थ्रॉटल करें. अगर इमेज लेबलर चलने के दौरान कोई नया वीडियो फ़्रेम उपलब्ध हो जाता है, तो फ़्रेम को छोड़ें. उदाहरण के लिए, क्विकस्टार्ट ऐप्लिकेशन मेंVisionProcessorBase
क्लास देखें. - अगर
CameraX
एपीआई का इस्तेमाल किया जाता है, तो पक्का करें कि बैकप्रेशर रणनीति की वैल्यू,ImageAnalysis.STRATEGY_KEEP_ONLY_LATEST
डिफ़ॉल्ट वैल्यू पर सेट हो. इससे यह गारंटी मिलती है कि एक बार में विश्लेषण के लिए सिर्फ़ एक इमेज ही डिलीवर की जाएगी. अगर ऐनालाइज़र के व्यस्त होने पर और इमेज बनाई जाती हैं, तो उन्हें अपने-आप हटा दिया जाएगा और डिलीवरी के लिए सूची में नहीं रखा जाएगा. जिस इमेज की जांच की जा रही है उसे Imageप्रॉक्सी.close() को कॉल करके बंद करने के बाद, अगली सबसे नई इमेज डिलीवर की जाएगी. - अगर इनपुट इमेज पर ग्राफ़िक ओवरले करने के लिए, इमेज लेबलर के आउटपुट का इस्तेमाल किया जाता है, तो सबसे पहले एमएल किट से नतीजा पाएं. इसके बाद, इमेज और ओवरले को एक ही चरण में रेंडर करें. यह हर इनपुट फ़्रेम के लिए, डिसप्ले प्लैटफ़ॉर्म पर
सिर्फ़ एक बार रेंडर होता है. उदाहरण के लिए, क्विकस्टार्ट ऐप्लिकेशन में
CameraSourcePreview
औरGraphicOverlay
क्लास देखें. - अगर Camera2 एपीआई का इस्तेमाल किया जा रहा है, तो
ImageFormat.YUV_420_888
फ़ॉर्मैट में इमेज कैप्चर करें. अगर पुराने Camera API का इस्तेमाल किया जा रहा है, तो इमेज कोImageFormat.NV21
फ़ॉर्मैट में कैप्चर करें.