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'image de base qui reconnaît plusieurs centaines de classes d'images. Il a identifié la photo d'une fleur de façon très générique : elle a vu des pétales, une fleur, une plante et le 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é à l'aide d'un grand nombre d'exemples de chaque type de fleur que vous souhaitez reconnaître.
Prérequis
- Atelier de programmation précédent de ce parcours de formation
Objectifs de l'atelier
- Entraîner un modèle personnalisé de classificateur 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
Le code à suivre a été préparé pour vous et peut être exécuté à l'aide de Google Colab sur cette page. Si vous n'avez pas accès à Google Colab, vous pouvez cloner le dépôt et utiliser le notebook nommé CustomImageClassifierModel.ipynb, qui se trouve dans le répertoire ImageClassificationMobile->colab.
Si vous disposez de nombreux exemples de fleurs particulières, il est relativement facile d'entraîner un modèle avec TensorFlow Lite Model Maker pour les reconnaître.
La méthode la plus simple consiste à 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 ceci:
Compressez-le et hébergez-le sur un serveur pour pouvoir entraîner des modèles. Vous en utiliserez un qui a été préparé pour vous dans le reste de cet atelier.
Dans cet atelier, nous partons du principe que vous utilisez Google Colab pour entraîner le modèle. Vous pouvez accéder à Colab à l'adresse colab.research.google.com. Si vous utilisez un autre environnement, vous devrez peut-être installer de nombreuses dépendances, en particulier TensorFlow.
3. Installer et importer des dépendances
- Installez TensorFlow Lite Model Maker. Pour ce faire, effectuez une installation pip. Le bouton &> /dev/null at the end just suppresses the output. Model Maker génère de nombreux éléments qui ne sont pas pertinents dans l'immédiat. Il a été supprimé pour que vous puissiez vous concentrer sur la tâche à accomplir.
# 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 que vous utilisez 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 et que ces dossiers sont compressés, si vous téléchargez le fichier ZIP et le décompressez, vos images seront automatiquement étiquetées en fonction du dossier dans lequel elles se trouvent. Ce répertoire sera référencé sous la forme 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 d'accès aux données peut ensuite être chargé dans un modèle de réseau de neurones pour l'entraîner avec la classe ImageClassifierDataLoader de TensorFlow Lite Model Maker. Il vous suffit de le pointer vers le dossier et le tour est joué.
Pour entraîner des modèles à l'aide du machine learning, il est important de ne pas utiliser toutes vos données pour l'entraînement. Reculez un peu pour tester le modèle avec des données qu'il n'a pas encore vues. Cela est facile à faire avec la méthode de division de l'ensemble de données renvoyé par ImageClassifierDataLoader. En lui transmettant 0, 9, vous obtenez 90% de données d'entraînement et 10% de 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éparées, vous pouvez créer un modèle à partir de celles-ci.
5. Créer le modèle de classificateur d'images
Model Maker élimine une grande partie des spécificités de la conception du réseau de neurones. Vous n'avez donc pas à vous occuper de la conception du réseau, ni des aspects tels que les convolutions, la densité, le reLU, l'aplatissement, les fonctions de perte et les optimiseurs. Dans le cas d'un modèle par défaut, il vous suffit d'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, le résultat qui s'affiche ressemble à ce qui suit:
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 présente l'architecture de votre modèle. L'action de Model Maker en arrière-plan s'appelle l'apprentissage par transfert. Elle utilise un modèle pré-entraîné existant comme point de départ, et se contente d'utiliser les informations que le modèle a apprises sur la façon dont les images sont construites pour comprendre ces cinq fleurs. Vous pouvez le voir dans la première ligne qui indique:
hub_keras_layer_v1v2_2 (HubK (None, 1280) 3413024
La clé est le mot "Hub", qui 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 est ici que la méthodologie utilisée, en apprenant les "caractéristiques" pour distinguer 1 000 classes, peut être réutilisée. Les mêmes "caractéristiques" peut être associé à nos cinq classes de fleurs, ce qui évite de devoir les apprendre à partir de zéro.
Le modèle a subi cinq époques. Une époque est un cycle d'entraînement complet au cours duquel le réseau de neurones tente de faire correspondre les images à leurs étiquettes. Au moment où elle a traversé cinq époques, en une minute environ, les données d'entraînement étaient précises à 93,85 %. Étant donné qu'il y a 5 classes, une estimation aléatoire serait de 20 %. C'est donc une progression ! (Il signale également une "perte", mais vous pouvez l'ignorer sans risque pour le moment.)
Plus tôt, vous avez divisé les données en données d'entraînement et de test, afin d'obtenir une évaluation des performances du réseau sur des données qu'il n'avait pas vues auparavant. Il s'agit d'un meilleur indicateur de ses performances réelles en utilisant model.evaluate sur les données de test:
loss, accuracy = model.evaluate(test_data)
Le résultat devrait ressembler à ceci:
12/12 [===] - 5s 115ms/step - loss: 0.6622 - accuracy: 0.8801
Notez la précision. Il est de 88,01 %. Par conséquent, l'utilisation du modèle par défaut dans le monde réel devrait permettre d'obtenir ce niveau de précision. Ce n'est pas mauvais pour le modèle par défaut que vous avez entraîné en une minute environ. Bien entendu, vous pourriez effectuer de nombreux ajustements 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 offre une méthode d'exportation simple. Il vous suffit de spécifier le répertoire de destination.
Voici le code :
model.export(export_dir='/mm_flowers')
Si vous exécutez ceci dans Google Colab, vous pouvez voir le modèle en cliquant sur l'icône de dossier à gauche de l'écran:
À partir de là, vous obtiendrez une liste du répertoire actuel. Utilisez le bouton indiqué pour "monter" un répertoire:
Dans votre code que vous avez spécifié pour l'exportation vers le répertoire mm_flowers Ouvrez-le. Vous y trouverez un fichier intitulé "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 accéder au menu contextuel et y télécharger 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 ! C'est ce que vous ferez dans le prochain atelier.