Guide de démarrage rapide pour Android

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 de l'apprentissage automatique est appelé détection d'objets . 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
  • SDK Android version 21 ou supérieure

Obtenez l'exemple de code

Créez une copie locale de l'exemple de code afin de pouvoir le créer 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 une extraction fragmentée, afin de disposer uniquement des fichiers pour l'exemple d'application de détection d'objets :
    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é, générer le projet et l'exécuter.

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

  1. Démarrez Android Studio .
  2. Sur la page de bienvenue 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 sortie de construction .

Pour exécuter le projet :

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

Comment fonctionne l'exemple d'application

L'exemple d'application utilise un modèle de détection d'objets pré-entraîné, tel que mobilenetv1.tflite , au format TensorFlow Lite pour rechercher des objets dans un flux vidéo en direct provenant 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 - Crée 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 détection d'objets.

Les sections suivantes vous montrent les composants clés de ces fichiers de code, afin que vous puissiez 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 des 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 tensoriel 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 : Fichier > Synchroniser le projet avec les fichiers Gradle .

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 du runtime des services Play et définissez un écouteur pour vérifier qu'il a été chargé correctement :

    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 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 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 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 l'échec du code 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 TensorFlow Lite ObjectDetector contenant le modèle :

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

Pour plus d'informations sur l'utilisation de 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 entraîner le modèle. Selon le modèle que vous utilisez, vous devrez peut-être transformer les données pour les adapter aux attentes du modèle. L'exemple d'application utilise un objet ImageAnalysis pour extraire les images du sous-système de caméra.

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

  1. Créez un objet ImageAnalysis pour extraire les 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 de l'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 le modèle et générer des prédictions à partir des 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'objets, celui-ci 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 d'écoute pour un traitement ultérieur et un affichage à l'utilisateur.

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

  1. Utilisez un modèle d'écoute 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. Agissez sur les résultats, par exemple en affichant 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