Reconnaître des fleurs avec TensorFlow Lite sur Android

1. Introduction

Remarque: Cet atelier de programmation nécessite un appareil physique pour tester

TensorFlow est un framework de machine learning polyvalent. TensorFlow peut être utilisé partout, de l'entraînement de modèles volumineux sur des clusters dans le cloud à l'exécution de modèles en local sur un système intégré comme votre téléphone.

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

Installez Android Studio 4.1 ou version ultérieure

Si ce n'est pas déjà fait, 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

• 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 afin d'intégrer le modèle personnalisé dans une application Android à l'aide de CameraX
• Comment utiliser le GPU sur 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 des fleurs.

Licence: Sans frais

2. Entraîner un programme 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 Colab, qui montre comment entraîner un classificateur avec Keras pour reconnaître des fleurs à l'aide de l'apprentissage par transfert TensorFlow Lite.

Assurez-vous de:

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

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 nécessaires 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 allez travailler dans la suite de cet atelier de programmation:

cd TFLClassify

4. Configurer l'application squelette Android

Installez Android Studio 4.1 ou version ultérieure

Si ce n'est pas déjà fait, 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 "Ouvrir un projet existant". dans ce pop-up:

2. Dans le sélecteur de fichiers, choisissez 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 un indice.

3. Le message "Gradle Sync" (Synchronisation Gradle) s'affiche. la première fois que vous ouvrez le projet, vous demandant comment utiliser le wrapper Gradle. Cliquez sur "OK".

4. Activez le modèle de développeur et le débogage USB sur votre téléphone, si ce n'est pas déjà fait. Cette configuration n'est à effectuer qu'une seule fois. Suivez ces instructions.
5. Une fois que votre projet et votre téléphone sont prêts, vous pouvez l'exécuter sur un appareil réel en sélectionnant TFL_Classify.start et en appuyant sur le bouton d'exécution dans la barre d'outils:

6. À présent, autorisez 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 de l'emplacement d'affichage des résultats réels.

5. Ajouter TensorFlow Lite à l'application Android

1. Sélectionnez le module start dans l'explorateur de projets à 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 dans lequel vous avez téléchargé l'FlowerModel.tflite d'entraînement personnalisé précédemment.

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

4. Cliquez sur Finish.
5. Vous verrez ce qui suit à la fin. Le fichier FlowerModel.tflite a bien été importé. 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 la liste de toutes les tâches

La liste de tâches 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 vos futurs travaux. Vous pouvez ajouter des tâches à l'aide de commentaires de code et saisir le mot clé TODO. Pour accéder à la liste des tâches, vous pouvez:

1. Un bon moyen de voir ce que nous allons faire est de consulter la liste de tâches. Pour ce faire, sélectionnez View dans la barre de menu supérieure > Tool Windows > TODO

2. Par défaut, il répertorie toutes les TODO dans tous les modules, ce qui rend le processus un peu déroutant. Pour trier uniquement les premières tâches à effectuer, cliquez sur le bouton "Grouper par" sur le côté du panneau "TODO" et sélectionnez 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. Ensuite, initialisez le modèle en ajoutant la ligne suivante:

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'analyseur CameraX, nous devons convertir l'entrée ImageProxy de l'appareil photo en Bitmap et créer un objet TensorImage pour le processus d'inférence.

Notez que les outils actuels nécessitent que l'entrée d'image soit au format Bitmap.

• Cela signifie que si l'entrée est un fichier et non ImageProxy, vous pouvez l'alimenter directement dans la méthode fromBitmap en tant qu'objet Bitmap.
• Si vous souhaitez savoir comment convertir ImageProxy en Bitmap, consultez la méthode toBitmap et YuvToRgbConverter. Ces méthodes devraient être temporairement nécessaires, 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 probabilité par ordre décroissant sous l'attribut score en commençant par la probabilité la plus élevée.
• Prenons les k premiers résultats, tels que 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 voyons 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 et en appuyant sur le bouton d'exécution de la barre d'outils:

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

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

TensorFlow Lite est compatible avec plusieurs accélérateurs matériels qui permettent d'accélérer l'inférence sur votre appareil mobile. Le GPU, un accélérateur assez simple à utiliser, TensorFlow Lite via un mécanisme de délégation.

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

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

Remarque: nous allons ajouter cette importation manuellement dans cet atelier de programmation. Toutefois, lorsque vous effectuez cette opération dans votre projet, il vous suffit de 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 de tâches. Remplacez l'initiation simple de flowerModel par ce qui suit: obtenez une instance de la liste de compatibilité GPU et initialisez le GPU selon qu'il fait partie des GPU compatibles listés. 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 du modèle pour l'utiliser 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 et en appuyant sur le bouton d'exécution de la barre d'outils:

Sur un appareil mobile moyen/haut de gamme, le GPU est beaucoup plus rapide que le processeur. Les appareils bas de gamme ont tendance à avoir des GPU plus lents, donc la vitesse constatée peut varier.

9. Étapes suivantes

Voici quelques liens pour en savoir plus:

• Essayez d'autres modèles TFLite compatibles avec la liaison de modèles de ML disponibles sur tfhub.dev.
• Pour en savoir plus sur TFLite, consultez la documentation sur tensorflow.org et le dépôt de code.
• Essayez d'autres modèles pré-entraînés TFLite, tels qu'un détecteur vocal de mots clés et une version intégrée des réponses suggérées.
• Pour en savoir plus sur TensorFlow en général, consultez notre documentation de démarrage.