Tout d'abord, lisons Commencer. Introduction | TensorFlow
Soudainement, l'exemple de code de TensorFlow sort, mais ici, il montre à quel point il est simple de créer un modèle à l'aide des exemples de données. Si vous n'avez aucune connaissance de l'apprentissage automatique, vous n'en comprendrez pas le sens.
Si vous regardez divers articles de TensorFlow, vous constaterez peut-être que vous pouvez utiliser zéro connaissance de l'apprentissage automatique, mais TensorFlow n'est qu'un outil, donc je pense qu'il est préférable d'avoir le minimum de connaissances pour l'avenir.
Ensuite, il est conseillé de télécharger les données en travaillant sur MNIST traditionnel (Handwritten Character Recognition). Si vous n'avez aucune expérience avec MNIST, nous vous recommandons la «médecine bleue», et si vous êtes habitué à l'apprentissage automatique dans une certaine mesure, la «médecine rouge» est recommandée, alors n'hésitez pas à obtenir la «médecine rouge» ici.
Parce que j'ai étudié l'apprentissage automatique pendant un mois.
Donc, j'ai remarqué ici que j'ai dit "Essayons MNIST", mais je n'avais même pas encore installé TensorFlow. Ce Get started n'est pas en très bon état. L'installation et l'explication du premier exemple de code semblent être suffisantes pour un article Qiita 1, donc MNIST le fera à un autre moment.
TensorFlow install on Mac OS X
(référence) Download and Setup | TensorFlow
Cela dit que si vous utilisez GPU, mais maintenant je veux me concentrer sur l'étude de l'apprentissage automatique, donc j'éviterai de trébucher sur la construction d'autres environnements et ne créerai pas d'environnement GPU. Je vais ignorer tout ce qui concerne la construction de l'environnement GPU.
Je l'ai fait parce qu'il me semblait facile de se préparer dans l'environnement de Virtualenv que j'ai actuellement.
% virtualenv --system-site-packages ~/env/tensorflow
Dans la procédure d'installation du site, le répertoire dans lequel les paramètres d'environnement sont stockés était ~ / tensorflow, mais j'ai organisé l'environnement dans ~ / env, donc je l'ai fait comme ci-dessus. Veuillez modifier le cas échéant en fonction de votre environnement.
% source ~/env/tensorflow/bin/activate
Maintenant, votre console ressemble à ceci et vous êtes prêt à préparer l'environnement pour tensorflow sans polluer d'autres environnements. Nous allons installer tensorflow dans ce domaine.
(tensorflow) %
Suivez les instructions sur le site
(tensorflow) % export TF_BINARY_URL=https://storage.googleapis.com/tensorflow/mac/cpu/tensorflow-0.12.1-py3-none-any.whl
(tensorflow) % pip3 install --upgrade $TF_BINARY_URL
Ceci termine l'installation. Vérifiez le fonctionnement ci-dessous et s'il n'y a pas de problème, c'est OK.
(tensorflow) % python
...
>>> import tensorflow as tf
>>> hello = tf.constant('Hello, TensorFlow!')
>>> sess = tf.Session()
>>> print(sess.run(hello))
Hello, TensorFlow!
>>> a = tf.constant(10)
>>> b = tf.constant(32)
>>> print(sess.run(a + b))
42
Maintenant, l'exemple de code présenté soudainement lors de la mise en route était un simple code de régression linéaire. Je voudrais expliquer cela en détail tout en expliquant la régression linéaire.
Comme il est court, j'ai posté l'intégralité du code.
import tensorflow as tf
import numpy as np
# Create 100 phony x, y data points in NumPy, y = x * 0.1 + 0.3
x_data = np.random.rand(100).astype(np.float32)
y_data = x_data * 0.1 + 0.3
# Try to find values for W and b that compute y_data = W * x_data + b
# (We know that W should be 0.1 and b 0.3, but TensorFlow will
# figure that out for us.)
W = tf.Variable(tf.random_uniform([1], -1.0, 1.0))
b = tf.Variable(tf.zeros([1]))
y = W * x_data + b
# Minimize the mean squared errors.
loss = tf.reduce_mean(tf.square(y - y_data))
optimizer = tf.train.GradientDescentOptimizer(0.5)
train = optimizer.minimize(loss)
# Before starting, initialize the variables. We will 'run' this first.
init = tf.global_variables_initializer()
# Launch the graph.
sess = tf.Session()
sess.run(init)
# Fit the line.
for step in range(201):
sess.run(train)
if step % 20 == 0:
print(step, sess.run(W), sess.run(b))
# Learns best fit is W: [0.1], b: [0.3]
# Close the Session when we're done.
sess.close()
Il y a des commentaires dans le code, mais je pense qu'il vaut mieux être un peu plus détaillé, alors je vais l'expliquer également.
import tensorflow as tf
import numpy as np
# Create 100 phony x, y data points in NumPy, y = x * 0.1 + 0.3
x_data = np.random.rand(100).astype(np.float32)
y_data = x_data * 0.1 + 0.3
À l'origine, si vous souhaitez effectuer une régression linéaire, vous préparez des données d'entraînement à partir de données réelles, mais comme il s'agit d'un didacticiel, nous avons généré et préparé environ 100 données d'entraînement dont la distribution peut être prédite à l'avance. Tout d'abord, nous préparons 100 points de x en utilisant la fonction aléatoire de numpy et en faisons x_data, et nous préparons également 100 points de y_data sur le graphique correspondant. En d'autres termes, les données d'entraînement ne varient pas et sont toutes sur $ y = \ frac {1} {10} x + \ frac {3} {10} $.
Si vous modélisez cela sous la forme $ y = W x + b $, $ W = 0,1 $ et $ b = 0,3 $ sont évidents, mais vous pouvez les utiliser comme données d'entraînement pour la régression linéaire avec TensorFlow. Faire] C'est le but de ce tutoriel.
# Try to find values for W and b that compute y_data = W * x_data + b
# (We know that W should be 0.1 and b 0.3, but TensorFlow will
# figure that out for us.)
W = tf.Variable(tf.random_uniform([1], -1.0, 1.0))
b = tf.Variable(tf.zeros([1]))
y = W * x_data + b
Où W = ... donne la valeur initiale de W. Où b = ... donne la valeur initiale de b.
Dans un réseau de neurones etc., il est nécessaire de donner à W un petit nombre aléatoire afin de casser la symétrie, mais en régression linéaire, la valeur initiale de W peut être tf.zeros ([1]) ainsi que b ([1]). Le résultat est le même). Étant donné que l'exemple de code est utilisé tel quel cette fois, il est initialisé avec un nombre aléatoire.
y = ... est un ensemble de y points émis par ce modèle qui correspond à x_data. En d'autres termes, c'est une fonction hypothétique.
Et
# Minimize the mean squared errors.
loss = tf.reduce_mean(tf.square(y - y_data))
optimizer = tf.train.GradientDescentOptimizer(0.5)
train = optimizer.minimize(loss)
Maintenant, nous voulons sélectionner $ W $ et $ b $ afin que la prédiction du modèle ci-dessus ait le moins d'erreur avec les données réelles, définissez d'abord l'erreur. L'erreur à un certain point est définie par le carré de la différence entre les données prédites y et les données réelles y_data, et la moyenne des erreurs en tous points est définie comme une perte.
Reconfirmons ici la fonction de coût de la régression linéaire.
La perte est la représentation python de ce $ J (\ theta) $ en utilisant TensorFlow. ($ \ Frac {1} {2} $ est omis car il n'est pas pertinent pour la minimisation)
Ensuite, nous définissons l'optimiseur. C'est là que vous décidez quel algorithme utiliser pour minimiser les coûts. Actuellement, GradientDescentOptimizer est spécifié car il utilise la méthode de descente la plus raide parmi les algorithmes fournis dans TensorFlow. L'argument 0,5 est le taux d'apprentissage. À l'origine, je devrais essayer différentes valeurs, mais cette fois autour de 0,5, cela fonctionne bien, j'ai donc spécifié 0,5.
Cliquez ici pour le taux d'apprentissage (= coefficient d'apprentissage) [Niveau pratique d'apprentissage automatique en un mois # 4 (régression linéaire)](http://qiita.com/junichiro/items/d4dc67bdebb9fccb7ef5#%E5%AD%A6%E7%BF%92%E4%BF % 82% E6% 95% B0)
Vous pouvez en savoir plus sur l'Optimizer pré-préparé en consultant la documentation. Optimizers | TensorFlow
Et enfin, cet optimiseur nous dit de minimiser la perte.
# Before starting, initialize the variables. We will 'run' this first.
init = tf.global_variables_initializer()
En fait, TensorFlow ne fait rien avec le code jusqu'à présent. Tout ce que vous avez à faire est de faire divers réglages et de vous préparer. Après cela, l'apprentissage s'exécute en exécutant run, mais avant cela, l'initialisation de diverses valeurs est ce que nous faisons ici.
Au fait, s'il s'agit d'un petit article d'introduction ancien, veuillez noter qu'il y a des cas où ʻinitialize_all_variables` est utilisé ici. Il est obsolète, il n'y a donc aucune raison de l'utiliser à nouveau.
(Référence) TensorFlow initialize_all_variables est devenu obsolète
# Launch the graph.
sess = tf.Session()
sess.run(init)
# Fit the line.
for step in range(201):
sess.run(train)
if step % 20 == 0:
print(step, sess.run(W), sess.run(b))
# Learns best fit is W: [0.1], b: [0.3]
# Close the Session when we're done.
sess.close()
La dernière est la phase d'exécution. TensorFlow s'entraîne dans la session selon les paramètres ci-dessus. Dans cet exemple, le nombre d'itérations est fixé à 200 («plage (201)»), et le processus de minimisation de la fonction de coût définie à l'avance sur «train» est exécuté à plusieurs reprises. L'état est vérifié en sortant sur la console toutes les 20 étapes.
0 [ 0.17769754] [ 0.34861392]
20 [ 0.1106104] [ 0.29447961]
40 [ 0.10272982] [ 0.29857972]
60 [ 0.10070232] [ 0.29963461]
80 [ 0.10018069] [ 0.29990602]
100 [ 0.1000465] [ 0.29997581]
120 [ 0.10001197] [ 0.29999378]
140 [ 0.10000309] [ 0.2999984]
160 [ 0.1000008] [ 0.29999959]
180 [ 0.10000021] [ 0.29999989]
200 [ 0.1000001] [ 0.29999995]
Ce n'est pas très intéressant, mais en répétant les itérations, vous pouvez voir qu'il converge progressivement vers $ W = 0,1 $ et $ b = 0,3 $.
Une fois que vous savez cela, je pense qu'il n'est pas trop difficile d'appliquer le problème général de la régression linéaire. Vous pourrez l'utiliser immédiatement. Je pense que traiter des problèmes de classification tels que la régression logistique peut être résolu sans problème en ajoutant simplement une autre tournure à la fonction de coût.
Si possible, j'aimerais le pratiquer avec un réseau de neurones. Le réseau de neurones sera probablement utilisé en "MNIST traditionnel (reconnaissance de caractères manuscrits)", ce que je n'ai pas fait cette fois, donc j'aimerais le voir le plus tôt possible.
Postscript: je l'ai écrit! Introduction à TensorFlow ~ Petite application de MNIST pour les débutants ~ J'ai essayé le tutoriel TensorFlow "Traditional MNIST (Handwritten Character Recognition)" avec une petite extension de mes propres connaissances. Dans le didacticiel, la fonction softmax est utilisée pour la fonction de coût et la méthode du gradient stochastique est utilisée pour la minimisation, mais vous pouvez comprendre en les remplaçant par celle utilisant la fonction sigmoïde ou celle utilisant la méthode de descente la plus raide. Je m'approfondis.
Autres articles d'introduction sur TensorFlow auxquels j'ai fait référence
J'aimerais faire ce genre de chose à l'avenir.
Recommended Posts