Lorsque vous transmettez une image à ML Kit, celui-ci détecte jusqu'à cinq objets dans l'image ainsi que la position de chaque objet dans l'image. Lorsque vous détectez des objets dans flux vidéo, chaque objet possède un identifiant unique que vous pouvez utiliser pour suivre d'une image à l'autre.
Vous pouvez utiliser un modèle de classification d'images personnalisé pour classer les objets détecté. Consultez Modèles personnalisés avec ML Kit pour découvrir des conseils sur les exigences de compatibilité des modèles, où trouver des modèles pré-entraînés, et comment entraîner vos propres modèles.
Il existe deux façons d'intégrer un modèle personnalisé. Vous pouvez grouper le modèle en le plaçant dans le dossier de composants de votre application, ou vous pouvez le télécharger depuis Firebase. Le tableau suivant compare les deux options.
Modèle groupé | Modèle hébergé |
---|---|
Le modèle fait partie de l'APK de votre application, ce qui augmente sa taille. | Le modèle ne fait pas partie de votre APK. Il est hébergé par l'importation dans Firebase Machine Learning. |
Le modèle est disponible immédiatement, même lorsque l'appareil Android est hors connexion | Le modèle est téléchargé à la demande |
Pas besoin d'un projet Firebase | Nécessite un projet Firebase |
Vous devez publier à nouveau votre application pour mettre à jour le modèle | Déployer les mises à jour du modèle sans publier à nouveau votre application |
Pas de tests A/B intégrés | Tests A/B faciles avec Firebase Remote Config |
Essayer
- Consultez l'application de démarrage rapide Vision. pour découvrir un exemple d'utilisation du modèle groupé application de démarrage rapide automl pour exemple d'utilisation du modèle hébergé.
- Voir la présentation Material Design app pour une implémentation de bout en bout de cette API.
Avant de commencer
Dans le fichier
build.gradle
au niveau du projet, veillez à inclure dépôt Maven de Google dans vos fichiersbuildscript
etallprojects
.Ajoutez les dépendances des bibliothèques Android ML Kit au fichier fichier Gradle au niveau de l'application, généralement
app/build.gradle
:Pour regrouper un modèle avec votre application:
dependencies { // ... // Object detection & tracking feature with custom bundled model implementation 'com.google.mlkit:object-detection-custom:17.0.2' }
Pour télécharger un modèle de manière dynamique depuis Firebase, ajoutez le
linkFirebase
la dépendance:dependencies { // ... // Object detection & tracking feature with model downloaded // from firebase implementation 'com.google.mlkit:object-detection-custom:17.0.2' implementation 'com.google.mlkit:linkfirebase:17.0.0' }
Si vous souhaitez télécharger un modèle, assurez-vous ajouter Firebase à votre projet Android ; si vous ne l'avez pas déjà fait. Cette opération n'est pas requise lorsque vous regroupez le modèle.
1. Charger le modèle
Configurer une source de modèle locale
Pour empaqueter le modèle avec votre application:
Copiez le fichier de modèle (se terminant généralement par
.tflite
ou.lite
) dans le répertoire Dossierassets/
. (Vous devrez peut-être d'abord créer le dossier faites un clic droit sur le dossierapp/
, puis cliquez sur Nouveau > Dossier > dossier "Assets".Ajoutez ensuite les éléments suivants au fichier
build.gradle
de votre application pour vous assurer Gradle ne compresse pas le fichier de modèle lors de la compilation de l'application:android { // ... aaptOptions { noCompress "tflite" // or noCompress "lite" } }
Le fichier de modèle sera inclus dans le package de l'application et disponible pour ML Kit en tant qu'élément brut.
Créez l'objet
LocalModel
en spécifiant le chemin d'accès au fichier de modèle: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();
Configurer une source de modèle hébergé sur Firebase
Pour utiliser le modèle hébergé à distance, créez un objet CustomRemoteModel
en exécutant la commande suivante :
FirebaseModelSource
, en spécifiant le nom que vous avez attribué au modèle lorsque vous avez
l'avez publiée:
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();
Ensuite, démarrez la tâche de téléchargement du modèle, en spécifiant les conditions dans lesquelles que vous souhaitez autoriser le téléchargement. Si le modèle ne figure pas sur l'appareil, ou si un modèle plus récent du modèle est disponible, la tâche téléchargera de manière asynchrone depuis 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. } });
De nombreuses applications lancent la tâche de téléchargement dans leur code d'initialisation, vous pouvez le faire à tout moment avant d'avoir besoin d'utiliser le modèle.
2. Configurer le détecteur d'objets
Une fois les sources de modèle configurées, configurez le détecteur d'objets pour votre
avec un objet CustomObjectDetectorOptions
. Vous pouvez modifier
les paramètres suivants:
Paramètres du détecteur d'objets | |
---|---|
Mode de détection |
STREAM_MODE (par défaut) | SINGLE_IMAGE_MODE
Dans Dans |
Détecter et suivre plusieurs objets |
false (par défaut) | true
Permet de détecter et de suivre jusqu'à cinq objets, ou seulement les plus objet proéminent (par défaut). |
Classer des objets |
false (par défaut) | true
Indique si les objets détectés doivent être classés ou non à l'aide de la classe
un modèle de classificateur personnalisé. Pour utiliser votre classification personnalisée :
vous devez le définir sur |
Seuil de confiance de la classification |
Score de confiance minimal des étiquettes détectées. Si ce champ n'est pas défini, spécifié par les métadonnées du modèle sera utilisé. Si le modèle ne contient pas de métadonnées spécifiez un seuil de classificateur, un seuil par défaut de 0.0 utilisé. |
Nombre maximal d'étiquettes par objet |
Nombre maximal d'étiquettes par objet que le détecteur retour. Si cette règle n'est pas configurée, la valeur par défaut de 10 est utilisée. |
L'API de détection et de suivi des objets est optimisée pour ces deux utilisations principales cas:
- Détection et suivi en direct de l'objet le plus proéminent de la caméra viseur.
- La détection de plusieurs objets à partir d'une image statique.
Pour configurer l'API pour ces cas d'utilisation, avec un modèle groupé localement, procédez comme suit:
Kotlin
// Live detection and tracking val customObjectDetectorOptions = CustomObjectDetectorOptions.Builder(localModel) .setDetectorMode(CustomObjectDetectorOptions.STREAM_MODE) .enableClassification() .setClassificationConfidenceThreshold(0.5f) .setMaxPerObjectLabelCount(3) .build() // Multiple object detection in static images val customObjectDetectorOptions = CustomObjectDetectorOptions.Builder(localModel) .setDetectorMode(CustomObjectDetectorOptions.SINGLE_IMAGE_MODE) .enableMultipleObjects() .enableClassification() .setClassificationConfidenceThreshold(0.5f) .setMaxPerObjectLabelCount(3) .build() val objectDetector = ObjectDetection.getClient(customObjectDetectorOptions)
Java
// Live detection and tracking CustomObjectDetectorOptions customObjectDetectorOptions = new CustomObjectDetectorOptions.Builder(localModel) .setDetectorMode(CustomObjectDetectorOptions.STREAM_MODE) .enableClassification() .setClassificationConfidenceThreshold(0.5f) .setMaxPerObjectLabelCount(3) .build(); // Multiple object detection in static images CustomObjectDetectorOptions customObjectDetectorOptions = new CustomObjectDetectorOptions.Builder(localModel) .setDetectorMode(CustomObjectDetectorOptions.SINGLE_IMAGE_MODE) .enableMultipleObjects() .enableClassification() .setClassificationConfidenceThreshold(0.5f) .setMaxPerObjectLabelCount(3) .build(); ObjectDetector objectDetector = ObjectDetection.getClient(customObjectDetectorOptions);
Si vous disposez d'un modèle hébergé à distance, vous devrez vérifier qu'il a été
téléchargée avant
de l’exécuter. Vous pouvez vérifier l'état du téléchargement du modèle
à l'aide de la méthode isModelDownloaded()
du gestionnaire de modèles.
Même s'il vous suffit de le confirmer avant d'exécuter le détecteur, un modèle hébergé à distance et un modèle groupé localement, cela peut rendre d'effectuer cette vérification lors de l'instanciation du détecteur d'images: créez une du modèle distant s'il a été téléchargé, et à partir de l'environnement local dans le cas contraire.
Kotlin
RemoteModelManager.getInstance().isModelDownloaded(remoteModel) .addOnSuccessListener { isDownloaded -> val optionsBuilder = if (isDownloaded) { CustomObjectDetectorOptions.Builder(remoteModel) } else { CustomObjectDetectorOptions.Builder(localModel) } val customObjectDetectorOptions = optionsBuilder .setDetectorMode(CustomObjectDetectorOptions.SINGLE_IMAGE_MODE) .enableClassification() .setClassificationConfidenceThreshold(0.5f) .setMaxPerObjectLabelCount(3) .build() val objectDetector = ObjectDetection.getClient(customObjectDetectorOptions) }
Java
RemoteModelManager.getInstance().isModelDownloaded(remoteModel) .addOnSuccessListener(new OnSuccessListener() { @Override public void onSuccess(Boolean isDownloaded) { CustomObjectDetectorOptions.Builder optionsBuilder; if (isDownloaded) { optionsBuilder = new CustomObjectDetectorOptions.Builder(remoteModel); } else { optionsBuilder = new CustomObjectDetectorOptions.Builder(localModel); } CustomObjectDetectorOptions customObjectDetectorOptions = optionsBuilder .setDetectorMode(CustomObjectDetectorOptions.SINGLE_IMAGE_MODE) .enableClassification() .setClassificationConfidenceThreshold(0.5f) .setMaxPerObjectLabelCount(3) .build(); ObjectDetector objectDetector = ObjectDetection.getClient(customObjectDetectorOptions); } });
Si vous ne disposez que d'un modèle hébergé à distance, vous devez désactiver les paramètres
(par exemple, griser ou masquer une partie de l'interface utilisateur),
vous confirmez que le modèle a été téléchargé. Pour ce faire, rattachez un écouteur
à la méthode download()
du gestionnaire de modèles:
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. } });
3. Préparer l'image d'entrée
Créez un objetInputImage
à partir de votre image.
Le détecteur d'objets s'exécute directement à partir d'un Bitmap
, d'un ByteBuffer
NV21 ou d'un
YUV_420_888 media.Image
Créer un InputImage
à partir de ces sources
recommandé si vous disposez d'un accès direct à l'un d'entre eux. Si vous construisez un
InputImage
provenant d'autres sources, nous gérerons la conversion en interne pour
vous et elle pourrait
être moins efficace.
Vous pouvez créer un InputImage
de différentes sources. Chacune d'elles est expliquée ci-dessous.
Utiliser un media.Image
Pour créer un InputImage
à partir d'un objet media.Image
, par exemple lorsque vous capturez une image à partir d'un
l'appareil photo de l'appareil, transmettez l'objet media.Image
et l'image
la rotation sur InputImage.fromMediaImage()
.
Si vous utilisez les
<ph type="x-smartling-placeholder"></ph>
la bibliothèque CameraX, les OnImageCapturedListener
et
Les classes ImageAnalysis.Analyzer
calculent la valeur de rotation
pour vous.
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 // ... } } }
Si vous n'utilisez pas de bibliothèque d'appareils photo qui indique le degré de rotation de l'image, le calcul à partir du degré de rotation de l'appareil et de l'orientation de la caméra capteur de l'appareil:
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; }
Ensuite, transmettez l'objet media.Image
et
valeur du degré de rotation sur InputImage.fromMediaImage()
:
Kotlin
val image = InputImage.fromMediaImage(mediaImage, rotation)
Java
InputImage image = InputImage.fromMediaImage(mediaImage, rotation);
Utiliser un URI de fichier
Pour créer un InputImage
à partir d'un URI de fichier, transmettez le contexte de l'application et l'URI du fichier à
InputImage.fromFilePath()
Cela est utile lorsque vous
Utiliser un intent ACTION_GET_CONTENT
pour inviter l'utilisateur à sélectionner
une image de son application Galerie.
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(); }
Utiliser un ByteBuffer
ou un ByteArray
Pour créer un InputImage
d'un objet ByteBuffer
ou ByteArray
, calculez d'abord l'image
degré de rotation décrit précédemment pour l'entrée media.Image
.
Ensuite, créez l'objet InputImage
avec le tampon ou le tableau, ainsi que l'objet image
la hauteur, la largeur, le format d'encodage des couleurs et le degré de rotation:
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 );
Utiliser un Bitmap
Pour créer un InputImage
à partir d'un objet Bitmap
, effectuez la déclaration suivante:
Kotlin
val image = InputImage.fromBitmap(bitmap, 0)
Java
InputImage image = InputImage.fromBitmap(bitmap, rotationDegree);
L'image est représentée par un objet Bitmap
associé à des degrés de rotation.
4. Exécuter le détecteur d'objets
Kotlin
objectDetector .process(image) .addOnFailureListener(e -> {...}) .addOnSuccessListener(results -> { for (detectedObject in results) { // ... } });
Java
objectDetector .process(image) .addOnFailureListener(e -> {...}) .addOnSuccessListener(results -> { for (DetectedObject detectedObject : results) { // ... } });
5. Obtenir des informations sur les objets étiquetés
Si l'appel à process()
aboutit, une liste de DetectedObject
est transmise à
l'écouteur de réussite.
Chaque DetectedObject
contient les propriétés suivantes:
Cadre de délimitation | Un Rect qui indique la position de l'objet dans
l'image. |
||||||
ID de suivi | Entier qui identifie l'objet dans les images. Null dans SINGLE_IMAGE_MODE | ||||||
Libellés |
|
Kotlin
// The list of detected objects contains one item if multiple // object detection wasn't enabled. for (detectedObject in results) { val boundingBox = detectedObject.boundingBox val trackingId = detectedObject.trackingId for (label in detectedObject.labels) { val text = label.text val index = label.index val confidence = label.confidence } }
Java
// The list of detected objects contains one item if multiple // object detection wasn't enabled. for (DetectedObject detectedObject : results) { Rect boundingBox = detectedObject.getBoundingBox(); Integer trackingId = detectedObject.getTrackingId(); for (Label label : detectedObject.getLabels()) { String text = label.getText(); int index = label.getIndex(); float confidence = label.getConfidence(); } }
Garantir une expérience utilisateur optimale
Pour une expérience utilisateur optimale, suivez ces consignes dans votre application:
- La réussite d'une détection d'objets dépend de sa complexité visuelle. Dans pour être détectés, les objets dotés d'un petit nombre de caractéristiques visuelles peuvent avoir besoin pour occuper une plus grande partie de l'image. Vous devez fournir aux utilisateurs des conseils sur en capturant une entrée qui fonctionne bien avec le type d'objets que vous souhaitez détecter.
- Quand vous utilisez la classification, si vous souhaitez détecter les objets qui ne tombent pas correctement dans les catégories prises en charge, implémenter un traitement spécial pour les d'objets.
Consultez également les Application de présentation Material Design de ML Kit et Material Design Modèles pour la collection de fonctionnalités basées sur le machine learning
Amélioration des performances
Si vous souhaitez utiliser la détection d'objets dans une application en temps réel, suivez ces pour obtenir des fréquences d'images optimales:Lorsque vous utilisez le mode de traitement par flux dans une application en temps réel, n'utilisez pas plusieurs la détection d'objets, car la plupart des appareils ne sont pas en mesure de produire des fréquences d'images adéquates.
- Si vous utilisez les
Camera
ou APIcamera2
limiter les appels au détecteur. Si une nouvelle vidéo devient disponible pendant l'exécution du détecteur, supprimez la trame. Consultez le <ph type="x-smartling-placeholder"></ph>VisionProcessorBase
de l'application exemple de démarrage rapide. - Si vous utilisez l'API
CameraX
, Assurez-vous que la stratégie de contre-pression est définie sur sa valeur par défaut <ph type="x-smartling-placeholder"></ph>ImageAnalysis.STRATEGY_KEEP_ONLY_LATEST
Cela garantit qu'une seule image à la fois sera envoyée pour analyse. Si davantage d'images sont générées lorsque l'analyseur est occupé, elles sont automatiquement abandonnées et ne sont pas mises en file d'attente la livraison. Une fois que l'image en cours d'analyse est fermée en appelant ImageProxy.close(), l'image suivante la plus récente sera diffusée. - Si vous utilisez la sortie du détecteur pour superposer des graphiques sur
l'image d'entrée, récupérez d'abord le résultat à partir de ML Kit, puis effectuez le rendu de l'image.
et les superposer en une seule étape. Le rendu à la surface d'affichage
une seule fois pour chaque
trame d'entrée. Consultez le
<ph type="x-smartling-placeholder"></ph>
CameraSourcePreview
et <ph type="x-smartling-placeholder"></ph>GraphicOverlay
de l'application exemple de démarrage rapide. - Si vous utilisez l'API Camera2, capturez des images
Format
ImageFormat.YUV_420_888
. Si vous utilisez l'ancienne API Camera, capturez les images FormatImageFormat.NV21
.