Créer et déployer un modèle personnalisé de détection d'objets à l'aide de TensorFlow Lite (Android)

1. Avant de commencer

Dans cet atelier de programmation, vous allez apprendre à entraîner un modèle personnalisé de détection d'objets à l'aide d'un ensemble d'images d'entraînement avecCréateur de modèles TFLite, puis le déployer dans une application Android en utilisantBibliothèque de tâches TFLite dans le menu déroulant ; Vous découvrirez comment :

• Créez une application Android qui détecte les ingrédients dans les images de repas.
• Intégrez un modèle de détection d'objets pré-entraîné TFLite et observez la limite de ce qu'il peut détecter.
• Entraînez un modèle de détection d'objets personnalisé à détecter les ingrédients ou les composants d'un repas à l'aide d'un ensemble de données personnalisé appelé salad et TFLite Model Maker.
• Déployez le modèle personnalisé dans l'application Android à l'aide de la bibliothèque de tâches TFLite.

Pour finir, créez un fichier semblable à l'image ci-dessous:

Conditions préalables

Cet atelier de programmation s'adresse aux développeurs d'applications mobiles expérimentés qui souhaitent maîtriser le machine learning. Vous devez être au fait:

• Développement Android à l'aide de Kotlin et Android Studio
• Syntaxe Python de base

Points abordés

• Entraînement d'un modèle de détection d'objets personnalisé avec TFLite Model Maker
• Déployer un modèle de détection d'objets TFLite à l'aide de la bibliothèque de tâches TFLite

Prérequis

• Une version récente d'Android Studio (version 4.2 ou ultérieure)
• Android Emulator ou appareil Android physique
• L'exemple de code
• Connaissances de base en développement Android en langage Kotlin

2. Détection d'objet

La détection d'objets est un ensemble de tâches de vision par ordinateur qui peuvent détecter et localiser des objets dans une image numérique. À partir d'une image ou d'un flux vidéo, un modèle de détection d'objets peut identifier un ensemble connu d'objets présents et fournir des informations sur leur position dans l'image.

TensorFlow fournit des modèles pré-entraînés et optimisés pour les mobiles, capables de détecter des objets courants tels que les voitures, les oranges, etc. Vous pouvez intégrer ces modèles pré-entraînés dans votre application mobile en seulement quelques lignes de code. Toutefois, nous vous conseillons de détecter les objets dans des catégories plus spécifiques ou décalées. Pour cela, vous devez collecter vos propres images d'entraînement, puis entraîner et déployer votre propre modèle de détection d'objets.

Si vous souhaitez effectuer une détection d'objets générale sans entraîner votre propre modèle, suivez cet atelier de programmation pour apprendre à créer un détecteur d'objets en quelques lignes seulement à l'aide de l'API de détection et d'objets de ML Kit. .

TensorFlow Lite

TensorFlow Lite est une bibliothèque de machine learning multiplate-forme optimisée pour l'exécution de modèles de ML sur des appareils de périphérie, y compris des appareils mobiles Android et iOS.

TensorFlow Lite est le moteur principal du ML Kit pour exécuter des modèles de machine learning. L'écosystème TensorFlow Lite comprend deux composants qui facilitent l'entraînement et le déploiement de modèles de machine learning sur les appareils mobiles:

• Model Maker est une bibliothèque Python qui permet d'entraîner facilement des modèles TensorFlow Lite à l'aide de vos propres données, en seulement quelques lignes de code. Aucune expertise en machine learning n'est requise.
• La bibliothèque de tâches est une bibliothèque multiplate-forme qui facilite le déploiement de modèles TensorFlow Lite avec quelques lignes de code dans vos applications mobiles.

Cet atelier de programmation est consacré à TFLite. Les concepts et les blocs de code qui ne sont pas pertinents pour TFLite et la détection d'objets ne sont pas expliqués. Ils vous sont fournis afin que vous puissiez simplement les copier et les coller.

3. Configuration

Télécharger le code

Cliquez sur le lien ci-dessous pour télécharger l'ensemble du code de cet atelier de programmation :

Télécharger le code source

Décompressez le fichier ZIP téléchargé. Cela permet de décompresser un dossier racine (odml-pathways-main) contenant toutes les ressources dont vous avez besoin. Pour cet atelier de programmation, vous n'aurez besoin que des sources dans le sous-répertoire object-detection/codelab2/android.

Le sous-répertoire android du dépôt object-detection/codelab2/android contient deux répertoires:

• starter : code de démarrage sur lequel s'appuie cet atelier de programmation.
• final : code final de l'exemple d'application terminée

Importer l'application de départ

Commençons par importer l'application de départ dans Android Studio.

1. Ouvrez Android Studio, puis sélectionnez Import Project (Gradle, Eclipse ADT, etc.) (Importer un projet (Gradle, Eclipse ADT, etc.)).
2. Ouvrez le dossier starter à partir du code source que vous avez téléchargé précédemment.

Pour vous assurer que toutes les dépendances sont disponibles pour votre application, vous devez synchroniser votre projet avec les fichiers Gradle une fois le processus d'importation terminé.

3. Sélectionnez Sync Project with Gradle Files (Synchroniser le projet avec les fichiers Gradle) () dans la barre d'outils d'Android Studio. Importez starter/app/build.gradle

Si ce bouton est désactivé, veillez à n'importer que starter/app/build.gradle, et non le dépôt complet.

Exécuter l'application de départ

Maintenant que vous avez importé le projet dans Android Studio, vous êtes prêt à exécuter l'application.

Connectez votre appareil Android via USB à votre ordinateur ou démarrez l'émulateur Android Studio,puis cliquez sur Run () (Exécuter) dans la barre d'outils Android Studio.

4. Comprendre l'application de départ

Pour que cet atelier de programmation soit simple et axé sur les bits de machine learning, l'application de départ contient un code récurrent qui effectue plusieurs actions:

• L'appareil photo permet de prendre des photos.
• Il contient quelques éléments d'une banque d'images pour vous permettre de tester la détection d'objets sur un émulateur Android.
• Il existe une méthode pratique pour dessiner le résultat de la détection d'objets sur le bitmap d'entrée.

Vous allez principalement interagir avec ces méthodes dans le squelette de l'application:

• fun runObjectDetection(bitmap: Bitmap) Cette méthode est appelée lorsque vous choisissez une image prédéfinie ou prenez une photo. bitmap est l'image d'entrée pour la détection d'objets. Plus tard dans cet atelier de programmation, vous ajouterez un code de détection d'objets à cette méthode.
• data class DetectionResult(val boundingBoxes: Rect, val text: String) Cette classe de données représente un résultat de détection d'objets à des fins de visualisation. boundingBoxes est le rectangle où se trouve l'objet, et text est la chaîne de résultat de détection à afficher avec le cadre de délimitation de l'objet.
• fun drawDetectionResult(bitmap: Bitmap, detectionResults: List<DetectionResult>): Bitmap Cette méthode dessine les résultats de la détection d'objets dans detectionResults sur l'entrée bitmap et renvoie la copie modifiée de celle-ci.

Voici un exemple de sortie de la méthode utilitaire drawDetectionResult.

5. Ajouter la détection d'objets sur l'appareil

Vous allez maintenant créer un prototype en intégrant un modèle TFLite pré-entraîné capable de détecter des objets courants dans l'application de départ.

Télécharger un modèle de détection d'objets TFLite pré-entraîné

Vous pouvez utiliser plusieurs modèles de détecteurs d'objets sur TensorFlow Hub. Pour cet atelier de programmation, vous allez télécharger le modèle de détection d'objets EffectiveDet-Lite, entraîné sur l'ensemble de données COCO 2017, optimisé pour TFLite et conçu pour optimiser les performances du processeur mobile, du GPU. et Edge TPU.

Télécharger le modèle

Ensuite, utilisez la bibliothèque de tâches TFLite pour intégrer le modèle TFLite pré-entraîné dans votre application de départ. La bibliothèque de tâches TFLite facilite l'intégration de modèles de machine learning optimisés pour les mobiles dans une application mobile. Cette solution est compatible avec de nombreux cas d'utilisation de machine learning courants, tels que la détection d'objets, la classification d'images et de classification de texte. Vous pouvez charger le modèle TFLite et l'exécuter avec seulement quelques lignes de code.

La bibliothèque de tâches TFLite n'est compatible qu'avec les modèles TFLite qui contiennent des métadonnées valides. Vous trouverez d'autres modèles de détection d'objets compatibles dans cette collection de TensorFlow Hub.

Ajouter le modèle à l'application de départ

1. Copiez le modèle que vous venez de télécharger dans le dossier assets de l'application de départ. Vous le trouverez dans le panneau de navigation de projet dans Android Studio.

2. Nommez le fichier model.tflite.

Mettre à jour les dépendances de la bibliothèque de tâches du fichier Gradle

Accédez au fichier app/build.gradle et ajoutez cette ligne à la configuration dependencies:

implementation 'org.tensorflow:tensorflow-lite-task-vision:0.3.1'

Synchroniser un projet avec des fichiers Gradle

Pour vous assurer que toutes les dépendances sont disponibles pour votre application, vous devez synchroniser votre projet avec les fichiers Gradle à ce stade. Sélectionnez Sync Project with Gradle Files (Synchroniser le projet avec les fichiers Gradle) () dans la barre d'outils d'Android Studio.

(Si ce bouton est désactivé, veillez à n'importer que le déclencheur/l'application/le build.gradle, et pas le dépôt complet.)

Configurer et exécuter la détection d'objets sur l'appareil pour une image

Il n'y a que trois étapes simples avec trois API pour charger et exécuter un modèle de détection d'objets:

• Préparer une image ou un flux: TensorImage
• Créez un objet détecteur: ObjectDetector
• connectez les deux objets ci-dessus: detect(image)

Vous devez procéder de cette manière dans la fonction runObjectDetection(bitmap: Bitmap)du fichier MainActivity.kt.

/**
* TFLite Object Detection Function
*/
private fun runObjectDetection(bitmap: Bitmap) {
    //TODO: Add object detection code here
}

Pour le moment, la fonction est vide. Passez au point suivant pour mettre en œuvre le détecteur d'objets TFLite. En attendant, Android Studio vous invitera à ajouter les importations nécessaires:

• org.tensorflow.lite.support.image.TensorImage
• org.tensorflow.lite.task.vision.detector.ObjectDetector

Créer un objet d'image

Les images que vous utiliserez dans cet atelier de programmation seront extraites de l'appareil photo de l'appareil ou d'images prédéfinies que vous sélectionnerez dans l'interface utilisateur de l'application. L'image d'entrée est décodée au format Bitmap et transmise à la méthode runObjectDetection.

TFLite fournit une API simple pour créer une TensorImage à partir de Bitmap. Ajoutez le code ci-dessous en haut de runObjectDetection(bitmap:Bitmap):

// Step 1: create TFLite's TensorImage object
val image = TensorImage.fromBitmap(bitmap)

Créer une instance Nest Detect

La bibliothèque de tâches TFLite suit le schéma de conception de compilateur. Vous allez transmettre la configuration à un compilateur, puis en acquérir un détecteur. Vous pouvez configurer plusieurs options, y compris celles permettant d'ajuster la sensibilité du détecteur d'objets:

• résultat maximal (nombre maximal d'objets que le modèle doit détecter)
• Seuil de score (niveau de confiance que le détecteur d'objet doit renvoyer pour un objet détecté)
• libellé de liste d'autorisation/refus (autoriser/refuser les objets dans une liste prédéfinie)

Initialisez l'instance du détecteur d'objets en spécifiant le nom du fichier de modèle TFLite et les options de configuration:

// Step 2: Initialize the detector object
val options = ObjectDetector.ObjectDetectorOptions.builder()
    .setMaxResults(5)
    .setScoreThreshold(0.5f)
    .build()
val detector = ObjectDetector.createFromFileAndOptions(
    this, // the application context
    "model.tflite", // must be same as the filename in assets folder
    options
)

Image(s) de flux vers le détecteur

Ajoutez le code suivant à fun runObjectDetection(bitmap:Bitmap). Vos images sont alors transmises au détecteur.

// Step 3: feed given image to the model and print the detection result
val results = detector.detect(image)

Une fois l'opération terminée, le détecteur renvoie une liste de Detection, chacune contenant des informations sur un objet que le modèle a trouvé dans l'image. Chaque objet est décrit avec les éléments suivants:

• boundingBox: rectangle indiquant la présence d'un objet et son emplacement dans l'image
• categories: type de l'objet et niveau de confiance du modèle avec le résultat de la détection. Le modèle renvoie plusieurs catégories, et la plus fiable est la première.
• label: nom de la catégorie d'objet.
• classificationConfidence:valeur flottante comprise entre 0 et 1, avec 1,0 représentant 100%

Imprimer les résultats de la détection

Ajoutez le code suivant à fun runObjectDetection(bitmap:Bitmap). Cela appelle une méthode pour imprimer les résultats de la détection d'objets dans Logcat.

// Step 4: Parse the detection result and show it
debugPrint(results)

Ensuite, ajoutez la méthode debugPrint() à la classe MainActivity:

private fun debugPrint(results : List<Detection>) {
    for ((i, obj) in results.withIndex()) {
        val box = obj.boundingBox

        Log.d(TAG, "Detected object: ${i} ")
        Log.d(TAG, "  boundingBox: (${box.left}, ${box.top}) - (${box.right},${box.bottom})")

        for ((j, category) in obj.categories.withIndex()) {
            Log.d(TAG, "    Label $j: ${category.label}")
            val confidence: Int = category.score.times(100).toInt()
            Log.d(TAG, "    Confidence: ${confidence}%")
        }
    }
}

Votre détecteur d'objets est maintenant prêt ! Compilez et exécutez l'application en cliquant sur Run (Exécuter) () dans la barre d'outils d'Android Studio. Une fois que l'application s'affiche sur l'appareil, appuyez sur l'une des images prédéfinies pour lancer le détecteur d'objets. Ensuite, regardez la fenêtre Logcat*(* *)* dans votre IDE. Vous devriez obtenir un résultat semblable à celui-ci:

D/TFLite-ODT: Detected object: 0
D/TFLite-ODT:   boundingBox: (0.0, 15.0) - (2223.0,1645.0)
D/TFLite-ODT:     Label 0: dining table
D/TFLite-ODT:     Confidence: 77%
D/TFLite-ODT: Detected object: 1
D/TFLite-ODT:   boundingBox: (702.0, 3.0) - (1234.0,797.0)
D/TFLite-ODT:     Label 0: cup
D/TFLite-ODT:     Confidence: 69%

Cela indique que le détecteur a bien vu deux objets. Le premier est le suivant:

• Un objet se trouve dans un rectangle compris entre (0, 15) et (2223, 1645)
• Libellé : table à manger
• Le modèle est certain que la première valeur est une table à manger (77%)

Techniquement, vous n'avez besoin que de cette bibliothèque pour travailler: vous avez tout compris pour le moment. Félicitations !

Toutefois, sur le plan de l'interface utilisateur, vous êtes toujours au point de départ. Vous devez maintenant utiliser les résultats détectés dans l'interface utilisateur en post-traitant les résultats détectés.

6. Dessiner le résultat de la détection sur l'image d'entrée

Lors des étapes précédentes, vous avez imprimé le résultat de la détection dans logcat: simple et rapide. Au cours de cette étape, vous allez utiliser la méthode utilitaire déjà implémentée dans l'application de départ pour:

• dessiner un cadre de délimitation sur une image
• dessiner un nom de catégorie et un pourcentage de confiance dans le cadre de délimitation

1. Remplacez l'appel debugPrint(results) par l'extrait de code suivant:

val resultToDisplay = results.map {
    // Get the top-1 category and craft the display text
    val category = it.categories.first()
    val text = "${category.label}, ${category.score.times(100).toInt()}%"

    // Create a data object to display the detection result
    DetectionResult(it.boundingBox, text)
}
// Draw the detection result on the bitmap and show it.
val imgWithResult = drawDetectionResult(bitmap, resultToDisplay)
runOnUiThread {
    inputImageView.setImageBitmap(imgWithResult)
}

Remarque: La détection d'objets étant un processus de calcul intensif, et la bibliothèque de tâches TFLite s'exécute sur le même thread où elle est appelée, il est important de l'exécuter sur un thread en arrière-plan pour éviter de bloquer l'interface utilisateur de l'application. Comme vous pouvez le constater, nous utilisons la coroutine Kotlin pour appeler la méthode runObjectDetection.

lifecycleScope.launch(Dispatchers.Default) { runObjectDetection(bitmap) }

2. Cliquez sur Run (Exécuter) () dans la barre d'outils d'Android Studio.
3. Une fois l'application chargée, appuyez sur l'une des images prédéfinies pour afficher le résultat de la détection.

Voulez-vous essayer avec votre propre photo ? Appuyez sur le bouton Prendre une photo et prenez des photos des objets qui vous entourent.

7. Entraîner un modèle de détection d'objets personnalisé

Lors de l'étape précédente, vous avez intégré un modèle de détection d'objets TFLite pré-entraîné dans l'application Android et vous avez vu qu'il pouvait détecter des objets courants, comme des bols ou des tables pour les repas, dans des exemples d'images. Cependant, votre objectif étant de détecter les ingrédients des plats présentés sur l'image, la détection d'objets généraux ne correspond pas à votre cas d'utilisation. Vous souhaitez entraîner un modèle personnalisé de détection d'objets à l'aide d'un ensemble de données d'entraînement contenant les ingrédients à détecter.

Voici un ensemble de données contenant des images et des étiquettes que vous pouvez utiliser pour entraîner votre propre modèle personnalisé. Il a été créé à l'aide d'images provenant d'Open Images Dataset V4.

Colaboratory

Passons maintenant à l'entraînement du modèle personnalisé dans Google Colab.

Accéder à Google Colab

Si vous ne connaissez pas encore Google Colaboratory, c'est-à-dire un environnement interactif qui vous permet d'écrire et d'exécuter du code. Il est largement utilisé dans la communauté du machine learning. Grâce à Colab, vous pouvez importer un ensemble de données d'images, y entraîner un classificateur d'images et évaluer le modèle.

Les notebooks Colab exécutent le code sur les serveurs cloud de Google. Vous bénéficiez donc de toute la puissance du matériel Google, y compris des GPU et TPU, quelle que soit la puissance de votre machine. Il vous suffit d'un navigateur.

Si vous ne parvenez pas à accéder à Colab, vous pouvez utiliser un autre environnement et accéder au code via ce lien GitHub.

L'entraînement du modèle personnalisé prendra environ 30 minutes.

Si vous êtes pressé, vous pouvez télécharger un modèle que nous avons pré-entraîné pour l'ensemble de données fourni. Passez ensuite à l'étape suivante.

Télécharger le modèle de détection de salades

8. Intégrer le modèle TFLite personnalisé à l'application Android

Maintenant que vous avez entraîné un modèle de détection de salades, intégrez-le et transformez votre application d'un détecteur d'objets courants en un détecteur de salade, en particulier.

1. Copiez le modèle de salade TFLite dans le dossier assets. Nommez le nouveau modèle salad.tflite.

2. Ouvrez le fichier MainActivity.kt et recherchez le code d'initialisation ObjectDetector.
3. Remplacez le modèle EffectiveDet-Lite (model.tflite) par le modèle de salade (salad.tflite)

val detector = ObjectDetector.createFromFileAndOptions(
    this, // the application context
    "salad.tflite", // must be same as the filename in assets folder
    options
)

4. Cliquez surCourir (Run) ( ) dans la barre d'outils d'Android Studio pour réexécuter l'application avec le nouveau modèle ; Et voilà, L'application peut désormais reconnaître des fromages, des salades et des viennoiseries.

Si vous exécutez l'application dans un émulateur Android, vous constaterez peut-être que le modèle de détection d'objets met quelques secondes à renvoyer son résultat. En effet, les modèles quantifiés TFLite ne sont pas optimisés pour s'exécuter sur un émulateur. Elle s'exécutera beaucoup plus rapidement sur un appareil physique physique.

9. Félicitations !

Vous avez utilisé TFLite pour entraîner un modèle personnalisé et ajouter des fonctionnalités de détection d'objets à votre application. Vous avez terminé la configuration.

Points abordés

• Rechercher des modèles de détection d'objets TFLite pré-entraînés sur TensorFlow Hub
• Intégrer des modèles de détection d'objection à votre application Android à l'aide de la bibliothèque de tâches TFLite
• Entraînement d'un modèle de détection d'objets personnalisé avec TFLite Model Maker

Étapes suivantes

• Utiliser Firebase pour améliorer le déploiement de votre modèle TFLite
• Collecter des données d'entraînement pour entraîner votre propre modèle
• Appliquer la détection d'objets dans votre propre application Android

En savoir plus

• Machine learning intégré avec les technologies Google