Ajouter une étiquette à des images avec un modèle entraîné par AutoML sur Android
Après avoir entraîné votre propre modèle à l'aide d'AutoML Vision Edge, vous pouvez l'utiliser dans votre application pour ajouter des étiquettes aux images. Il existe deux façons d'intégrer des modèles entraînés à partir d'AutoML Vision Edge: vous pouvez regrouper le modèle en le plaçant dans le dossier d'éléments de votre application, ou le télécharger dynamiquement depuis Firebase.Options de regroupement de modèles | |
---|---|
Regroupé dans votre application |
|
Hébergé avec Firebase |
|
Essayer
- Jouez avec l'application exemple pour voir un exemple d'utilisation de cette API.
Avant de commencer
1. Dans le fichierbuild.gradle
de niveau projet, veillez à inclure
le dépôt Maven de Google à la fois dans les sections
buildscript
et allprojects
.2. Ajoutez les dépendances des bibliothèques Android de ML Kit au fichier Gradle au niveau de l'application de votre module, qui est généralement
app/build.gradle
:
Pour regrouper un modèle avec votre application :
dependencies { // ... // Image labeling feature with bundled automl model implementation 'com.google.mlkit:image-labeling-automl:16.2.1' }Pour télécharger un modèle de manière dynamique à partir de Firebase, ajoutez la dépendance
linkFirebase
:
dependencies { // ... // Image labeling feature with automl model downloaded // from firebase implementation 'com.google.mlkit:image-labeling-automl:16.2.1' implementation 'com.google.mlkit:linkfirebase:16.0.1' }3. Si vous souhaitez télécharger un modèle, veillez à ajouter Firebase à votre projet Android, si ce n'est pas déjà fait. Cela n'est pas nécessaire lorsque vous regroupez le modèle.
1. Charger le modèle
Configurer une source de modèle locale
Pour grouper le modèle avec votre application:1. Extrayez le modèle et ses métadonnées à partir de l'archive ZIP que vous avez téléchargée depuis la console Firebase. Nous vous recommandons d'utiliser les fichiers tels que vous les avez téléchargés, sans les modifier (y compris les noms de fichiers).
2. Incluez votre modèle et ses fichiers de métadonnées dans le package de votre application:
a. Si vous n'avez pas de dossier d'éléments dans votre projet, créez-en un en effectuant un clic droit sur le dossier
app/
, puis en cliquant sur Nouveau > Dossier > Dossier d'éléments.b. Créez un sous-dossier sous le dossier "assets" qui contiendra les fichiers de modèle.
c. Copiez les fichiers
model.tflite
, dict.txt
et manifest.json
dans le sous-dossier (les trois fichiers doivent se trouver dans le même dossier).3. Ajoutez le code suivant au fichier
build.gradle
de votre application pour vous assurer que Gradle ne compresse pas le fichier de modèle lors de la compilation :
android { // ... aaptOptions { noCompress "tflite" } }Le fichier de modèle sera inclus dans le package de l'application et mis à la disposition de ML Kit en tant qu'élément brut.
Remarque: À partir de la version 4.1 du plug-in Android Gradle, .tflite sera ajouté par défaut à la liste noCompress. Les éléments ci-dessus ne seront plus nécessaires.
4. Créez un objet
LocalModel
en spécifiant le chemin d'accès au fichier manifeste du modèle:
Kotlin
val localModel = AutoMLImageLabelerLocalModel.Builder() .setAssetFilePath("manifest.json") // or .setAbsoluteFilePath(absolute file path to manifest file) .build()
Java
AutoMLImageLabelerLocalModel localModel = new AutoMLImageLabelerLocalModel.Builder() .setAssetFilePath("manifest.json") // or .setAbsoluteFilePath(absolute file path to manifest file) .build();
Configurer une source de modèle hébergée sur Firebase
Pour utiliser le modèle hébergé à distance, créez un objet RemoteModel
en spécifiant le nom que vous avez attribué au modèle lorsque vous l'avez publié:
Kotlin
// Specify the name you assigned in the Firebase console. val remoteModel = AutoMLImageLabelerRemoteModel.Builder("your_model_name").build()
Java
// Specify the name you assigned in the Firebase console. AutoMLImageLabelerRemoteModel remoteModel = new AutoMLImageLabelerRemoteModel.Builder("your_model_name").build();
Démarrez ensuite la tâche de téléchargement du modèle en spécifiant les conditions dans lesquelles vous souhaitez autoriser le téléchargement. Si le modèle n'est pas sur l'appareil ou si une version plus récente du modèle est disponible, la tâche télécharge le modèle de manière asynchrone à partir de 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 commencent la tâche de téléchargement dans leur code d'initialisation, mais vous pouvez le faire à tout moment avant d'avoir besoin d'utiliser le modèle.
Créer un étiqueteur d'images à partir de votre modèle
Après avoir configuré les sources de votre modèle, créez un objet ImageLabeler
à partir de l'une d'entre elles.
Si vous ne disposez que d'un modèle groupé localement, il vous suffit de créer un étiqueteur à partir de votre objet AutoMLImageLabelerLocalModel
et de configurer le seuil de score de confiance que vous souhaitez exiger (voir Évaluer votre modèle):
Kotlin
val autoMLImageLabelerOptions = AutoMLImageLabelerOptions.Builder(localModel) .setConfidenceThreshold(0) // Evaluate your model in the Firebase console // to determine an appropriate value. .build() val labeler = ImageLabeling.getClient(autoMLImageLabelerOptions)
Java
AutoMLImageLabelerOptions autoMLImageLabelerOptions = new AutoMLImageLabelerOptions.Builder(localModel) .setConfidenceThreshold(0.0f) // Evaluate your model in the Firebase console // to determine an appropriate value. .build(); ImageLabeler labeler = ImageLabeling.getClient(autoMLImageLabelerOptions)
Si vous disposez d'un modèle hébergé à distance, vous devez vérifier qu'il a été téléchargé avant de l'exécuter. Vous pouvez vérifier l'état de la tâche de téléchargement du modèle à l'aide de la méthode isModelDownloaded()
du gestionnaire de modèles.
Bien que vous n'ayez qu'à vérifier cela avant d'exécuter l'étiqueteur, si vous disposez à la fois d'un modèle hébergé à distance et d'un modèle groupé localement, il peut être judicieux d'effectuer cette vérification lors de l'instanciation de l'étiqueteur: créez un étiqueteur à partir du modèle distant s'il a été téléchargé, et à partir du modèle local dans le cas contraire.
Kotlin
RemoteModelManager.getInstance().isModelDownloaded(remoteModel) .addOnSuccessListener { isDownloaded -> val optionsBuilder = if (isDownloaded) { AutoMLImageLabelerOptions.Builder(remoteModel) } else { AutoMLImageLabelerOptions.Builder(localModel) } // Evaluate your model in the Firebase console to determine an appropriate threshold. val options = optionsBuilder.setConfidenceThreshold(0.0f).build() val labeler = ImageLabeling.getClient(options) }
Java
RemoteModelManager.getInstance().isModelDownloaded(remoteModel) .addOnSuccessListener(new OnSuccessListener() { @Override public void onSuccess(Boolean isDownloaded) { AutoMLImageLabelerOptions.Builder optionsBuilder; if (isDownloaded) { optionsBuilder = new AutoMLImageLabelerOptions.Builder(remoteModel); } else { optionsBuilder = new AutoMLImageLabelerOptions.Builder(localModel); } AutoMLImageLabelerOptions options = optionsBuilder .setConfidenceThreshold(0.0f) // Evaluate your model in the Firebase console // to determine an appropriate threshold. .build(); ImageLabeler labeler = ImageLabeling.getClient(options); } });
Si vous ne disposez que d'un modèle hébergé à distance, vous devez désactiver les fonctionnalités liées au modèle (par exemple, griser ou masquer une partie de l'interface utilisateur) jusqu'à ce que vous confirmiez que le modèle a été téléchargé. Pour ce faire, associez 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. } });
2. Préparer l'image d'entrée
Ensuite, pour chaque image à étiqueter, créez un objet InputImage
à partir de votre image. L'étiqueteur d'image fonctionne plus rapidement lorsque vous utilisez un Bitmap
ou, si vous utilisez l'API Camera2, un media.Image
YUV_420_888, qui sont recommandés lorsque cela est possible.
Vous pouvez créer un objet InputImage
à partir de différentes sources, expliquées ci-dessous.
Utiliser un media.Image
Pour créer un objet InputImage
à partir d'un objet media.Image
, par exemple lorsque vous capturez une image avec l'appareil photo d'un appareil, transmettez l'objet media.Image
et la rotation de l'image à InputImage.fromMediaImage()
.
Si vous utilisez la bibliothèque
Camera Camera, les classes OnImageCapturedListener
et ImageAnalysis.Analyzer
calculent automatiquement la valeur de rotation.
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 fournit le degré de rotation de l'image, vous pouvez le calculer à partir du degré de rotation de l'appareil et de l'orientation du capteur de l'appareil photo 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; }
Transmettez ensuite l'objet media.Image
et la valeur du degré de rotation à 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 objet 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 utilisez un intent ACTION_GET_CONTENT
pour inviter l'utilisateur à sélectionner une image dans 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 objet InputImage
à partir d'un ByteBuffer
ou d'un ByteArray
, commencez par calculer le degré de rotation de l'image comme décrit précédemment pour l'entrée media.Image
.
Créez ensuite l'objet InputImage
avec le tampon ou le tableau, ainsi que la hauteur, la largeur, le format d'encodage des couleurs et le degré de rotation de l'image:
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 objet 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
accompagné de degrés de rotation.
3. Exécuter l'étiqueteur d'images
Pour étiqueter des objets dans une image, transmettez l'objetimage
à la méthode process()
de ImageLabeler
.
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. Obtenir des informations sur les objets étiquetés
Si l'opération d'ajout d'étiquettes à l'image aboutit, une liste d'objets ImageLabel
est transmise à l'écouteur de réussite. Chaque objet ImageLabel
représente un élément étiqueté dans l'image. Vous pouvez obtenir la description textuelle de chaque étiquette, le score de confiance et l'indice de la correspondance.
Exemple :
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(); }
Conseils pour améliorer les performances en temps réel
Si vous souhaitez étiqueter des images dans une application en temps réel, suivez ces consignes pour obtenir les meilleures fréquences d'images:
- Si vous utilisez l'API
Camera
oucamera2
, limitez les appels à l'étiqueteur d'images. Si une nouvelle image vidéo devient disponible pendant que l'étiqueteur d'images est en cours d'exécution, déposez l'image. Consultez la classeVisionProcessorBase
dans l'exemple d'application de démarrage rapide pour voir un exemple. - Si vous utilisez l'API
CameraX
, assurez-vous que la stratégie de contre-pression est définie sur sa valeur par défautImageAnalysis.STRATEGY_KEEP_ONLY_LATEST
. Cela garantit qu'une seule image à la fois sera diffusée pour analyse. Si davantage d'images sont produites alors que l'analyseur est occupé, elles seront automatiquement supprimées et ne seront pas mises en file d'attente pour la diffusion. Une fois l'image analysée fermée en appelant ImageProxy.close(), la dernière image suivante sera diffusée. - Si vous utilisez la sortie de l'étiqueteur d'images pour superposer des éléments graphiques à l'image d'entrée, obtenez d'abord le résultat de ML Kit, puis affichez l'image et la superposition en une seule étape. La surface d'affichage n'est donc rendue qu'une seule fois pour chaque image d'entrée. Consultez les classes
CameraSourcePreview
etGraphicOverlay
dans l'exemple d'application de démarrage rapide pour voir un exemple. - Si vous utilisez l'API Camera2, capturez des images au format
ImageFormat.YUV_420_888
. Si vous utilisez l'ancienne API Camera, capturez des images au formatImageFormat.NV21
.