Guide de démarrage rapide pour Android

Restez organisé à l'aide des collections Enregistrez et classez les contenus selon vos préférences.

Cette page vous montre comment créer une application Android avec TensorFlow Lite pour analyser un flux de caméra en direct et identifier des objets. Ce cas d'utilisation d'apprentissage automatique est appelé détection d'objet . L'exemple d'application utilise la bibliothèque de tâches TensorFlow Lite pour la vision via les services Google Play afin de permettre l'exécution du modèle d'apprentissage automatique de détection d'objets, qui est l'approche recommandée pour créer une application ML avec TensorFlow Lite.

Démo animée de détection d'objets

Configurer et exécuter l'exemple

Pour la première partie de cet exercice, téléchargez l' exemple de code depuis GitHub et exécutez-le à l'aide d' Android Studio . Les sections suivantes de ce document explorent les sections pertinentes de l'exemple de code, afin que vous puissiez les appliquer à vos propres applications Android. Vous devez installer les versions suivantes de ces outils :

  • Android Studio 4.2 ou supérieur
  • Android SDK version 21 ou supérieure

Obtenir l'exemple de code

Créez une copie locale de l'exemple de code afin de pouvoir le générer et l'exécuter.

Pour cloner et configurer l'exemple de code :

  1. Cloner le dépôt git
    git clone https://github.com/tensorflow/examples.git
  2. Configurez votre instance git pour utiliser le sparse checkout, de sorte que vous n'ayez que les fichiers pour l'exemple d'application de détection d'objet :
    cd examples
git sparse-checkout init --cone
git sparse-checkout set lite/examples/object_detection/android_play_services

Importer et exécuter le projet

Utilisez Android Studio pour créer un projet à partir de l'exemple de code téléchargé, créez le projet et exécutez-le.

Pour importer et créer l'exemple de projet de code :

  1. Démarrez Android Studio .
  2. Sur la page d' accueil d'Android Studio, choisissez Importer un projet ou sélectionnez Fichier > Nouveau > Importer un projet .
  3. Accédez au répertoire de code d'exemple contenant le fichier build.gradle ( ...examples/lite/examples/object_detection/android_play_services/build.gradle ) et sélectionnez ce répertoire.

Après avoir sélectionné ce répertoire, Android Studio crée un nouveau projet et le construit. Une fois la construction terminée, Android Studio affiche un message BUILD SUCCESSFUL dans le panneau d'état de la sortie de construction.

Pour exécuter le projet :

  1. Depuis Android Studio, exécutez le projet en sélectionnant Exécuter > Exécuter… et MainActivity .
  2. Sélectionnez un appareil Android connecté avec une caméra pour tester l'application.

Fonctionnement de l'exemple d'application

L'exemple d'application utilise un modèle de détection d'objet pré-entraîné, tel que mobilenetv1.tflite , au format TensorFlow Lite pour rechercher des objets dans un flux vidéo en direct à partir de la caméra d'un appareil Android. Le code de cette fonctionnalité se trouve principalement dans ces fichiers :

  • ObjectDetectorHelper.kt - Initialise l'environnement d'exécution, active l'accélération matérielle et exécute le modèle ML de détection d'objets.
  • CameraFragment.kt - Construit le flux de données d'image de la caméra, prépare les données pour le modèle et affiche les résultats de la détection d'objet.

Les sections suivantes vous montrent les composants clés de ces fichiers de code, vous pouvez donc modifier une application Android pour ajouter cette fonctionnalité.

Créer l'application

Les sections suivantes expliquent les étapes clés pour créer votre propre application Android et exécuter le modèle présenté dans l'exemple d'application. Ces instructions utilisent l'exemple d'application présenté précédemment comme point de référence.

Ajouter des dépendances de projet

Dans votre application Android de base, ajoutez les dépendances du projet pour exécuter les modèles d'apprentissage automatique TensorFlow Lite et accéder aux fonctions de l'utilitaire de données ML. Ces fonctions utilitaires convertissent des données telles que des images dans un format de données de tenseur qui peut être traité par un modèle.

L'exemple d'application utilise la bibliothèque de tâches TensorFlow Lite pour la vision des services Google Play afin de permettre l'exécution du modèle d'apprentissage automatique de détection d'objets. Les instructions suivantes expliquent comment ajouter les dépendances de bibliothèque requises à votre propre projet d'application Android.

Pour ajouter des dépendances de module :

  1. Dans le module d'application Android qui utilise TensorFlow Lite, mettez à jour le fichier build.gradle du module pour inclure les dépendances suivantes. Dans l'exemple de code, ce fichier se trouve ici : ...examples/lite/examples/object_detection/android_play_services/app/build.gradle

    ...
dependencies {
...
    // Tensorflow Lite dependencies
    implementation 'org.tensorflow:tensorflow-lite-task-vision-play-services:0.4.2'
    implementation 'com.google.android.gms:play-services-tflite-gpu:16.1.0'
...
}

  2. Dans Android Studio, synchronisez les dépendances du projet en sélectionnant : File > Sync Project with Gradle Files .

Initialiser les services Google Play

Lorsque vous utilisez les services Google Play pour exécuter des modèles TensorFlow Lite, vous devez initialiser le service avant de pouvoir l'utiliser. Si vous souhaitez utiliser la prise en charge de l'accélération matérielle avec le service, telle que l'accélération GPU, vous activez également cette prise en charge dans le cadre de cette initialisation.

Pour initialiser TensorFlow Lite avec les services Google Play :

  1. Créez un objet TfLiteInitializationOptions et modifiez-le pour activer la prise en charge du GPU :

    val options = TfLiteInitializationOptions.builder()
    .setEnableGpuDelegateSupport(true)
    .build()

  2. Utilisez la méthode TfLiteVision.initialize() pour activer l'utilisation de l'environnement d'exécution des services Play et définissez un écouteur pour vérifier qu'il s'est chargé avec succès :

    TfLiteVision.initialize(context, options).addOnSuccessListener {
    objectDetectorListener.onInitialized()
}.addOnFailureListener {
    // Called if the GPU Delegate is not supported on the device
    TfLiteVision.initialize(context).addOnSuccessListener {
        objectDetectorListener.onInitialized()
    }.addOnFailureListener{
        objectDetectorListener.onError("TfLiteVision failed to initialize: "
                + it.message)
    }
}

Initialiser l'interpréteur de modèle ML

Initialisez l'interpréteur de modèle d'apprentissage automatique TensorFlow Lite en chargeant le fichier de modèle et en définissant les paramètres du modèle. Un modèle TensorFlow Lite inclut un fichier .tflite contenant le code du modèle. Vous devez stocker vos modèles dans le répertoire src/main/assets de votre projet de développement, par exemple :

.../src/main/assets/mobilenetv1.tflite`

Pour initialiser le modèle :

  1. Ajoutez un fichier de modèle .tflite au répertoire src/main/assets de votre projet de développement, tel que ssd_mobilenet_v1 .

  2. Définissez la variable modelName pour spécifier le nom de fichier de votre modèle de ML :

    val modelName = "mobilenetv1.tflite"

  3. Définissez les options du modèle, telles que le seuil de prédiction et la taille de l'ensemble de résultats :

    val optionsBuilder =
    ObjectDetector.ObjectDetectorOptions.builder()
        .setScoreThreshold(threshold)
        .setMaxResults(maxResults)

  4. Activez l'accélération GPU avec les options et autorisez le code à échouer correctement si l'accélération n'est pas prise en charge sur l'appareil :

    try {
    optionsBuilder.useGpu()
} catch(e: Exception) {
    objectDetectorListener.onError("GPU is not supported on this device")
}

  5. Utilisez les paramètres de cet objet pour créer un objet ObjectDetector TensorFlow Lite contenant le modèle :

    objectDetector =
    ObjectDetector.createFromFileAndOptions(
        context, modelName, optionsBuilder.build())

Pour plus d'informations sur l'utilisation des délégués d'accélération matérielle avec TensorFlow Lite, consultez Délégués TensorFlow Lite .

Préparer les données pour le modèle

Vous préparez les données pour l'interprétation par le modèle en transformant les données existantes telles que les images au format de données Tensor , afin qu'elles puissent être traitées par votre modèle. Les données d'un Tensor doivent avoir des dimensions ou une forme spécifiques qui correspondent au format des données utilisées pour former le modèle. Selon le modèle que vous utilisez, vous devrez peut-être transformer les données pour qu'elles correspondent aux attentes du modèle. L'exemple d'application utilise un objet ImageAnalysis pour extraire des cadres d'image du sous-système de caméra.

Pour préparer les données pour le traitement par le modèle :

  1. Créez un objet ImageAnalysis pour extraire des images au format requis :

    imageAnalyzer =
    ImageAnalysis.Builder()
        .setTargetAspectRatio(AspectRatio.RATIO_4_3)
        .setTargetRotation(fragmentCameraBinding.viewFinder.display.rotation)
        .setBackpressureStrategy(ImageAnalysis.STRATEGY_KEEP_ONLY_LATEST)
        .setOutputImageFormat(OUTPUT_IMAGE_FORMAT_RGBA_8888)
        .build()
        ...

  2. Connectez l'analyseur au sous-système de la caméra et créez un tampon bitmap pour contenir les données reçues de la caméra :

            .also {
        it.setAnalyzer(cameraExecutor) { image ->
            if (!::bitmapBuffer.isInitialized) {
                bitmapBuffer = Bitmap.createBitmap(
                    image.width,
                    image.height,
                    Bitmap.Config.ARGB_8888
                )
            }
            detectObjects(image)
        }
    }

  3. Extrayez les données d'image spécifiques nécessaires au modèle et transmettez les informations de rotation d'image :

    private fun detectObjects(image: ImageProxy) {
    // Copy out RGB bits to the shared bitmap buffer
    image.use { bitmapBuffer.copyPixelsFromBuffer(image.planes[0].buffer) }
    val imageRotation = image.imageInfo.rotationDegrees
    objectDetectorHelper.detect(bitmapBuffer, imageRotation)
}

  4. Effectuez toutes les transformations de données finales et ajoutez les données d'image à un objet TensorImage , comme indiqué dans la méthode ObjectDetectorHelper.detect() de l'exemple d'application :

    val imageProcessor = ImageProcessor.Builder().add(Rot90Op(-imageRotation / 90)).build()

// Preprocess the image and convert it into a TensorImage for detection.
val tensorImage = imageProcessor.process(TensorImage.fromBitmap(image))

Exécuter des prédictions

Une fois que vous avez créé un objet TensorImage avec des données d'image au format correct, vous pouvez exécuter le modèle sur ces données pour produire une prédiction ou une inférence . Dans l'exemple d'application, ce code est contenu dans la méthode ObjectDetectorHelper.detect() .

Pour exécuter un modèle et générer des prédictions à partir de données d'image :

  • Exécutez la prédiction en transmettant les données d'image à votre fonction de prédiction :

    val results = objectDetector?.detect(tensorImage)

Gérer la sortie du modèle

Une fois que vous avez exécuté des données d'image sur le modèle de détection d'objet, il produit une liste de résultats de prédiction que votre code d'application doit gérer en exécutant une logique métier supplémentaire, en affichant les résultats à l'utilisateur ou en effectuant d'autres actions. Le modèle de détection d'objets dans l'exemple d'application produit une liste de prédictions et de cadres de délimitation pour les objets détectés. Dans l'exemple d'application, les résultats de la prédiction sont transmis à un objet écouteur pour un traitement ultérieur et affichés à l'utilisateur.

Pour gérer les résultats de prédiction du modèle :

  1. Utilisez un modèle d'écouteur pour transmettre les résultats au code de votre application ou aux objets de l'interface utilisateur. L'exemple d'application utilise ce modèle pour transmettre les résultats de détection de l'objet ObjectDetectorHelper à l'objet CameraFragment :

    objectDetectorListener.onResults( // instance of CameraFragment
    results,
    inferenceTime,
    tensorImage.height,
    tensorImage.width)

  2. Agir sur les résultats, comme afficher la prédiction à l'utilisateur. L'exemple d'application dessine une superposition sur l'objet CameraPreview pour afficher le résultat :

    override fun onResults(
  results: MutableList<Detection>?,
  inferenceTime: Long,
  imageHeight: Int,
  imageWidth: Int
) {
    activity?.runOnUiThread {
        fragmentCameraBinding.bottomSheetLayout.inferenceTimeVal.text =
            String.format("%d ms", inferenceTime)

        // Pass necessary information to OverlayView for drawing on the canvas
        fragmentCameraBinding.overlay.setResults(
            results ?: LinkedList<Detection>(),
            imageHeight,
            imageWidth
        )

        // Force a redraw
        fragmentCameraBinding.overlay.invalidate()
    }
}

Prochaines étapes