Après avoir entraîné votre propre modèle à l'aide d'AutoML Vision Edge, vous pouvez l'utiliser dans votre application pour détecter des objets dans des images.
Il existe deux façons d'intégrer des modèles entraînés à partir d'AutoML Vision Edge : regroupez le modèle en le plaçant dans le dossier des composants de votre application, ou vous pouvez téléchargez-la dynamiquement depuis Firebase.
Options de regroupement des modèles | |
---|---|
Intégré à votre application |
|
Hébergé avec Firebase |
|
Avant de commencer
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.
Ajoutez les dépendances de la bibliothèque de tâches TensorFlow Lite 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 { // ... // Object detection with a bundled Auto ML model implementation 'org.tensorflow:tensorflow-lite-task-vision:0.0.0-nightly-SNAPSHOT' }
Pour télécharger un modèle de manière dynamique depuis Firebase, ajoutez également Firebase ML la dépendance:
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. Charger le modèle
Configurer la source d'un modèle local
Pour empaqueter le modèle avec votre application:
- Extrayez le modèle de l'archive ZIP que vous avez téléchargée à partir du Console Google Cloud.
- Inclure votre modèle dans le package de votre application:
- Si vous n'avez pas de dossier de composants dans votre projet, créez-en un
faites un clic droit sur le dossier
app/
, puis cliquez sur Nouveau > Dossier > Dossier des composants. - Copiez le fichier de modèle
tflite
avec les métadonnées intégrées aux éléments .
- Si vous n'avez pas de dossier de composants dans votre projet, créez-en un
faites un clic droit sur le dossier
Ajoutez 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" } }
Le fichier de modèle sera inclus dans le package de l'application et disponible en tant qu'élément brut.
Configurer une source de modèle hébergé 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é :
Java
// 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()
Lancez 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 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:
Java
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.
}
De nombreuses applications démarrent 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 détecteur d'objets à partir de votre modèle
Après avoir configuré vos sources de modèle, créez un objet ObjectDetector
à partir de l'une d'elles.
Si vous ne disposez que d'un modèle groupé localement, il vous suffit de créer un détecteur d'objets à partir de votre fichier de modèle et configurer le score de confiance le seuil souhaité (voir Évaluer votre modèle):
Java
// 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)
Si vous disposez d'un modèle hébergé à distance, vous devez vérifier qu'il a été
téléchargée 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.
Même s'il vous suffit de confirmer cela avant d'exécuter le détecteur d'objets, 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'objets: créez une le détecteur d'objets du modèle distant s'il a été téléchargé, et à partir du modèle local dans le cas contraire.
Java
FirebaseModelManager.getInstance().isModelDownloaded(remoteModel)
.addOnSuccessListener(new OnSuccessListener<Boolean>() {
@Override
public void onSuccess(Boolean isDownloaded) {
}
});
Kotlin
FirebaseModelManager.getInstance().isModelDownloaded(remoteModel)
.addOnSuccessListener { success ->
}
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, joignez un écouteur à la méthode download()
du gestionnaire de modèles.
Une fois que vous savez que votre modèle a été téléchargé, créez un détecteur d'objets à partir de fichier de modèle:
Java
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. Préparer l'image d'entrée
Ensuite, pour chaque image à laquelle vous souhaitez ajouter une étiquette, créez un objet TensorImage
à partir de votre
l'image. Vous pouvez créer un objet TensorImage
à partir d'un Bitmap
à l'aide de la méthode
Méthode fromBitmap
:
Java
TensorImage image = TensorImage.fromBitmap(bitmap);
Kotlin
val image = TensorImage.fromBitmap(bitmap)
Si vos données d'image ne se trouvent pas dans un Bitmap
, vous pouvez charger un tableau de pixels comme indiqué dans
la documentation TensorFlow Lite.
3. Exécuter le détecteur d'objets
Pour détecter des objets dans une image, transmettez l'objet TensorImage
à la
La méthode detect()
de ObjectDetector
.
Java
List<Detection> results = objectDetector.detect(image);
Kotlin
val results = objectDetector.detect(image)
4. Obtenir des informations sur les objets étiquetés
Si l'opération de détection d'objets aboutit, elle renvoie une liste de Detection
.
d'objets. Chaque objet Detection
représente un élément détecté dans le
l'image. Vous pouvez obtenir le cadre de délimitation de chaque objet et ses étiquettes.
Exemple :
Java
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()
}
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 pour obtenir des fréquences d'images optimales:
- 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 le cadre. Consultez les
VisionProcessorBase
de l'application exemple de démarrage rapide. - Si vous utilisez la sortie du libelléur d'images pour superposer des éléments graphiques à l'image d'entrée, obtenez d'abord le résultat, puis affichez l'image et la superposition en une seule étape. Cela vous permet d'afficher
sur la surface d'affichage
une seule fois pour chaque
trame d'entrée. Consultez les
CameraSourcePreview
etGraphicOverlay
de l'application exemple de démarrage rapide pour une à titre d'exemple. -
Si vous utilisez l'API Camera2, capturez des images Format
ImageFormat.YUV_420_888
.Si vous utilisez l'ancienne API Camera, capturez les images Format
ImageFormat.NV21
.