VT2016 TensorFlow

=Présentation=
 * Sujet : TensorFlow
 * Auteur : Coralie RACHEX
 * Enseignants : Didier Donsez, Georges-Pierre Bonneau
 * Date : 04/10/2016



=Résumé= TensorFlow™ est une librairie open source permettant d'effectuer des calculs numériques en utilisant des graphes de flux de données. Les noeuds du graphe représentant des opérations mathématiques, tandis que les arêtes représentent les données. Cette architecture flexible permet de déployer l'ensemble des calculs sur un ou plusieurs CPU ou GPU. Cela permet également de déployer le programme sur un ordinateur de bureau, sur un serveur et même sur un appareil mobile avec une seule API. TensorFlow a été initialement développé par les chercheurs et les ingénieurs de l'équipe Google Brain, au sein du département de recherche sur l'intelligence artificielle de Google, dans le but d'être utilisé en apprentissage automatique et pour poursuivre les recherches sur l'apprentissage en profondeur par réseaux de neurones. Mais le système est tout aussi bien applicable dans une grande variété d'autres domaines.


 * Mots-clés : TensorFlow, Apprentissage en profondeur, Réseau neuronal, Apprentissage automatique

=Abstract= TensorFlow™ is an open source software library for numerical computation using data flow graphs. Nodes in the graph represent mathematical operations, while the graph edges represent the data. The flexible architecture allows you to deploy computation to one or more CPUs or GPUs in a desktop, server, or mobile device with a single API. TensorFlow was originally developed by researchers and engineers working on the Google Brain Team within Google's Machine Intelligence research organization for the purposes of conducting machine learning and deep neural networks research, but the system is general enough to be applicable in a wide variety of other domains as well.


 * Keywords : TensorFlow, DeepLearning, Neural network, Machine learning

=Synthèse=

Domaine d'application
Comme TensorFlow provient de Google, il est évident que Google utilise cette technologie pour plusieurs de ses services. Cela permet d'avoir un aperçu de ses possibles applications. Mais il ne faut pas perdre de vue le fait que nous sommes actuellement à un stade précoce de l'apprentissage automatique et que bon nombre de ses applications potentielles sont encore insoupçonnées.

Analyse d'images
 * Google Photos : création automatique des albums et des vidéos en fonction des similitudes.
 * Street View : brouillage automatique des numéros de plaque d'immatriculation des voitures.

Reconnaissance de la parole
 * Google Talk : reconnaissance vocale des instructions à exécuter.

Traduction dynamique
 * Google Translate : détection automatique de la langue d'entrée.

Alpha Go
 * Il s'agit d'une application programmée pour jouer au Go, un jeu incroyablement complexe qui possèderait plus de possibilités que le nombre total d'atomes dans l'univers visible. Cette application montre ce que la technologie de l'apprentissage machine peut faire avec les possibilités infinies. Dans ses matches contre Lee Sedol (considéré comme l'un des meilleurs joueurs mondiaux), Alpha Go a remporté 4 de 5 parties.

Magenta Project
 * Il s'agit d'un projet ambitieux, ayant la prétention de créer de l'art grâce à une machine. Le premier résultat tangible a été une mélodie de 90 secondes jouée au piano. En février 2016, Google a également organisé une exposition d'art et de vente aux enchères à San Francisco, montrant 29 œuvres générés par ordinateur (avec un peu d'aide de l'homme).

Forces et faiblesses
Paradigme de programmation déclarative : TensorFlow permet de se concentrer sur le problème (quoi), plutôt que sur la solution (comment).

Portabilité : TensorFlow fonctionne sur CPU ou GPU. Et le modèle créé avec TensorFlow peut être déployé sur ordinateur, serveur, appareil mobile et même dans le cloud (conteneuriser avec Docker).

Flexibilité : TensorFlow ne propose pas que des algorithmes, il propose également un ensemble d'outils permettant d'assembler différentes couches dans les réseaux de neurones. À partir de là, l'utilisateur peut créer ses propres algorithmes et les intégrer au reste très facilement.

Performance : TensorFlow gère lui même les calculs asynchrones et permet donc en théorie de tirer le meilleur parti du matériel disponible. Mais en réalité, il est encore un peu à la traine comparée à certains de ses concurrents. À ses débuts, il souffrait même d'un réel problème de performance, qui a toutefois été vite corrigé par Google. Et les contributions ne cessent d'améliorer les choses.

API multilangage : TensorFlow est utilisable en Python et en C++ (l'API Python est à l'heure actuelle le plus complet et le plus facile à utiliser, mais l'API C ++ peut offrir certains avantages de performance dans l'exécution du graphe, et prend en charge le déploiement Android). De plus, Google à l'intention d'inclure des API pour Java et Go, puis plus tard pour d'autres langages comme JavaScript, Lua, R, etc.

Outils incorporés : Tensorboard aide à construire et à visualiser les modèles de flots de données.

Communauté active : Il suffit de jeter un oeil à la liste des auteurs de TensorFlow pour se rendre compte de l'importance du projet pour Google, puisqu'il a mis dessus un bon nombre de ses meilleurs éléments: Jeff Dean (père de MapReduce), Ian Goodfellow (contributeur principal de Théano / PyLearn2), Yangqing Jia (principal contributeur de Caffe). De plus, Google a rendu cette technologie open source pour accélérer sa croissance. Cette stratégie est payante, car la communauté est effectivement très active. Et une communauté active est la meilleure des choses pour le maintien et le développement d'une technologie !

Fonctionnement général
TensorFlow représente les flux de données sous forme de graphes, où les nœuds représentent des opérations mathématiques et les arrêtes représentent des tenseurs. Ces graphes sont des représentations complètes des calculs qui sont ensuite exécutés sur le CPU ou le GPU.

Tenseur
TensorFlow utilise des tenseurs pour représenter toutes les données. Les tenseurs sont des tableaux de données multidimensionnelles et de taille dynamique. Cette structure peut donc avoir différents niveaux de complexité, du scalaire à une matrice de dimension n.



Variable
Les opérations mathématiques réalisées par TensorFlow découlent directement du ou des modèles utilisés pour l'apprentissage. Hors, ces modèles reposent eux même sur les paramètres (poids et biais pour la softmax regression). Lors de la phase d'entrainement, TensorFlow utilise des variables pour mettre à jour ces paramètres sur lesquels repose le modèle d'apprentissage. Ces variables contiennent des tenseurs (puisque toutes les données sont des tenseurs sous TensorFlow), mais contrairement aux tenseurs, les variables sont modifiées tout au long de la phase d'apprentissage.



Fonctionnement détaillé : Démo MNIST sous Python
Le MNIST fait référence à la base de données MNIST (Mixed National Institute of Standards and Technology), une base de données de chiffres écrits à la main. Ce sont des images en noir et blanc, normalisées centrées de 28 pixels de côté. Les images d'apprentissage étant associé à des étiquettes déterminant le chiffre. La reconnaissance de l'écriture manuscrite étant un problème complexe, le MNIST est devenu un test standard pour les algorithmes d'apprentissages supervisés.

Importation de TensorFlow
La première chose à faire avant de commencer le programme Python est d'importer TensorFlow.



Importation des données MNIST
Ensuite, il faut importer les données MNIST. Chaque donnée est constituée d'une image représentant un chiffre écrit à la main, et de son label correspondant.





Création du modèle d'apprentissage : Softmax Regression
Pour x et y_, le mot clé "tf.placeholder" indique que ce sont simplement des espaces réservés qui vont être remplis par les tenseurs représentant l'ensemble des images et des labels, lors de l'apprentissage.
 * x sera rempli par le tenseur représentant les images (chaque image étant représentés par un vecteur de 784 valeurs, où les 0 représentent les pixels d’intensité faible et les 1 représentent les pixels d’intensité forte).
 * y_ sera rempli par le tenseur représentant les labels (chaque label étant représenté par un vecteur de 10 valeurs où la position du 1 parmi les 0 indique le chiffre, par exemple 3 = [0001000000]).





Pour W et b, le mot clé "tf.variable" indique qu'il s'agit des variables du modèle d'apprentissage, qui seront continuellement recalculées durant la phase d'apprentissage. Ces variables sont initialisées comme des tenseurs pleins de zéros (puisque nous allons apprendre W et b, il n'a pas beaucoup d'importance ce qu'ils sont au départ).
 * w représente le poids.
 * b représente le biais.



Il ne reste plus qu'à mettre en œuvre notre modèle de régression. Ce modèle est très simple, puisqu'il suffit de multiplier les images d'entrée x par la matrice de poids W, puis d'ajouter le biais b. On obtient alors y qui est le label prédit.



Mise en place de la phase d'apprentissage
Lors de la phase d'apprentissage, nous allons chercher à minimiser la perte, c'est-à-dire la distance entre la prévision de notre modèle (y) vis-à-vis du résultat souhaité (y_). Le but est d'améliorer le modèle en modifiant les variables de poids et de biais au cours de la phase d'apprentissage.

La fonction la plus connue pour déterminer la perte d'un modèle est appelée «entropie croisée. Après avoir défini l'entropie croisée, TensorFlow peut automatiquement utiliser l'algorithme de rétropropagation pour déterminer efficacement comment les variables influent sur la perte que vous lui demandez de minimiser. De cette façon, il va modifier les variables afin de réduire la perte.



Lancement de la phase d'apprentissage
TensorFlow repose sur un back-end C++ pour faire son calcul et la connexion à ce back-end est appelée une session. Il faut donc instancier une nouvelle session avant d'initialiser les variables et de lancer l'apprentissage.



Évaluation du modèle d'apprentissage
Le plus important en apprentissage automatique, est de pouvoir connaître la précision de l'algorithme.



tf.argmax(y,1) est le label que notre modèle pense le plus probable, tandis que tf.argmax(y_,1) est le véritable label. Nous pouvons alors utiliser tf.equal pour vérifier si notre prévision correspond à la vérité. Cela nous donne une liste de booléens, que l'on cast en nombre à virgule flottante, avant d'en calculer la moyenne. Par exemple [True, False, True, True] deviendrait [1,0,1,1] qui donnerait 0.75.

La précision de l'algorithme sur les données d'essai est d'environ 92%. Il faut savoir que ce résultat sur le MNIST est mauvais, mais cela s'explique par l'extrême simplicité du modèle utilisé. En effet, nous avons utilisé une seule couche linéaire. Avec un modèle à peine plus sophistiqué (un petit réseau de neurones à convolution), cela nous mène à environ 99,2% de précision. Et des réseaux multicouches de neurones plus complexes mènent proches des 99,9%.

=Webographie=
 * https://www.tensorflow.org/
 * https://github.com/tensorflow/tensorflow
 * http://download.tensorflow.org/paper/whitepaper2015.pdf
 * http://www.lemonde.fr/pixels/article/2015/07/24/comment-le-deep-learning-revolutionne-l-intelligence-artificielle_4695929_4408996.html
 * http://beebom.com/google-brains-tensorflow/
 * https://www.reddit.com/r/artificial/comments/4ym9ba/tensorflow_demo_in_5_minutes/
 * http://www.cell.com/cell-systems/pdf/S2405-4712(16)00010-7.pdf