Reconnaître des fleurs avec TensorFlow Lite sur Android

1. Introduction

Remarque : Cet atelier de programmation utilise la bibliothèque TensorFlow Lite. Nous vous recommandons d'utiliser l'outil bibliothèque Google AI Edge LiteRT pour tout nouveau code.

Remarque : Cet atelier de programmation nécessite un appareil physique pour les tests.

TensorFlow est un framework de machine learning polyvalent. TensorFlow peut être utilisé dans le cloud, pour entraîner des modèles volumineux sur des clusters, ou en local, pour exécuter des modèles sur un système intégré, comme un téléphone.

Cet atelier de programmation utilise TensorFlow Lite pour exécuter un modèle de reconnaissance d'images sur un appareil Android.

Installer Android Studio 4.1 ou version ultérieure

Si vous ne l'avez pas encore installé, téléchargez et installez Android Studio 4.1 ou version ultérieure pendant que vous entraînez votre modèle TensorFlow Lite.

Points abordés

• Découvrez comment entraîner votre propre classificateur d'images personnalisé à l'aide de TensorFlow Lite Model Maker.
• Utiliser Android Studio pour importer le modèle TensorFlow Lite et intégrer le modèle personnalisé dans une application Android à l'aide de CameraX.
• Découvrez comment utiliser le GPU de votre téléphone pour accélérer votre modèle.

Objectifs de l'atelier

Application d'appareil photo simple qui exécute un programme de reconnaissance d'image TensorFlow pour identifier les fleurs.

Licence : Utilisation sans frais

2. Entraîner un outil de reconnaissance de fleurs à l'aide de Colab

Avant de commencer l'entraînement du modèle, téléchargez et installez Android Studio 4.1 ou version ultérieure.

Ouvrez le notebook Colab qui montre comment entraîner un classificateur avec Keras pour reconnaître les fleurs à l'aide de l'apprentissage par transfert TensorFlow Lite.

Assurez-vous de :

1. vous avez téléchargé le modèle entraîné (model.tflite) ;
2. a renommé le fichier FlowerModel.tflite

avant de continuer.

Certains navigateurs bloquent les téléchargements :

Vous devrez peut-être autoriser Colab à télécharger les fichiers :

3. Configurer le répertoire de travail

Cloner le dépôt Git

La commande suivante clone le dépôt Git contenant les fichiers requis pour cet atelier de programmation :

git clone https://github.com/hoitab/TFLClassify.git

Ensuite, accédez au répertoire dans lequel vous venez de cloner le dépôt. C'est là que vous travaillerez pour le reste de cet atelier de programmation :

cd TFLClassify

4. Configurer l'application squelette Android

Installer Android Studio 4.1 ou version ultérieure

Si vous ne l'avez pas encore installé, installez Android Studio 4.1 ou version ultérieure.

Ouvrir le projet avec Android Studio

Pour ouvrir un projet avec Android Studio, procédez comme suit :

1. Ouvrez Android Studio . Une fois le chargement terminé, sélectionnez "Open an Existing project" (Ouvrir un projet existant) dans le pop-up suivant :

2. Dans le sélecteur de fichiers, sélectionnez TFLClassify/build.gradle dans votre répertoire de travail.

Le projet contient deux modules, start et finish. Si vous rencontrez des difficultés, consultez le module finish pour obtenir de l'aide.

3. Lorsque vous ouvrez le projet pour la première fois, un pop-up "Gradle Sync" s'affiche. Il vous demande si vous souhaitez utiliser le wrapper Gradle. Cliquez sur "OK".

4. Si ce n'est pas déjà fait, activez le mode développeur et le débogage USB sur votre téléphone. Il s'agit d'une configuration unique. Suivez ces instructions.
5. Une fois votre projet et votre téléphone prêts, vous pouvez l'exécuter sur un appareil réel en sélectionnant TFL_Classify.start, puis en appuyant sur le bouton d'exécution  dans la barre d'outils :

6. Autorisez maintenant la démonstration Tensorflow à accéder à votre appareil photo :

7. L'écran suivant s'affiche sur votre téléphone, avec des nombres aléatoires à la place des résultats réels.

5. Ajouter TensorFlow Lite à l'application Android

1. Sélectionnez le module start dans l'explorateur de projet sur la gauche :

2. Effectuez un clic droit sur le module start ou cliquez sur File, puis sur New > Other > TensorFlow Lite Model.

3. Sélectionnez l'emplacement du modèle où vous avez téléchargé le FlowerModel.tflite entraîné personnalisé précédemment.

Notez que l'outil configurera la dépendance du module en votre nom avec la liaison de modèle ML et que toutes les dépendances seront automatiquement insérées dans le fichier build.gradle de votre module Android.

4. Cliquez sur Finish.
5. Les informations suivantes s'affichent à la fin. Le fichier FlowerModel.tflite a été importé avec succès. Il affiche des informations générales sur le modèle, y compris les entrées / sorties, ainsi qu'un exemple de code pour vous aider à démarrer.

6. Facultatif : Consulter toutes les listes de tâches

La liste TODO permet d'accéder facilement à l'emplacement exact où vous devez mettre à jour l'atelier de programmation. Vous pouvez également l'utiliser dans votre projet Android pour vous rappeler des tâches à venir. Vous pouvez ajouter des tâches à faire à l'aide de commentaires de code et en saisissant le mot clé TODO. Pour accéder à la liste des tâches à faire, vous pouvez :

1. Pour avoir une idée de ce que nous allons faire, consultez la liste des tâches. Pour ce faire, sélectionnez dans la barre de menu supérieure View > Tool Windows > TODO.

2. Par défaut, il liste tous les éléments à faire dans tous les modules, ce qui peut être un peu déroutant. Nous pouvons trier uniquement les tâches TODO de début en cliquant sur le bouton "Grouper par" sur le côté du panneau TODO et en choisissant Modules.

3. Développez tous les éléments sous les modules de démarrage :

7. Exécuter le modèle personnalisé avec TensorFlow Lite

1. Cliquez sur "TODO 1" dans la liste TODO ou ouvrez le fichier MainActivity.kt et localisez "TODO 1". Initialisez le modèle en ajoutant cette ligne :

private class ImageAnalyzer(ctx: Context, private val listener: RecognitionListener) :
        ImageAnalysis.Analyzer {

  ...
  // TODO 1: Add class variable TensorFlow Lite Model
  private val flowerModel = FlowerModel.newInstance(ctx)

  ...
}

2. Dans la méthode d'analyse de l'outil d'analyse CameraX, nous devons convertir l'entrée de la caméra ImageProxy en Bitmap et créer un objet TensorImage pour le processus d'inférence.

Notez que les outils actuels nécessitent que les images saisies soient au format Bitmap.

• Cela signifie que si l'entrée est un fichier et non ImageProxy, vous pouvez l'envoyer directement à la méthode fromBitmap en tant qu'objet Bitmap.
• Si vous souhaitez savoir comment ImageProxy est converti en Bitmap, veuillez consulter la méthode toBitmap et YuvToRgbConverter. Nous pensons que ces méthodes ne seront nécessaires que temporairement, car l'équipe travaille à la prise en charge de ImageProxy pour TensorImage.

override fun analyze(imageProxy: ImageProxy) {
  ...
  // TODO 2: Convert Image to Bitmap then to TensorImage
  val tfImage = TensorImage.fromBitmap(toBitmap(imageProxy))
  ...
}

3. Traitez l'image et effectuez les opérations suivantes sur le résultat :

• Triez les résultats par ordre décroissant de probabilité sous l'attribut score, en commençant par la probabilité la plus élevée.
• Prenez les k premiers résultats définis par la constante MAX_RESULT_DISPLAY. Vous pouvez éventuellement faire varier la valeur de cette variable pour obtenir plus ou moins de résultats.

override fun analyze(imageProxy: ImageProxy) {
  ...
  // TODO 3: Process the image using the trained model, sort and pick out the top results
  val outputs = flowerModel.process(tfImage)
      .probabilityAsCategoryList.apply {
          sortByDescending { it.score } // Sort with highest confidence first
      }.take(MAX_RESULT_DISPLAY) // take the top results

  ...
}

4. Convertissez les résultats triés et filtrés en objets de données Recognition prêts à être utilisés par RecyclerView via la liaison de données :

override fun analyze(imageProxy: ImageProxy) {
  ...
  // TODO 4: Converting the top probability items into a list of recognitions
  for (output in outputs) {
      items.add(Recognition(output.label, output.score))
  }
  ...
}

5. Mettez en commentaire ou supprimez les lignes suivantes qui permettent de générer les faux résultats que nous avons vus précédemment :

// START - Placeholder code at the start of the codelab. Comment this block of code out.
for (i in 0..MAX_RESULT_DISPLAY-1){
    items.add(Recognition("Fake label $i", Random.nextFloat()))
}
// END - Placeholder code at the start of the codelab. Comment this block of code out.

8. Exécutez l'application sur un appareil réel en sélectionnant TFL_Classify.start, puis appuyez sur le bouton d'exécution  dans la barre d'outils :

9. L'écran suivant s'affiche sur votre téléphone, avec des nombres aléatoires à la place des résultats réels :

8. Facultatif : Accélérer l'inférence avec le délégué GPU

TensorFlow Lite est compatible avec plusieurs accélérateurs matériels pour accélérer l'inférence sur votre appareil mobile. Le GPU est l'un des accélérateurs que TensorFlow Lite peut exploiter grâce à un mécanisme de délégué. Il est assez facile à utiliser.

1. Ouvrez build.gradle sous le module start ou cliquez sur TODO 5 dans la liste des tâches et ajoutez la dépendance suivante :

// TODO 5: Optional GPU Delegates    
implementation 'org.tensorflow:tensorflow-lite-gpu:2.3.0'

Remarque : Nous ajoutons cette importation manuellement dans cet atelier de programmation, mais lorsque vous le ferez dans votre projet, vous pourrez simplement cocher la deuxième case de l'écran d'importation pour ajouter la dépendance d'accélération GPU :

2. Revenez au fichier MainActivity.kt ou cliquez sur TODO 6 dans la liste TODO. Remplacez l'initialisation simple de flowerModel par ce qui suit : obtenez une instance de la liste de compatibilité des GPU et initialisez le GPU en fonction de sa présence dans la liste des GPU compatibles. Sinon, lancez quatre threads de processeur pour exécuter le modèle :

private class ImageAnalyzer(ctx: Context, private val listener: RecognitionListener) :
        ImageAnalysis.Analyzer {
  ...

  // TODO 1: Add class variable TensorFlow Lite Model
  // Initializing the flowerModel by lazy so that it runs in the same thread when the process
  // method is called.
  private val flowerModel: FlowerModel by lazy{

    // TODO 6. Optional GPU acceleration
    val compatList = CompatibilityList()

    val options = if(compatList.isDelegateSupportedOnThisDevice){
        Log.d(TAG, "This device is GPU Compatible ")
        Model.Options.Builder().setDevice(Model.Device.GPU).build()
    } else {
        Log.d(TAG, "This device is GPU Incompatible ")
        Model.Options.Builder().setNumThreads(4).build()
    }

  ...
}

Remarque : Il existe plusieurs objets Model. Choisissez l'objet org.tensorflow.lite.support.model.Model dans votre importation.

3. Modifiez l'initialiseur de modèle pour qu'il l'utilise en ajoutant options à l'entrée de la méthode :

private class ImageAnalyzer(ctx: Context, private val listener: RecognitionListener) :
        ImageAnalysis.Analyzer {

  private val flowerModel: FlowerModel by lazy{

    ...

    // Initialize the Flower Model
    FlowerModel.newInstance(ctx, options)
  }
}

10. Exécutez l'application sur un appareil réel en sélectionnant TFL_Classify.start, puis appuyez sur le bouton d'exécution  dans la barre d'outils :

Sur un appareil mobile de milieu ou de haut de gamme, le GPU est beaucoup plus rapide que le CPU. Les appareils bas de gamme ont tendance à avoir des GPU plus lents. La vitesse de traitement que vous constaterez variera donc.

9. Étapes suivantes

Voici quelques liens pour en savoir plus :

• Essayez d'autres modèles TFLite compatibles avec la liaison de modèles ML depuis tfhub.dev.
• Pour en savoir plus sur TFLite, consultez la documentation sur tensorflow.org et le dépôt de code.
• Testez d'autres modèles préentraînés pour TFLite, tels qu'un détecteur vocal de mots clés ou une version avec Réponse suggérée intégrée directement sur l'appareil.
• Pour en savoir plus sur TensorFlow en général, consultez notre documentation de mise en route.