1. Avant de commencer
Dans l'atelier de programmation précédent, vous avez créé une application pour Android et iOS utilisant un modèle d'étiquetage d'images de base qui reconnaît plusieurs centaines d'images. Elle a reconnu une image de fleur de manière très générique, avec des pétales, des fleurs, des plantes et du ciel.
Pour mettre à jour l'application afin qu'elle reconnaisse des fleurs, des marguerites ou des roses spécifiques, par exemple, vous aurez besoin d'un modèle personnalisé, entraîné sur de nombreux exemples de chaque type de fleur que vous voulez reconnaître.
Prérequis
- Atelier de programmation précédent dans ce parcours de formation.
Objectifs de l'atelier
- Entraînement d'un modèle personnalisé de classificateur d'images à l'aide de TensorFlow Lite Model Maker
Prérequis
- Aucun matériel spécifique n'est requis, tout peut être effectué avec Google Colab dans le navigateur.
2. Commencer
Tout le code à suivre a été préparé pour vous. Vous pouvez l'exécuter via Google Colab en cliquant ici. Si vous n'avez pas accès à Google Colab, vous pouvez cloner le dépôt et utiliser le notebook appelé CustomImageClassifierModel.ipynb, qui se trouve dans le répertoire ImageClassificationMobile->colab.
Si vous avez beaucoup d'exemples de fleurs particulières, il est assez simple d'entraîner un modèle avec le créateur de modèles TensorFlow Lite pour les reconnaître.
Pour ce faire, le moyen le plus simple consiste à créer un fichier ZIP ou TTG 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 annuaires comme suit:
Compressez le fichier vers un serveur, puis hébergez-le sur un serveur pour pouvoir l'entraîner. Nous allons en utiliser une préparée pour vous dans la suite de cet atelier.
Dans cet atelier, nous partons du principe 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, au moins TensorFlow.
3. Installer et importer des dépendances
- Installez TensorFlow Lite Model Maker. Pour ce faire, vous devez installer pip. À la fin, le caractère &> /dev/null supprime simplement le résultat. Model Maker affiche de nombreux éléments qui ne sont pas immédiatement pertinents. Il a été supprimé afin que vous puissiez vous concentrer sur la tâche à accomplir.
# Install Model maker
!pip install -q tflite-model-maker &> /dev/null
- Ensuite, importez les bibliothèques que vous devez utiliser et assurez-vous 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, vous pouvez commencer à créer votre modèle.
4. Télécharger et préparer vos données
Si vos images sont organisées en dossiers, ces derniers sont compressés. Si vous téléchargez le fichier ZIP et que vous le décompressez, vous obtiendrez automatiquement les étiquettes correspondantes en fonction du dossier dont ils font partie. Ce répertoire sera référencé en tant que 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. Pointez la souris sur le dossier et le tour est joué.
Un élément important de l'entraînement de modèles avec le machine learning est de ne pas utiliser toutes vos données pour l'entraînement. Attendez un peu pour tester le modèle avec des données qu'il n'a jamais vues auparavant. Vous pouvez facilement le faire avec la méthode "split" de l'ensemble de données qui provient de ImageClassifierDataLoader. Si vous transmettez une valeur de 0, 9, vous recevrez 90% de vos données d'entraînement et 10% en tant que données de test:
data = DataLoader.from_folder(data_path)
train_data, test_data = data.split(0.9)
Maintenant que vos données sont prêtes, vous pouvez créer un modèle.
5. Créer le modèle de classificateur d'images
Model Maker fait abstraction de nombreuses spécificités de la conception du réseau de neurones. Vous n'avez donc pas à vous soucier de la conception du réseau, ni des éléments tels que les convolutions, les éléments denses, les liens relais, les fonctions d'aplatissement et les optimiseurs. Pour un modèle par défaut, il vous suffit d'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)
Lors de son exécution, le résultat devrait ressembler à ceci:
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 vous montre l'architecture de votre modèle. Ce que l'outil Model Maker fait en arrière-plan s'appelle l'apprentissage par transfert, qui utilise un modèle pré-entraîné existant comme point de départ. Il s'appuie simplement sur les connaissances acquises par ce modèle sur la construction et l'application des images. pour comprendre ces cinq fleurs. Vous pouvez le constater sur la première ligne:
hub_keras_layer_v1v2_2 (HubK (None, 1280) 3413024
La clé est le mot "Hub", 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. Ici, la logique est que la méthodologie qu'elle utilise, en apprenant les "caractéristiques" pour faire la distinction entre 1 000 classes, peut être réutilisée. Les mêmes "caractéristiques" peuvent être mappées à nos cinq classes de fleurs, elles n'ont donc pas à apprendre de zéro.
Le modèle a subi cinq époques : l'époque est un cycle complet d'entraînement, où le réseau de neurones tente de faire correspondre les images à leurs étiquettes. Au cours des 5 époques, en une minute environ, la précision des données d'entraînement était de 93,85 %. Comme il s'agit de cinq classes, une estimation aléatoire sera précise à 20 %. (Il indique également un nombre "persé", mais vous pouvez l'ignorer pour le moment en toute sécurité.)
Plus tôt vous divisez les données en données d'entraînement et de test, afin que vous puissiez obtenir une estimation des performances du réseau sur des données inconnues. L'outil vous fournit une meilleure idée de ses performances réellesmodel.evaluate des données de test:
loss, accuracy = model.evaluate(test_data)
Le résultat ressemble à ceci:
12/12 [===] - 5s 115ms/step - loss: 0.6622 - accuracy: 0.8801
Notez l'exactitude de ces informations. La valeur de ce taux est de 88,01 %. Vous devez donc vous attendre à un tel niveau de précision dans l'utilisation du modèle par défaut. Ce n'est pas mal pour le modèle par défaut que vous avez entraîné en une minute environ. Bien sûr, il est très probable que vous puissiez effectuer de nombreux ajustements pour améliorer le modèle, et c'est tout seul une science !
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 facile 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 l'exécutez dans Google Colab, vous pouvez alors afficher le modèle en cliquant sur l'icône de dossier située à gauche de l'écran:
Vous obtenez alors une liste de l'annuaire actuel. Utilisez le bouton indiqué pour déplacer le répertoire vers le haut:
Dans votre code, vous devez indiquer l'exportation vers le répertoire mm_flowers. Ouvrez-le et vous verrez un fichier appelé "model.tflite". Il s'agit de votre modèle entraîné.
Sélectionnez le fichier. Trois points s'affichent sur la droite. Cliquez dessus pour obtenir un menu contextuel, à partir duquel vous pouvez télécharger le modèle.
Après quelques instants, votre modèle est téléchargé dans votre dossier de téléchargements.
7. Félicitations
Vous pouvez l'intégrer à votre application mobile. Vous le ferez lors du prochain atelier.