1. Avant de commencer
Dans l'atelier de programmation précédent, vous avez créé une application pour Android et iOS qui utilisait un modèle d'étiquetage d'images de base reconnaissant plusieurs centaines de classes d'images. Elle a reconnu une image de fleur de manière très générique, en identifiant des pétales, une fleur, une plante et un ciel.
Pour que l'application puisse reconnaître des fleurs spécifiques (des marguerites ou des roses, par exemple), vous aurez besoin d'un modèle personnalisé entraîné sur de nombreux exemples de chaque type de fleur que vous souhaitez reconnaître.
Prérequis
- L'atelier de programmation précédent de ce parcours de formation.
Ce que vous allez créer et apprendre
- Découvrez comment entraîner un modèle personnalisé de classification d'images à l'aide de TensorFlow Lite Model Maker.
Prérequis
- Aucun matériel spécifique n'est nécessaire. Vous pouvez tout faire avec Google Colab dans le navigateur.
2. Premiers pas
Tout le code à suivre a été préparé pour vous et est disponible pour exécution à l'aide de Google Colab ici. Si vous n'avez pas accès à Google Colab, vous pouvez cloner le dépôt et utiliser le notebook CustomImageClassifierModel.ipynb, qui se trouve dans le répertoire ImageClassificationMobile->colab.
Si vous disposez de nombreux exemples de fleurs spécifiques, il est relativement facile d'entraîner un modèle avec TensorFlow Lite Model Maker pour les reconnaître.
Le plus simple est de créer un fichier .zip ou .tgz contenant les images, triées dans des répertoires. Par exemple, si vous utilisez des images de marguerites, de pissenlits, de roses, de tournesols et de tulipes, vous pouvez les organiser dans des répertoires comme suit :
Compressez-le et hébergez-le sur un serveur pour pouvoir entraîner des modèles avec. Vous allez utiliser celui qui a été préparé pour vous dans le reste de cet atelier.
Cet atelier suppose que vous utilisez Google Colab pour entraîner le modèle. Vous trouverez Colab sur colab.research.google.com. Si vous utilisez un autre environnement, vous devrez peut-être installer de nombreuses dépendances, y compris TensorFlow.
3. Installer et importer des dépendances
- Installez TensorFlow Lite Model Maker. Pour ce faire, utilisez pip install. Le "&> /dev/null" à la fin supprime simplement le résultat. Model Maker génère beaucoup de contenu qui n'est pas immédiatement pertinent. Il a été supprimé pour que vous puissiez vous concentrer sur la tâche en cours.
# Install Model maker
!pip install -q tflite-model-maker &> /dev/null
- Vous devez ensuite importer les bibliothèques dont vous avez besoin et vous assurer d'utiliser TensorFlow 2.x :
# Imports and check that we are using TF2.x
import numpy as np
import os
from tflite_model_maker import configs
from tflite_model_maker import ExportFormat
from tflite_model_maker import model_spec
from tflite_model_maker import image_classifier
from tflite_model_maker.image_classifier import DataLoader
import tensorflow as tf
assert tf.__version__.startswith('2')
tf.get_logger().setLevel('ERROR')
Maintenant que l'environnement est prêt, il est temps de commencer à créer votre modèle.
4. Télécharger et préparer vos données
Si vos images sont organisées dans des dossiers et que ces dossiers sont compressés, lorsque vous téléchargez le fichier ZIP et le décompressez, vos images sont automatiquement étiquetées en fonction du dossier dans lequel elles se trouvent. Ce répertoire sera référencé sous le nom data_path.
data_path = tf.keras.utils.get_file(
'flower_photos',
'https://storage.googleapis.com/download.tensorflow.org/example_images/flower_photos.tgz',
untar=True)
Ce chemin de données peut ensuite être chargé dans un modèle de réseau de neurones pour l'entraînement avec la classe ImageClassifierDataLoader de TensorFlow Lite Model Maker. Il vous suffit de pointer le dossier, et le tour est joué.
Un élément important de l'entraînement des modèles avec le machine learning est de ne pas utiliser toutes vos données pour l'entraînement. Mettez-en de côté pour tester le modèle avec des données qu'il n'a pas encore vues. C'est facile à faire avec la méthode de fractionnement de l'ensemble de données qui revient de ImageClassifierDataLoader. En lui transmettant la valeur 0, 9, vous obtiendrez 90 % de vos données pour l'entraînement et 10 % pour les tests :
data = DataLoader.from_folder(data_path)
train_data, test_data = data.split(0.9)
Maintenant que vos données sont préparées, vous pouvez créer un modèle à l'aide de celles-ci.
5. Créer le modèle de classification d'images
Model Maker abstrait de nombreux détails de la conception du réseau de neurones. Vous n'avez donc pas à vous soucier de la conception du réseau, ni des convolutions, des fonctions dense, relu, flatten, de perte et des optimiseurs. Pour un modèle par défaut, vous pouvez simplement utiliser une seule ligne de code pour créer un modèle en entraînant un réseau de neurones avec les données fournies :
model = image_classifier.create(train_data)
Lorsque vous exécutez cette commande, un résultat semblable à celui-ci s'affiche :
Model: "sequential_2"
_________________________________________________________________
Layer (type) Output Shape Param #
=================================================================
hub_keras_layer_v1v2_2 (HubK (None, 1280) 3413024
_________________________________________________________________
dropout_2 (Dropout) (None, 1280) 0
_________________________________________________________________
dense_2 (Dense) (None, 5) 6405
=================================================================
Total params: 3,419,429
Trainable params: 6,405
Non-trainable params: 3,413,024
_________________________________________________________________
None
Epoch 1/5
103/103 [===] - 15s 129ms/step - loss: 1.1169 - accuracy: 0.6181
Epoch 2/5
103/103 [===] - 13s 126ms/step - loss: 0.6595 - accuracy: 0.8911
Epoch 3/5
103/103 [===] - 13s 127ms/step - loss: 0.6239 - accuracy: 0.9133
Epoch 4/5
103/103 [===] - 13s 128ms/step - loss: 0.5994 - accuracy: 0.9287
Epoch 5/5
103/103 [===] - 13s 126ms/step - loss: 0.5836 - accuracy: 0.9385
La première partie montre l'architecture de votre modèle. Ce que fait Model Maker en arrière-plan s'appelle l'apprentissage par transfert. Il utilise un modèle pré-entraîné existant comme point de départ et applique les connaissances acquises par ce modèle sur la façon dont les images sont construites pour comprendre ces cinq fleurs. Vous pouvez le voir dans la première ligne :
hub_keras_layer_v1v2_2 (HubK (None, 1280) 3413024
Le mot "Hub" est la clé qui nous indique que ce modèle provient de TensorFlow Hub. Par défaut, TensorFlow Lite Model Maker utilise un modèle appelé "MobileNet", conçu pour reconnaître 1 000 types d'images. La logique ici est que la méthodologie qu'il utilise, en apprenant des "caractéristiques" pour distinguer 1 000 classes, peut être réutilisée. Les mêmes "caractéristiques" peuvent être mises en correspondance avec nos cinq classes de fleurs. Il n'est donc pas nécessaire de les apprendre à partir de zéro.
Le modèle a été entraîné sur cinq époques, c'est-à-dire cinq cycles complets d'entraînement au cours desquels le réseau de neurones tente de faire correspondre les images à leurs libellés. Au bout de cinq époques, soit environ une minute, il était précis à 93,85 % sur les données d'entraînement. Étant donné qu'il y a cinq classes, une prédiction aléatoire aurait une précision de 20 %. C'est déjà un progrès ! (Il indique également un nombre de "pertes", mais vous pouvez l'ignorer pour le moment.)
Vous avez précédemment divisé les données en données d'entraînement et de test. Vous pouvez ainsi évaluer les performances du réseau sur des données qu'il n'a jamais vues auparavant. Il s'agit d'un meilleur indicateur de ses performances dans le monde réel. Pour ce faire, utilisez model.evaluate sur les données de test :
loss, accuracy = model.evaluate(test_data)
Vous devriez obtenir un résultat semblable à celui-ci :
12/12 [===] - 5s 115ms/step - loss: 0.6622 - accuracy: 0.8801
Notez la précision ici. Il est de 88,01 %. Par conséquent, si vous utilisez le modèle par défaut dans un contexte réel, vous devez vous attendre à ce niveau de précision. Ce n'est pas mal pour le modèle par défaut que vous avez entraîné en une minute environ. Bien sûr, vous pourriez probablement apporter de nombreuses modifications pour améliorer le modèle, et c'est une science en soi !
6. Exporter le modèle
Maintenant que le modèle est entraîné, l'étape suivante consiste à l'exporter au format .tflite qu'une application mobile peut utiliser. Model Maker fournit une méthode d'exportation simple que vous pouvez utiliser. Il vous suffit de spécifier le répertoire de sortie.
Voici le code :
model.export(export_dir='/mm_flowers')
Si vous exécutez cette commande dans Google Colab, vous pouvez ensuite voir le modèle en cliquant sur l'icône de dossier à gauche de l'écran :
La liste du répertoire actuel s'affiche. Utilisez le bouton indiqué pour remonter d'un répertoire :
Dans votre code, vous avez spécifié d'exporter vers le répertoire mm_flowers. Ouvrez-le. Vous verrez un fichier nommé model.tflite. Il s'agit de votre modèle entraîné.
Sélectionnez le fichier. Trois points s'affichent alors sur la droite. Cliquez dessus pour afficher un menu contextuel, puis téléchargez le modèle.
Après quelques instants, votre modèle sera téléchargé dans votre dossier de téléchargements.
7. Félicitations
Vous êtes maintenant prêt à l'intégrer à votre application mobile. Vous le ferez dans le prochain atelier.