Premiers pas avec Tensorflow

Tensorflow est la librairie open source soutenue par Google pour réaliser des calculs sur de grandes quantités de données. J'ai eu la chance d'assister à la présentation de Yufeng Guo au Breiztcamp 2017 sur ce sujet (lien vidéo) et j'ai eu envie de partager cette découverte.

Présentation

Le projet Tensorflow date de Septembre 2016 et rassemble plus de 90 contributeurs. Cette librairie est utilisée par de nombreuses entreprises comme Twitter, Ebay, Snapchat et Intel. Elle dispose de deux principales API : une très bas niveau qui permet de comprendre exactement la modélisation mathématique utilisée et une plus haut niveau qui fait abstraction de la partie calcul pour se concentrer sur le résultat. En utilisant cette API on peut utiliser tout le savoir faire de Google sans avoir à comprendre exactement comment fonctionne la machine. Le langage de programmation utilisé pour la librairie est Python. L'objectif que je me suis fixé est d'utiliser Tensorflow pour différencier deux types de moyens de transport : la voiture et le cheval. J'avais tout d'abord pensé aux licornes mais il n'est pas simple de trouver une grande quantité de photos de licorne dans leur habitat naturel !

Installation

Il y a plusieurs façons d'installer Tensorflow  :

  • virtualenv
  • "native" pip
  • Docker
  • Anaconda

L'objectif pour l'installation est d'isoler l'environnement de Tensorflow. Virtualenv et Anaconda permettent de créer des environnements virtuels et Docker isole complètement le programme Python des autres processus en cours. J'ai testé la procédure d'installation recommandée (virtualenv) mais j'ai eu quelques problèmes de stabilité. J'ai finalement opté pour l'image Docker qui présente l'avantage de fournir un environnement stable, jetable et totalement compatible. On peut utiliser cette image par exemple :

docker pull tensorflow/tensorflow

et lancer l'environnement :

docker run -it --publish 6006:6006 --volume ~/tensorflowWorkspace/tf_files:/tf_files --workdir /tf_files tensorflow/tensorflow:1.1.0 bash

La première API

J'ai commencé par suivre le tutoriel du site officiel pour apprendre la théorie mathématique. Les premières étapes sont assez simples et montrent comment résoudre des équations du type y = W.x + b où les inconnues sont W et b. On commence par définir nos deux inconnues, puis on écrit une fonction qui va calculer la perte au court de l'entrainement. On boucle 1000 fois sur les 4 valeurs et à chaque itération l'optimiseur va améliorer la précision de notre prédiction. Enfin on affiche le résultat.

On comprend assez aisément comment fonctionne l'entrainement : l'optimiser va modifier peu à peu les valeurs qu'il pense être les bonnes pour W et b entre chaque essai, puis calculer la perte pour savoir s'il s'approche ou s'il s'éloigne du bon résultat. Pour cet exemple le modèle est une des données d'entrée du problème donc le résoudre s'avère assez simple.

La seconde API

L'API haut niveau de Tensorflow (tf.contrib.learn) permet de configurer facilement l'entrainement, la perte, mais aussi les différents modèles à utiliser pour trouver une solution au problème. Cette api est utilisée dans un second exemple fourni par Google : TensorFlow For Poets. J'ai adapté cet exemple pour le cas qui nous intéresse : reconnaître une photo de cheval ou une photo de voiture. Pour commencer nous allons nous procurer les données. Il suffit de se rendre sur une banque d'image très connue : ImageNet. On télécharge la liste des images à partir du fichier qui contient les url

wget -i url.txt

L'objectif suivant est de minimiser le temps de calcul. Pour se faire, nous allons redimensionner les images :

convert horse/my_horse.png -resize 200x100 horseResized/my_horse.png

et les convertir en niveaux de gris :

convert horseResized/my_horse.png -colorspace Gray horseResizedGrey/my_horse.png

Ensuite il faut se procurer les deux scripts de l'exemple de Google : retrain.py qui permet d'entraîner notre modèle et label_image.py qui sert à le tester unitairement. On lance ensuite la commande :

python retrain.py --bottleneck_dir=bottlenecks

--how_many_training_steps=500

--model_dir=inception

--summaries_dir=training_summaries/basic

--output_graph=retrained_graph.pb

--output_labels=retrained_labels.txt

--image_dir=images

Le premier argument est le dossier où seront déposés les bottlenecks. Ce sont des fichiers texte qui contiennent une représentation mathématique de l'image : une série de chiffres. Le second paramètre indique le nombre d'entraînement que le programme doit réaliser. Les quatre arguments suivants indiquent des fichiers ou des dossiers où le programme va stocker le modèle qui sert à faire les prédictions. Enfin, le dernier paramètre est le dossier où sont stockées les photos. Le script va tout d'abord calculer tous les bottlenecks. Ensuite il va télécharger le modèle de Google qui est entraîné à la reconnaissance de photos. Ensuite il va commencer l'entraînement : pour chaque passage dans la boucle d'entraînement il choisit 10 photos dans chaque dossier pour parfaire ses prédictions. Lors de cet entraînement on ne fait qu'ajouter une petite couche au modèle pour notre cas spécifique, en utilisant une api haut niveau. Une fois l'entraînement terminé on peut voir les résultats :

On arrive à une précision de 96,2%. Ce résultat n'est pas mauvais pour un premier essai mais on reste loin des résultats courants précis à plus de 99%.

Le second script permet de tester le modèle que nous venons de réaliser pour avoir une vrai vision du résultat. On l'utilise avec la commande :

python label_image.py images/horse/horsestudent.jpg

et on obtient les résultats suivants :

Conclusion

Nous avons réussi à réaliser un script qui procède à du Machine Learning sur un ensemble de données. La prochaine étape consiste à améliorer la précision pour atteindre 99%. Tensorflow nous a permis d'arriver à ces résultats assez facilement en utilisant un script et un modèle déjà entraîné par Google. Pour une entrée en matière c'est très satisfaisant mais si on veut avoir de meilleurs résultats sans dépendre du modèle pré-entraîné du géant américain il va falloir passer par les théories mathématiques et créer son propre modèle avec l'api bas niveau.

Laisser un commentaire

Votre adresse de messagerie ne sera pas publiée. Les champs obligatoires sont indiqués avec *

Captcha *

Ce site utilise Akismet pour réduire les indésirables. En savoir plus sur comment les données de vos commentaires sont utilisées.