Après avoir entraîné votre propre modèle à l'aide d'AutoML Vision Edge, vous pouvez l'utiliser dans votre application pour étiqueter des images.
Avant de commencer
- Si ce n'est pas déjà fait, ajoutez Firebase à votre projet Android.
- Ajoutez les dépendances pour les bibliothèques Android ML Kit au fichier Gradle (généralement
app/build.gradle
) de votre module (au niveau de l'application) :apply plugin: 'com.android.application' apply plugin: 'com.google.gms.google-services' dependencies { // ... implementation 'com.google.firebase:firebase-ml-vision:24.0.3' implementation 'com.google.firebase:firebase-ml-vision-automl:18.0.5' }
1. Charger le modèle
ML Kit exécute vos modèles générés par AutoML sur l'appareil. Toutefois, vous pouvez configurer ML Kit pour charger votre modèle à distance depuis Firebase, depuis le stockage local ou les deux.
En hébergeant le modèle sur Firebase, vous pouvez le mettre à jour sans publier une nouvelle version de l'application. Vous pouvez également utiliser Remote Config et A/B Testing pour diffuser dynamiquement différents modèles à différents ensembles d'utilisateurs.
Si vous choisissez de ne fournir que le modèle en l'hébergeant avec Firebase, et de ne pas l'inclure dans votre application, vous pouvez réduire la taille du téléchargement initial de votre application. Toutefois, gardez à l'esprit que si le modèle n'est pas inclus dans votre application, toutes les fonctionnalités associées au modèle ne seront pas disponibles tant que votre application n'aura pas téléchargé le modèle pour la première fois.
En regroupant votre modèle avec votre application, vous pouvez vous assurer que les fonctionnalités de ML de votre application fonctionnent toujours lorsque le modèle hébergé sur Firebase n'est pas disponible.
Configurer une source de modèle hébergée par Firebase
Pour utiliser le modèle hébergé à distance, créez un objet FirebaseAutoMLRemoteModel
en spécifiant le nom que vous avez attribué au modèle lors de sa publication :
Java
// Specify the name you assigned in the Firebase console.
FirebaseAutoMLRemoteModel remoteModel =
new FirebaseAutoMLRemoteModel.Builder("your_remote_model").build();
Kotlin
// Specify the name you assigned in the Firebase console.
val remoteModel = FirebaseAutoMLRemoteModel.Builder("your_remote_model").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 Firebase de manière asynchrone :
Java
FirebaseModelDownloadConditions conditions = new FirebaseModelDownloadConditions.Builder()
.requireWifi()
.build();
FirebaseModelManager.getInstance().download(remoteModel, conditions)
.addOnCompleteListener(new OnCompleteListener<Void>() {
@Override
public void onComplete(@NonNull Task<Void> task) {
// Success.
}
});
Kotlin
val conditions = FirebaseModelDownloadConditions.Builder()
.requireWifi()
.build()
FirebaseModelManager.getInstance().download(remoteModel, conditions)
.addOnCompleteListener {
// Success.
}
De nombreuses applications lancent 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.
Configurer une source de modèle local
Pour regrouper le modèle avec votre application :
- Extrayez le modèle et ses métadonnées 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).
-
Incluez votre modèle et ses fichiers de métadonnées dans le package de votre application :
- Si votre projet ne comporte pas de dossier d'éléments, créez-en un en effectuant un clic droit sur le dossier
app/
, puis en cliquant sur Nouveau > Dossier > Dossier d'éléments. - Créez un sous-dossier dans le dossier des composants pour contenir les fichiers du modèle.
- Copiez les fichiers
model.tflite
,dict.txt
etmanifest.json
dans le sous-dossier (les trois fichiers doivent se trouver dans le même dossier).
- Si votre projet ne comporte pas de dossier d'éléments, créez-en un en effectuant un clic 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 de modèle lors de la compilation de l'application : Le fichier de modèle sera inclus dans le package de l'application et disponible pour ML Kit en tant qu'asset brut.android { // ... aaptOptions { noCompress "tflite" } }
- Créez un objet
FirebaseAutoMLLocalModel
en spécifiant le chemin d'accès au fichier manifeste du modèle :Java
FirebaseAutoMLLocalModel localModel = new FirebaseAutoMLLocalModel.Builder() .setAssetFilePath("manifest.json") .build();
Kotlin
val localModel = FirebaseAutoMLLocalModel.Builder() .setAssetFilePath("manifest.json") .build()
Créer un outil de classification d'images à partir de votre modèle
Après avoir configuré vos sources de modèle, créez un objet FirebaseVisionImageLabeler
à partir de l'une d'elles.
Si vous ne disposez que d'un modèle groupé localement, créez simplement un outil de libellisation à partir de votre objet FirebaseAutoMLLocalModel
et configurez le seuil de score de confiance que vous souhaitez exiger (voir Évaluer votre modèle) :
Java
FirebaseVisionImageLabeler labeler;
try {
FirebaseVisionOnDeviceAutoMLImageLabelerOptions options =
new FirebaseVisionOnDeviceAutoMLImageLabelerOptions.Builder(localModel)
.setConfidenceThreshold(0.0f) // Evaluate your model in the Firebase console
// to determine an appropriate value.
.build();
labeler = FirebaseVision.getInstance().getOnDeviceAutoMLImageLabeler(options);
} catch (FirebaseMLException e) {
// ...
}
Kotlin
val options = FirebaseVisionOnDeviceAutoMLImageLabelerOptions.Builder(localModel)
.setConfidenceThreshold(0) // Evaluate your model in the Firebase console
// to determine an appropriate value.
.build()
val labeler = FirebaseVision.getInstance().getOnDeviceAutoMLImageLabeler(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 du modèle à l'aide de la méthode isModelDownloaded()
du gestionnaire de modèles.
Bien que vous n'ayez à confirmer cela qu'avant d'exécuter le labeler, si vous disposez à la fois d'un modèle hébergé à distance et d'un modèle regroupé localement, il peut être judicieux d'effectuer cette vérification lors de l'instanciation du labeler d'images : créez un labeler à partir 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) {
FirebaseVisionOnDeviceAutoMLImageLabelerOptions.Builder optionsBuilder;
if (isDownloaded) {
optionsBuilder = new FirebaseVisionOnDeviceAutoMLImageLabelerOptions.Builder(remoteModel);
} else {
optionsBuilder = new FirebaseVisionOnDeviceAutoMLImageLabelerOptions.Builder(localModel);
}
FirebaseVisionOnDeviceAutoMLImageLabelerOptions options = optionsBuilder
.setConfidenceThreshold(0.0f) // Evaluate your model in the Firebase console
// to determine an appropriate threshold.
.build();
FirebaseVisionImageLabeler labeler;
try {
labeler = FirebaseVision.getInstance().getOnDeviceAutoMLImageLabeler(options);
} catch (FirebaseMLException e) {
// Error.
}
}
});
Kotlin
FirebaseModelManager.getInstance().isModelDownloaded(remoteModel)
.addOnSuccessListener { isDownloaded ->
val optionsBuilder =
if (isDownloaded) {
FirebaseVisionOnDeviceAutoMLImageLabelerOptions.Builder(remoteModel)
} else {
FirebaseVisionOnDeviceAutoMLImageLabelerOptions.Builder(localModel)
}
// Evaluate your model in the Firebase console to determine an appropriate threshold.
val options = optionsBuilder.setConfidenceThreshold(0.0f).build()
val labeler = FirebaseVision.getInstance().getOnDeviceAutoMLImageLabeler(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 votre UI) jusqu'à ce que vous confirmiez que le modèle a été téléchargé. Pour ce faire, vous pouvez associer un écouteur à la méthode download()
du gestionnaire de modèles :
Java
FirebaseModelManager.getInstance().download(remoteModel, conditions)
.addOnSuccessListener(new OnSuccessListener<Void>() {
@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.
}
});
Kotlin
FirebaseModelManager.getInstance().download(remoteModel, conditions)
.addOnCompleteListener {
// 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 que vous souhaitez étiqueter, créez un objet FirebaseVisionImage
à l'aide de l'une des options décrites dans cette section, puis transmettez-le à une instance de FirebaseVisionImageLabeler
(décrite dans la section suivante).
Vous pouvez créer un objet FirebaseVisionImage
à partir d'un objet media.Image
, d'un fichier sur l'appareil, d'un tableau d'octets ou d'un objet Bitmap
:
-
Pour créer un objet
FirebaseVisionImage
à partir d'un objetmedia.Image
, par exemple lors de la capture d'une image à partir de l'appareil photo d'un appareil, transmettez l'objetmedia.Image
et la rotation de l'image àFirebaseVisionImage.fromMediaImage()
.Si vous utilisez la bibliothèque CameraX, les classes
OnImageCapturedListener
etImageAnalysis.Analyzer
calculent la valeur de rotation pour vous. Il vous suffit donc de convertir la rotation en l'une des constantesROTATION_
de ML Kit avant d'appelerFirebaseVisionImage.fromMediaImage()
:Java
private class YourAnalyzer implements ImageAnalysis.Analyzer { private int degreesToFirebaseRotation(int degrees) { switch (degrees) { case 0: return FirebaseVisionImageMetadata.ROTATION_0; case 90: return FirebaseVisionImageMetadata.ROTATION_90; case 180: return FirebaseVisionImageMetadata.ROTATION_180; case 270: return FirebaseVisionImageMetadata.ROTATION_270; default: throw new IllegalArgumentException( "Rotation must be 0, 90, 180, or 270."); } } @Override public void analyze(ImageProxy imageProxy, int degrees) { if (imageProxy == null || imageProxy.getImage() == null) { return; } Image mediaImage = imageProxy.getImage(); int rotation = degreesToFirebaseRotation(degrees); FirebaseVisionImage image = FirebaseVisionImage.fromMediaImage(mediaImage, rotation); // Pass image to an ML Kit Vision API // ... } }
Kotlin
private class YourImageAnalyzer : ImageAnalysis.Analyzer { private fun degreesToFirebaseRotation(degrees: Int): Int = when(degrees) { 0 -> FirebaseVisionImageMetadata.ROTATION_0 90 -> FirebaseVisionImageMetadata.ROTATION_90 180 -> FirebaseVisionImageMetadata.ROTATION_180 270 -> FirebaseVisionImageMetadata.ROTATION_270 else -> throw Exception("Rotation must be 0, 90, 180, or 270.") } override fun analyze(imageProxy: ImageProxy?, degrees: Int) { val mediaImage = imageProxy?.image val imageRotation = degreesToFirebaseRotation(degrees) if (mediaImage != null) { val image = FirebaseVisionImage.fromMediaImage(mediaImage, imageRotation) // Pass image to an ML Kit Vision API // ... } } }
Si vous n'utilisez pas de bibliothèque d'appareil photo qui vous donne la rotation de l'image, vous pouvez la calculer à partir de la rotation de l'appareil et de l'orientation du capteur de l'appareil photo dans l'appareil :
Java
private static final SparseIntArray ORIENTATIONS = new SparseIntArray(); static { ORIENTATIONS.append(Surface.ROTATION_0, 90); ORIENTATIONS.append(Surface.ROTATION_90, 0); ORIENTATIONS.append(Surface.ROTATION_180, 270); ORIENTATIONS.append(Surface.ROTATION_270, 180); } /** * 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, Context context) 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); // On most devices, the sensor orientation is 90 degrees, but for some // devices it is 270 degrees. For devices with a sensor orientation of // 270, rotate the image an additional 180 ((270 + 270) % 360) degrees. CameraManager cameraManager = (CameraManager) context.getSystemService(CAMERA_SERVICE); int sensorOrientation = cameraManager .getCameraCharacteristics(cameraId) .get(CameraCharacteristics.SENSOR_ORIENTATION); rotationCompensation = (rotationCompensation + sensorOrientation + 270) % 360; // Return the corresponding FirebaseVisionImageMetadata rotation value. int result; switch (rotationCompensation) { case 0: result = FirebaseVisionImageMetadata.ROTATION_0; break; case 90: result = FirebaseVisionImageMetadata.ROTATION_90; break; case 180: result = FirebaseVisionImageMetadata.ROTATION_180; break; case 270: result = FirebaseVisionImageMetadata.ROTATION_270; break; default: result = FirebaseVisionImageMetadata.ROTATION_0; Log.e(TAG, "Bad rotation value: " + rotationCompensation); } return result; }
Kotlin
private val ORIENTATIONS = SparseIntArray() init { ORIENTATIONS.append(Surface.ROTATION_0, 90) ORIENTATIONS.append(Surface.ROTATION_90, 0) ORIENTATIONS.append(Surface.ROTATION_180, 270) ORIENTATIONS.append(Surface.ROTATION_270, 180) } /** * 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, context: Context): 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) // On most devices, the sensor orientation is 90 degrees, but for some // devices it is 270 degrees. For devices with a sensor orientation of // 270, rotate the image an additional 180 ((270 + 270) % 360) degrees. val cameraManager = context.getSystemService(CAMERA_SERVICE) as CameraManager val sensorOrientation = cameraManager .getCameraCharacteristics(cameraId) .get(CameraCharacteristics.SENSOR_ORIENTATION)!! rotationCompensation = (rotationCompensation + sensorOrientation + 270) % 360 // Return the corresponding FirebaseVisionImageMetadata rotation value. val result: Int when (rotationCompensation) { 0 -> result = FirebaseVisionImageMetadata.ROTATION_0 90 -> result = FirebaseVisionImageMetadata.ROTATION_90 180 -> result = FirebaseVisionImageMetadata.ROTATION_180 270 -> result = FirebaseVisionImageMetadata.ROTATION_270 else -> { result = FirebaseVisionImageMetadata.ROTATION_0 Log.e(TAG, "Bad rotation value: $rotationCompensation") } } return result }
Transmettez ensuite l'objet
media.Image
et la valeur de rotation àFirebaseVisionImage.fromMediaImage()
:Java
FirebaseVisionImage image = FirebaseVisionImage.fromMediaImage(mediaImage, rotation);
Kotlin
val image = FirebaseVisionImage.fromMediaImage(mediaImage, rotation)
- Pour créer un objet
FirebaseVisionImage
à partir d'un URI de fichier, transmettez le contexte de l'application et l'URI de fichier àFirebaseVisionImage.fromFilePath()
. Cela est utile lorsque vous utilisez un intentACTION_GET_CONTENT
pour inviter l'utilisateur à sélectionner une image dans son application Galerie.Java
FirebaseVisionImage image; try { image = FirebaseVisionImage.fromFilePath(context, uri); } catch (IOException e) { e.printStackTrace(); }
Kotlin
val image: FirebaseVisionImage try { image = FirebaseVisionImage.fromFilePath(context, uri) } catch (e: IOException) { e.printStackTrace() }
- Pour créer un objet
FirebaseVisionImage
à partir d'unByteBuffer
ou d'un tableau d'octets, commencez par calculer la rotation de l'image comme décrit ci-dessus pour l'entréemedia.Image
.Créez ensuite un objet
FirebaseVisionImageMetadata
contenant la hauteur, la largeur, le format d'encodage des couleurs et la rotation de l'image :Java
FirebaseVisionImageMetadata metadata = new FirebaseVisionImageMetadata.Builder() .setWidth(480) // 480x360 is typically sufficient for .setHeight(360) // image recognition .setFormat(FirebaseVisionImageMetadata.IMAGE_FORMAT_NV21) .setRotation(rotation) .build();
Kotlin
val metadata = FirebaseVisionImageMetadata.Builder() .setWidth(480) // 480x360 is typically sufficient for .setHeight(360) // image recognition .setFormat(FirebaseVisionImageMetadata.IMAGE_FORMAT_NV21) .setRotation(rotation) .build()
Utilisez le tampon ou le tableau, ainsi que l'objet de métadonnées, pour créer un objet
FirebaseVisionImage
:Java
FirebaseVisionImage image = FirebaseVisionImage.fromByteBuffer(buffer, metadata); // Or: FirebaseVisionImage image = FirebaseVisionImage.fromByteArray(byteArray, metadata);
Kotlin
val image = FirebaseVisionImage.fromByteBuffer(buffer, metadata) // Or: val image = FirebaseVisionImage.fromByteArray(byteArray, metadata)
- Pour créer un objet
FirebaseVisionImage
à partir d'un objetBitmap
:Java
FirebaseVisionImage image = FirebaseVisionImage.fromBitmap(bitmap);
Kotlin
val image = FirebaseVisionImage.fromBitmap(bitmap)
Bitmap
doit être à l'endroit, sans rotation supplémentaire requise.
3. Exécuter l'outil de classification d'images
Pour libeller des objets dans une image, transmettez l'objet FirebaseVisionImage
à la méthode processImage()
de FirebaseVisionImageLabeler
.
Java
labeler.processImage(image)
.addOnSuccessListener(new OnSuccessListener<List<FirebaseVisionImageLabel>>() {
@Override
public void onSuccess(List<FirebaseVisionImageLabel> labels) {
// Task completed successfully
// ...
}
})
.addOnFailureListener(new OnFailureListener() {
@Override
public void onFailure(@NonNull Exception e) {
// Task failed with an exception
// ...
}
});
Kotlin
labeler.processImage(image)
.addOnSuccessListener { labels ->
// Task completed successfully
// ...
}
.addOnFailureListener { e ->
// Task failed with an exception
// ...
}
Si l'étiquetage des images réussit, un tableau d'objets FirebaseVisionImageLabel
est transmis au listener de réussite. À partir de chaque objet, vous pouvez obtenir des informations sur une caractéristique reconnue dans l'image.
Exemple :
Java
for (FirebaseVisionImageLabel label: labels) {
String text = label.getText();
float confidence = label.getConfidence();
}
Kotlin
for (label in labels) {
val text = label.text
val confidence = label.confidence
}
Conseils pour améliorer les performances en temps réel
- Limitez les appels au détecteur. Si une nouvelle image vidéo devient disponible pendant l'exécution du détecteur, supprimez-la.
- Si vous utilisez la sortie du détecteur pour superposer des éléments graphiques sur l'image d'entrée, commencez par obtenir le résultat de ML Kit, puis affichez l'image et la superposition en une seule étape. Vous effectuez ainsi le rendu sur la surface d'affichage une seule fois pour chaque frame d'entrée.
-
Si vous utilisez l'API Camera2, capturez les images au format
ImageFormat.YUV_420_888
.Si vous utilisez l'ancienne API Camera, capturez les images au format
ImageFormat.NV21
.