Démarrage rapide pour Android

Ce didacticiel vous montre comment créer une application Android à l'aide de TensorFlow Lite pour analyser un flux de caméra en direct et identifier des objets à l'aide d'un modèle d'apprentissage automatique, en utilisant une quantité minimale de code. Si vous mettez à jour un projet existant, vous pouvez utiliser l'exemple de code comme référence et passer directement aux instructions de modification de votre projet .

Détection d'objets avec machine learning

Démo animée de détection d'objets Le modèle d'apprentissage automatique de ce didacticiel effectue la détection d'objets. Un modèle de détection d'objets prend des données d'image dans un format spécifique, les analyse et tente de catégoriser les éléments de l'image comme faisant partie d'un ensemble de classes connues qu'il a été entraîné à reconnaître. La vitesse à laquelle un modèle peut identifier un objet connu (appelée prédiction ou inférence d'objet) est généralement mesurée en millisecondes. En pratique, la vitesse d'inférence varie en fonction du matériel hébergeant le modèle, de la taille des données traitées et de la taille du modèle d'apprentissage automatique.

Exemple de configuration et d'exécution

Pour la première partie de ce didacticiel, téléchargez l'exemple à partir de GitHub et exécutez-le à l'aide d' Android Studio . Les sections suivantes de ce didacticiel 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.2 ou supérieur
  • Android SDK version 31 ou supérieure

Obtenir l'exemple de code

Créez une copie locale de l'exemple de code. Vous utiliserez ce code pour créer un projet dans Android Studio et exécuter l'exemple d'application.

Pour cloner et configurer l'exemple de code :

  1. Cloner le dépôt git
    git clone https://github.com/android/camera-samples.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 camera-samples
    git sparse-checkout init --cone
    git sparse-checkout set CameraXAdvanced
    

Importer et exécuter le projet

Créez un projet à partir de l'exemple de code téléchargé, générez le projet, puis 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 ( .../android/camera-samples/CameraXAdvanced/build.gradle ) et sélectionnez ce répertoire.

Si vous sélectionnez le bon répertoire, Android Studio crée un nouveau projet et le construit. Ce processus peut prendre quelques minutes, selon la vitesse de votre ordinateur et si vous avez utilisé Android Studio pour d'autres projets. Une fois la construction terminée, Android Studio affiche un message BUILD SUCCESSFUL dans le panneau d'état de la sortie de construction.

Facultatif : Pour corriger les erreurs de compilation en mettant à jour la version du plug-in Android :

  1. Ouvrez le fichier build.gradle dans le répertoire du projet.
  2. Modifiez la version des outils Android comme suit :

    // from:
    classpath 'com.android.tools.build:gradle:4.2.2'
    // to:
    classpath 'com.android.tools.build:gradle:4.1.2'
    
  3. Synchronisez le projet en sélectionnant : File > Sync Project with Gradle Files .

Pour exécuter le projet :

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

Les sections suivantes vous montrent les modifications que vous devez apporter à votre projet existant pour ajouter cette fonctionnalité à votre propre application, en utilisant cet exemple d'application comme point de référence.

Ajouter des dépendances de projet

Dans votre propre application, vous devez ajouter des dépendances de projet spécifiques pour exécuter des modèles d'apprentissage automatique TensorFlow Lite et accéder à des fonctions utilitaires qui convertissent des données telles que des images dans un format de données de tenseur pouvant être traité par le modèle que vous utilisez.

L'exemple d'application utilise plusieurs bibliothèques TensorFlow Lite pour permettre l'exécution du modèle de machine learning de détection d'objet :

  • Bibliothèque principale de TensorFlow Lite : fournit les classes d'entrée de données requises, l'exécution du modèle d'apprentissage automatique et les résultats de sortie du traitement du modèle.
  • Bibliothèque de prise en charge de TensorFlow Lite - Cette bibliothèque fournit une classe d'assistance pour traduire les images de la caméra en un objet de données TensorImage qui peut être traité par le modèle d'apprentissage automatique.
  • Bibliothèque GPU TensorFlow Lite : cette bibliothèque permet d'accélérer l'exécution du modèle à l'aide de processeurs GPU sur l'appareil, s'ils sont disponibles.

Les instructions suivantes expliquent comment ajouter les dépendances de projet et de module requises à votre propre projet d'application Android.

Pour ajouter des dépendances de module :

  1. Dans le module 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 : .../android/camera-samples/CameraXAdvanced/tflite/build.gradle ( code de référence )

    ...
    dependencies {
    ...
        // Tensorflow lite dependencies
        implementation 'org.tensorflow:tensorflow-lite:2.8.0'
        implementation 'org.tensorflow:tensorflow-lite-gpu:2.8.0'
        implementation 'org.tensorflow:tensorflow-lite-support:2.8.0'
    ...
    }
    
  2. Dans Android Studio, synchronisez les dépendances du projet en sélectionnant : File > Sync Project with Gradle Files .

Initialiser l'interpréteur de modèle ML

Dans votre application Android, vous devez initialiser l'interpréteur de modèle d'apprentissage automatique TensorFlow Lite avec des paramètres avant d'exécuter des prédictions avec le modèle. Ces paramètres d'initialisation dépendent du modèle que vous utilisez et peuvent inclure des paramètres tels que des seuils de précision minimum pour les prédictions et des étiquettes pour les classes d'objets identifiées.

Un modèle TensorFlow Lite inclut un fichier .tflite contenant le code du modèle et inclut fréquemment un fichier d'étiquettes contenant les noms des classes prédites par le modèle. Dans le cas de la détection d'objets, les classes sont des objets tels qu'une personne, un chien, un chat ou une voiture. Les modèles sont généralement stockés dans le répertoire src/main/assets du module principal, comme dans l'exemple de code :

  • CameraXAdvanced/tflite/src/main/assets/coco_ssd_mobilenet_v1_1.0_quant.tflite
  • CameraXAdvanced/tflite/src/main/assets/coco_ssd_mobilenet_v1_1.0_labels.txt

Pour plus de commodité et de lisibilité du code, l'exemple déclare un objet compagnon qui définit les paramètres du modèle.

Pour initialiser le modèle dans votre application :

  1. Créez un objet compagnon pour définir les paramètres du modèle : ( référence de code )

    companion object {
       private val TAG = CameraActivity::class.java.simpleName
    
       private const val ACCURACY_THRESHOLD = 0.5f
       private const val MODEL_PATH = "coco_ssd_mobilenet_v1_1.0_quant.tflite"
       private const val LABELS_PATH = "coco_ssd_mobilenet_v1_1.0_labels.txt"
    }
    
  2. Utilisez les paramètres de cet objet pour créer un objet TensorFlow Lite Interpreter contenant le modèle : ( référence de code )

    private val tflite by lazy {
       Interpreter(
           FileUtil.loadMappedFile(this, MODEL_PATH),
           Interpreter.Options().addDelegate(nnApiDelegate))
    }
    

Configurer l'accélérateur matériel

Lors de l'initialisation d'un modèle TensorFlow Lite dans votre application, vous pouvez utiliser les fonctionnalités d'accélération matérielle pour accélérer les calculs de prédiction du modèle. L'exemple de code ci-dessus utilise le délégué NNAPI pour gérer l'accélération matérielle de l'exécution du modèle :

Interpreter.Options().addDelegate(nnApiDelegate)

Les délégués TensorFlow Lite sont des modules logiciels qui accélèrent l'exécution de modèles d'apprentissage automatique à l'aide d'un matériel de traitement spécialisé sur un appareil mobile, tel que des GPU, des TPU ou des DSP. L'utilisation de délégués pour exécuter des modèles TensorFlow Lite est recommandée, mais pas obligatoire.

Pour plus d'informations sur l'utilisation de délégués avec TensorFlow Lite, consultez Délégués TensorFlow Lite .

Fournir des données au modèle

Dans votre application Android, votre code fournit des données au modèle pour interprétation en transformant des données existantes telles que des images dans un format de données Tensor qui peut être traité 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.

Pour déterminer la forme de tenseur requise pour un modèle :

  • Utilisez l'objet Interpreter initialisé pour déterminer la forme du tenseur utilisé par votre modèle, comme indiqué dans l'extrait de code ci-dessous : ( référence de code )

    private val tfInputSize by lazy {
       val inputIndex = 0
       val inputShape = tflite.getInputTensor(inputIndex).shape()
       Size(inputShape[2], inputShape[1]) // Order of axis is: {1, height, width, 3}
    }
    

Le modèle de détection d'objet utilisé dans l'exemple de code attend des images carrées d'une taille de 300 par 300 pixels.

Avant de pouvoir fournir des images à partir de la caméra, votre application doit prendre l'image, la rendre conforme à la taille attendue, ajuster sa rotation et normaliser les données d'image. Lors du traitement d'images avec un modèle TensorFlow Lite, vous pouvez utiliser la classe ImageProcessor de la bibliothèque de support TensorFlow Lite pour gérer ce prétraitement des données, comme indiqué ci-dessous.

Pour transformer les données d'image d'un modèle :

  1. Utilisez la bibliothèque de support ImageProcessor pour créer un objet permettant de transformer les données d'image dans un format que votre modèle peut utiliser pour exécuter des prédictions : ( référence de code )

    private val tfImageProcessor by lazy {
       val cropSize = minOf(bitmapBuffer.width, bitmapBuffer.height)
       ImageProcessor.Builder()
           .add(ResizeWithCropOrPadOp(cropSize, cropSize))
           .add(ResizeOp(
               tfInputSize.height, tfInputSize.width, ResizeOp.ResizeMethod.NEAREST_NEIGHBOR))
           .add(Rot90Op(-imageRotationDegrees / 90))
           .add(NormalizeOp(0f, 1f))
           .build()
    }
    
  2. Copiez les données d'image du système de caméra Android et préparez-les pour l'analyse avec votre objet ImageProcessor : ( référence de code )

    // Copy out RGB bits to the shared buffer
    image.use { bitmapBuffer.copyPixelsFromBuffer(image.planes[0].buffer)  }
    
    // Process the image in Tensorflow
    val tfImage =  tfImageProcessor.process(tfImageBuffer.apply { load(bitmapBuffer) })
    

Exécuter des prédictions

Dans votre application Android, 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 . L'exemple de code de ce didacticiel utilise une classe ObjectDetectionHelper qui encapsule ce code dans une méthode predict() .

Pour exécuter une prédiction sur un ensemble de données d'image :

  1. Exécutez la prédiction en transmettant les données d'image à votre fonction de prédiction : ( référence de code )

    // Perform the object detection for the current frame
    val predictions = detector.predict(tfImage)
    
  2. Appelez la méthode run sur votre instance d'objet tflite avec les données d'image pour générer des prédictions : ( référence de code )

    fun predict(image: TensorImage): List<ObjectPrediction> {
       tflite.runForMultipleInputsOutputs(arrayOf(image.buffer), outputBuffer)
       return predictions
    }
    

L'objet TensorFlow Lite Interpreter reçoit ces données, les exécute sur le modèle et produit une liste de prédictions. Pour un traitement continu des données par le modèle, utilisez la méthode runForMultipleInputsOutputs() afin que les objets Interpreter ne soient pas créés puis supprimés par le système pour chaque exécution de prédiction.

Gérer la sortie du modèle

Dans votre application Android, après avoir exécuté des données d'image sur le modèle de détection d'objet, il produit une liste de prédictions 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.

La sortie d'un modèle TensorFlow Lite donné varie en fonction du nombre de prédictions qu'il produit (une ou plusieurs) et des informations descriptives pour chaque prédiction. Dans le cas d'un modèle de détection d'objet, les prédictions incluent généralement des données pour une boîte englobante qui indique où un objet est détecté dans l'image. Dans l'exemple de code, les données renvoyées sont formatées sous la forme d'une liste d'objets ObjectPrediction , comme indiqué ci-dessous : ( référence de code )

val predictions get() = (0 until OBJECT_COUNT).map {
   ObjectPrediction(

       // The locations are an array of [0, 1] floats for [top, left, bottom, right]
       location = locations[0][it].let {
           RectF(it[1], it[0], it[3], it[2])
       },

       // SSD Mobilenet V1 Model assumes class 0 is background class
       // in label file and class labels start from 1 to number_of_classes + 1,
       // while outputClasses correspond to class index from 0 to number_of_classes
       label = labels[1 + labelIndices[0][it].toInt()],

       // Score is a single value of [0, 1]
       score = scores[0][it]
   )
}

Capture d'écran de détection d'objet Pour le modèle utilisé dans cet exemple, chaque prédiction inclut un emplacement de cadre de délimitation pour l'objet, une étiquette pour l'objet et un score de prédiction compris entre 0 et 1 en tant que flotteur représentant la confiance de la prédiction, 1 étant le niveau de confiance le plus élevé. . En général, les prédictions avec un score inférieur à 50 % (0,5) sont considérées comme non concluantes. Cependant, la façon dont vous gérez les résultats de prédiction de faible valeur dépend de vous et des besoins de votre application.

Une fois que le modèle a renvoyé un résultat de prédiction, votre application peut agir sur cette prédiction en présentant le résultat à votre utilisateur ou en exécutant une logique supplémentaire. Dans le cas de l'exemple de code, l'application dessine une boîte englobante autour de l'objet identifié et affiche le nom de la classe à l'écran. Consultez la fonction CameraActivity.reportPrediction() dans l'exemple de code pour plus de détails.

Prochaines étapes

  • Découvrez les différentes utilisations de TensorFlow Lite dans les exemples .
  • Apprenez-en plus sur l'utilisation des modèles de machine learning avec TensorFlow Lite dans la section Modèles .
  • En savoir plus sur la mise en œuvre du machine learning dans votre application mobile dans le guide du développeur TensorFlow Lite .