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 les images.
Il existe deux manières d'intégrer des modèles formés à partir d'AutoML Vision Edge : vous pouvez regrouper le modèle en le plaçant dans le dossier d'actifs de votre application, ou vous pouvez le télécharger dynamiquement depuis Firebase.
Options de regroupement de modèles | |
---|---|
Intégré dans votre application |
|
Hébergé avec Firebase |
|
Avant que tu commences
Si vous souhaitez télécharger un modèle , assurez-vous d'ajouter Firebase à votre projet Android , si vous ne l'avez pas déjà fait. Cela n’est pas obligatoire 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 dynamiquement un modèle depuis Firebase, ajoutez également la dépendance Firebase ML :
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. Chargez le modèle
Configurer une source de modèle locale
Pour regrouper le modèle avec votre application :
- Extrayez le modèle de l'archive zip que vous avez téléchargée depuis la console Google Cloud.
- Incluez votre modèle dans votre package d'application :
- Si vous n'avez pas de dossier d'actifs dans votre projet, créez-en un en cliquant avec le bouton droit sur le dossier
app/
, puis en cliquant sur Nouveau > Dossier > Dossier d'actifs . - Copiez votre fichier de modèle
tflite
avec les métadonnées intégrées dans le dossier des ressources.
- Si vous n'avez pas de dossier d'actifs dans votre projet, créez-en un en cliquant avec le bouton droit sur le dossier
Ajoutez les éléments suivants au fichier
build.gradle
de votre application pour vous assurer que Gradle ne compresse pas le fichier modèle lors de la création de l'application :android { // ... aaptOptions { noCompress "tflite" } }
Le fichier modèle sera inclus dans le package d'application et disponible en tant qu'actif brut.
Configurer une source de modèle hébergée par 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 lors de sa publication :
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()
Ensuite, démarrez 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échargera le modèle 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 de devoir utiliser le modèle.
Créez un détecteur d'objet à partir de votre modèle
Après avoir configuré vos sources de modèle, créez un objet ObjectDetector
à partir de l'une d'entre elles.
Si vous disposez uniquement d'un modèle regroupé localement, créez simplement un détecteur d'objets à partir de votre fichier de modèle et configurez le seuil de score de confiance que vous souhaitez exiger (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 devrez 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 de modèle à l'aide de la méthode isModelDownloaded()
du gestionnaire de modèles.
Bien que vous n'ayez qu'à confirmer cela avant d'exécuter le détecteur d'objets, si vous disposez à la fois d'un modèle hébergé à distance et d'un modèle fourni localement, il peut être judicieux d'effectuer cette vérification lors de l'instanciation du détecteur d'objets : créez un détecteur d'objets à partir du modèle distant. model 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 disposez uniquement 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 votre interface utilisateur) jusqu'à ce que vous confirmiez que le modèle a été téléchargé. Vous pouvez le faire en attachant 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'objet à partir du fichier 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éparez l'image d'entrée
Ensuite, pour chaque image que vous souhaitez étiqueter, créez un objet TensorImage
à partir de votre image. Vous pouvez créer un objet TensorImage
à partir d'un Bitmap
à l'aide de la méthode fromBitmap
:
Java
TensorImage image = TensorImage.fromBitmap(bitmap);
Kotlin
val image = TensorImage.fromBitmap(bitmap)
Si vos données d'image ne sont pas dans un Bitmap
, vous pouvez charger un tableau de pixels comme indiqué dans la documentation TensorFlow Lite .
3. Exécutez le détecteur d'objet
Pour détecter des objets dans une image, transmettez l'objet TensorImage
à la méthode detect()
de ObjectDetector
.
Java
List<Detection> results = objectDetector.detect(image);
Kotlin
val results = objectDetector.detect(image)
4. Obtenez des informations sur les objets étiquetés
Si l'opération de détection d'objet réussit, elle renvoie une liste d'objets Detection
. Chaque objet Detection
représente quelque chose qui a été détecté dans l'image. Vous pouvez obtenir le cadre de sélection de chaque objet et ses étiquettes.
Par 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 directives pour obtenir les meilleures fréquences d'images :
- Limitez les appels à l’étiqueteur d’images. Si une nouvelle image vidéo devient disponible pendant l'exécution de l'étiqueteur d'images, supprimez l'image. Consultez la classe
VisionProcessorBase
dans l’exemple d’application de démarrage rapide pour un exemple. - Si vous utilisez la sortie de l'étiqueteur d'image pour superposer des graphiques sur l'image d'entrée, obtenez d'abord le résultat, puis effectuez le rendu de l'image et la superposition en une seule étape. Ce faisant, vous effectuez le rendu sur la surface d'affichage une seule fois pour chaque image d'entrée. Consultez les classes
CameraSourcePreview
etGraphicOverlay
dans l’exemple d’application de démarrage rapide pour 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 format
ImageFormat.NV21
.