Déployer ma première application de Deep Learning

6 min readJun 16, 2020

Introduction

Ce post est la suite de l’article Comment se déroule un projet de Data Science ?. Lors du Nanodegree de Udacity sur le Machine Learning, le deuxième projet nous propose de développer et de déployer notre première application de Deep Learning.

Le premier projet a permis de comprendre la logique globale d’un projet de Machine Learning. Dans ce post, nous allons un pas plus loin : le déployer en production, ou du moins, le rendre utilisable pour nos collègues.

Vous connaissez la démarche, nous allons donc :

définir l’objectif “business” du projet
explorer et prendre en main les données
préparer les données pournotre modèle
construire notre modèle de prédiction
analyser ses performances sur un jeu de test
déployer ce modèle

Tout le code est disponible sur mon repo GitHub.

C’est parti !

Objectif

Comme tout bon projet de Data Sceince, il faut bien évidemment connaître l’objectif. Ici, nous prenons en photo une fleur et nous voulons connaître son nom. Pratique quand vous partez en randonnée ou explorez les jardins de votre ville.

Exploration données

Nous chargeons les images issues du jeu de données Oxford Flowers 102. Le jeu de données est déjà séparé en 3 : entraînement, validation et test. Il y a un total de 102 classes différentes de fleurs. Les jeux d’entraînement et de validation ont chacun 1020 images (10 image par classe) et le jeu de test 6129.

Data Preprocessing

Nous devons nous assurer que nos images ont bien la forme suivante : (3,224,224).

3 canaux pour le système de couleurs RGB
224 pixels de large
224 pixels de haut

Or, à première vue, il y a une grande disparité dans les tailles des images fournies.

Nous créons donc la fonction format_image qui a pour but de réaliser les transformations nécessaires.

Dans un premier temps, nous ne nous attardons pas plus dans le preprocessing. Nous passons directement à la suite : construction et entraînement de notre modèle.

Training a model

Nous n’allons pas repartir de zéro. Nous allons profiter du travail de nos collègues. Nous utilisons le modèle déjà entraîné MobileNet depuis TensorFlow Hub (le github des modèles de Machine Leanring).

A la suite de ce modèle, nous ajoutons une couche fully-connected avec le nombre de classes à prédire correspondant (102 dans notre cas).

Nous sélectionnons notre optimizer et notre fonction de coût (loss) et la métrique qui mesurera la performance de notre modèle.

Dans ce genre de problème, l’optimizer par défaut est souvent Adam. Il a l’avantage de converger rapidement. Plus d’infos ici.

La fonction de coût choisie est SparseCategoricalCrossentropy, car nous cherchons à prédire plusieurs classes différentes.

Enfin, nous choisissons la métrique accuracy (justesse en français).

Et nous lançons l’entrainement pour 8 époques.

Nous obtenons les graphes suivants :

Dès la première époque, nous constatons du sur-apprentissage (overfitting). Il faudra revenir et corriger cela. En attendant, continuons.

Regardons, comment notre modèle se comporte avec les données de test : 76% de justesse. Pour un modèle sorti du chapeau, ce n’est pas si mal que ça.

Inference for classification

Nous allons maintenant nettoyer le pipeline nécessaire à la mise en production de notre modèle :

pré-traitement des images
inférence d’une image des k classes prédominantes

Le but est maintenant de coder une fonction essentielle de notre application. Notre fonction predict a le prototype suivant :

où probs est un tableau de probabilité et classes le nom des classes correspondantes

Sanity Check

Comme nous sommes précautionneux, nous testons sur les images tests. Bien évidemment, après coup, le code et la démarche font totalement sens. Mais il faut garder à l’esprit que dans ce projet de Data Science, il y a eu lieu une multitude d’allers-retours pour tester, modifuer, ajuster, comprendre tous les aspects. Vous imaginez bien que j’ai perdu quelques cheveux dans cette affaire 👨‍🦲.

A ce stade là, la plus grosse partie est faite. Maintenant, nous nous penchons sur la partie “déploiement”. Le but est de rendre utilisable notre modèle.

Déploiement

Pour cela, nous créons un script predict.py. Et son utilisation souhaitée est la suivante :

./predict.py -image-path="./fleut_pellerin.jpg -model_folder="./my_model" -top_k=1 -category_names="./label_map.json

où

image_path : chemin de l’image à prédire
model_folder_path : chemin où nous avons sauvé notre modèle
top_k : nombre de prédictions à afficher
category_names : fichier de correspondances entre l’identifiant et le nom des classes de fleur

Son contenu n’est pas très compliqué :

récupérer les arguments de la ligne de commande
ouvrir le fichier des correspondances
charger le modèle entraîné
faire la prédiction
afficher la prédiction et sa probabilité

Tout tient en 27 lignes.

Ce script comprend bien évidemment les fonctions écrites précédemment lors de notre exploration dans le notebook.

Et voilà. Nous avons une application prête à l’emploi, voire même à être déployée derrière une API Http.

Vous remarquerez que nous n’avons pas du tout essayé d’affiner les performances du modèle. Ce dernier est un peu brut de décoffrage. La suite du projet serait bien évidemment d’étudier ce point là. Mais comme je le disais dans mon article précédent, un projet de Data Science est constitué de boucles de développement, aussi appelées itérations.

Conclusion

Dans ce post, nous sommes allés plus loin que lors du premier projet du mooc. Après un rapide pré-traitement des données, nous sommes partis d’un modèle pré-existant disponible sur TensorFlow Hub. Nous avons ensuite entraîné sa dernière couche sur nos données. Puis, nous avons sauvegardé ce modèle afin de l’utiliser directement en ligne de commande pour l’utiliser en production.