[PYTHON] Comprendre TensorFlow avec l'arithmétique
TensorFlow est principalement une bibliothèque pour la mise en œuvre de l'apprentissage automatique, en particulier les réseaux de neurones multicouches (apprentissage en profondeur), mais vous n'avez pas besoin de faire cela pour comprendre comment cela fonctionne.
Dans cet article, je voudrais démêler le mécanisme de TensorFlow basé sur des calculs simples tels que l'arithmétique.
Caractéristiques de TensorFlow
Tout d'abord, je voudrais résumer les fonctionnalités de TensorFlow. TensorFlow, comme son nom l'indique, est un outil d'écriture de Flow (traitement de calcul) de Tensor (correspondant à un tableau multidimensionnel, une matrice, etc.). Ses caractéristiques sont les suivantes.
- Évolutivité
- Échelle en fonction des ressources de chaque machine, des PC aux serveurs en passant par les appareils mobiles. En d'autres termes, même les serveurs à faible spécification fonctionnent comme ils le devraient, et les serveurs haut de gamme chargés de GPU peuvent utiliser pleinement leurs ressources pour les calculs. Puisque ce «calcul» n'est pas limité à l'apprentissage automatique, il peut également être utilisé dans des scènes qui nécessitent des opérations matricielles à grande échelle.
- Cela contribue à la portabilité et aux performances mentionnées comme fonctionnalités.
- Méthode de description simple / flexible
- Comme pour toute bibliothèque, une notation simple et flexible est possible.
- Il a une fonction de différenciation automatique intégrée, et je pense que c'est une force que vous pouvez apprendre simplement en définissant le processus de calcul et la fonction objectif.
- Utilisation à partir de nombreux langages de programmation
- Actuellement (2015/11/12) uniquement C ++ / Python, mais à l'avenir, SWIG fournira une interface qui pourra également être utilisée à partir d'autres langages.
- Fonction de visualisation
- Livré avec une fonction de visualisation du flux de calcul intégrée appelée TensorBoard
Il convient également de noter qu'il a déjà été utilisé dans divers services (classement de recherche, classification d'images) au sein de Google.
Veuillez vous référer à la partie suivante de la page officielle pour plus de détails sur le contenu ci-dessus.
Comment fonctionne TensorFlow
Le mécanisme de TensorFlow est le suivant.
Le graphe TensorFlow se compose d'un nœud et d'une arête. Le nœud représente le processus de calcul (cercle vert sur la figure) ou l'entrée / sortie à la fin (cercle bleu sur la figure). edge représente un tableau multidimensionnel, ou tenseur, qui est la valeur du résultat du calcul. Ensuite, Graph est affecté à Session pour effectuer le calcul. La session calcule les nœuds qui peuvent être calculés (nœuds dont tous les résultats de calcul sont envoyés depuis l'arête) de manière asynchrone / en parallèle. Lors du calcul, nous attribuons également le périphérique (cpu / gpu) à utiliser.
Voici une vue d'ensemble du processus de calcul dans TensorFlow. Veuillez vous référer à la partie suivante de la page officielle.
De plus, les entrées / sorties à la fin, spécifiquement, la lecture des fichiers et la sauvegarde des résultats des calculs, etc. sont résumées aux endroits suivants.
- Lecture de fichiers, etc.: Tensorflow How to / Reading data
- À propos de l'initialisation / de l'enregistrement / du chargement des variables: [Tensorflow How to / Variables: Creation, Initialization, Saving, and Loading](http://tensorflow.org/how_tos/variables/index.html#variables-creation-initialization- sauvegarde et chargement)
Tous ces processus sont souvent utilisés lors du calcul à l'aide de données, alors assurez-vous de vérifier.
Calcul par TensorFlow
Maintenant, j'aimerais utiliser TensorFlow pour effectuer des calculs arithmétiques ... simples. Le code introduit cette fois est résumé dans le référentiel suivant.
icoxfog417/tensorflow-arithmetic
Vous pouvez vous référer au notebook iPython depuis tensorflow-arithmetic.ipynb.
Installation
Voir ci-dessous pour les instructions d'installation. Il est recommandé d'utiliser «pip install».
Getting Started/Download and Setup
- Prend en charge Python 3 à partir de la version 0.6.0 (version 0.6.0).
- Prend en charge Windows à partir de la version 0.12 (TensorFlow 0.12 prend en charge Windows ))
Calcul
Maintenant, calculons en fait à l'aide de TensorFlow. Dans un premier temps, j'écrirai la formule suivante (bien que les mathématiques soient un peu plus que les mathématiques).
La formule écrite dans TensorFlow est la suivante.
import tensorflow as tf
def x2_plus_b(x, b):
_x = tf.constant(x)
_b = tf.constant(b)
result = tf.square(_x)
result = tf.add(result, _b)
return result
Cela ressemble à la figure ci-dessous.
Maintenant que l'expression est complète, exécutons-la en fait en utilisant Session.
with tf.Session() as sess:
result = sess.run([x2_plus_b(2., 3.)])
print(result)
Le résultat de l'exécution (sortie «print») est le suivant.
[7.0]
Puisque $ 2 ^ 2 + 3 = 7 $, vous pouvez voir que le calcul est fait correctement. Les méthodes arithmétiques disponibles sont documentées.
L'argument peut également être donné sous la forme «placeholder».
import tensorflow as tf
p_x = tf.placeholder(tf.float32)
p_b = tf.placeholder(tf.float32)
p_x2_plus_b = tf.add(tf.square(p_x), p_b)
with tf.Session() as sess:
result = sess.run([p_x2_plus_b], feed_dict={p_x: [2.], p_b: [3.]})
print(result)
Utilisez feed_dict pour passer une valeur à placeholder lors de l'exécution de Session.
Visualisation
L'une des caractéristiques de TensorFlow est qu'il dispose d'un puissant outil de visualisation appelé TensorBoard. Utilisons ceci pour visualiser le résultat du calcul de la formule.
Si vous avez installé avec pip, vous devriez pouvoir exécuter la commande tensorboard. La visualisation est effectuée à l'aide de cela, mais nous allons d'abord afficher la valeur de l'objet à visualiser.
import tensorflow as tf
def monitor_calculation(x, b):
title = "b = {0}".format(b)
c = x2_plus_b(float(x), float(b))
s = tf.scalar_summary(title, c)
m = tf.merge_summary([s]) # if you are using some summaries, merge them
return m
with tf.Session() as sess:
writer = tf.train.SummaryWriter("log", graph_def=sess.graph_def)
xaxis = range(-10, 12)
for b in range(3):
for x in xaxis:
summary_str = sess.run(monitor_calculation(x, b))
writer.add_summary(summary_str, x)
Le but est de résumer la valeur calculée par tf.scalar_summary. Le résumé ainsi calculé est écrit avec tf.train.SummaryWriter.
Lorsque le processus ci-dessus est exécuté, le fichier sera sorti dans le dossier log. Puis lancez tensorboard comme suit:
tensorboard --logdir=/path/to/log-directory
(Le chemin est définitivement un chemin absolu). Ensuite, je pense que le graphique sera affiché comme indiqué ci-dessous (* Cela prend beaucoup de temps pour s'afficher après le démarrage. Si je pensais qu'il ne serait pas affiché pendant longtemps, il pourrait apparaître soudainement) ..
Vous pouvez désormais tracer facilement les valeurs calculées et ainsi de suite. Au moment de l'apprentissage automatique, il sera possible de saisir la situation d'apprentissage en traçant les erreurs et la précision.
De plus, dans l'onglet "GRAPH", vous pouvez voir une visualisation de la formule construite (= graphe).
Veuillez vous reporter aux techniques suivantes pour dessiner des graphiques (telles que la création de processus à l'aide d'espaces de noms et leur assemblage).
TensorBoard: Graph Visualization
Veuillez également vous référer à ce qui suit pour savoir comment utiliser TensorBoard.
TensorBoard: Visualizing Learning
Pour savoir comment exporter le résumé, l'exemple de mnist est utile. Il y a une description du processus dans mnist.py (en utilisant scalar_summary etc. ici), et dans Fully_connected_feed.py, le processus défini dans mnist.py est combiné et exécuté. ..
Ce qui précède est le mécanisme de base de TensorFlow. Ce contenu est similaire au contenu de Getting Started.
Je pense qu'il y aura de plus en plus d'articles sur l'apprentissage automatique avec TensorFlow, j'espère donc que cela vous aidera à les comprendre.