Probablement l'introduction la plus simple à TensorFlow

J'ai essayé TensorFlow

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

Explication de la régression linéaire

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.

Ce que vous essayez de faire avec ce code

  1. Préparez environ 100 points sur la droite représentée par $ y = \ frac {1} {10} x + \ frac {3} {10} $.
  2. Effectuez une régression linéaire en l'utilisant comme données d'entraînement
  3. Définissez un modèle sous la forme $ y = W x + b $ et effectuez une régression linéaire en utilisant TensorFlow pour obtenir les paramètres $ W $ et $ b $.
  4. Assurez-vous que $ W $ et $ b $ sont respectivement proches de $ \ frac {1} {10} (= 0,1) $ et $ \ frac {3} {10} (= 0,3) $.

Commentaire de code

Importer les bibliothèques requises

import tensorflow as tf
import numpy as np

Préparation des données d'entraînement

# 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.

Définition du modèle de régression linéaire

# 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.

y = h_\theta(x)

Et $ h_\theta(x) = W x + b $ Est-ce.

Définition de la fonction de coût

# 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.

J(\theta) = \frac{ 1 }{ m }\sum_{ i = 1 }^{ m }\frac{ 1 }{ 2 }(h_\theta(x^{ (i) }) - y^{ (i) })^2

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.

Initialisation avant exécution

# 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

Phase d'exécution

# 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.

résultat

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.

(Référence) Niveau pratique d'apprentissage automatique en un mois # 7 (Problème de classification: régression logistique # 1)

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.

référence

Autres articles d'introduction sur TensorFlow auxquels j'ai fait référence

à partir de maintenant

J'aimerais faire ce genre de chose à l'avenir.

Recommended Posts

Probablement l'introduction la plus simple à TensorFlow
Introduction à Private TensorFlow
Introduction à TensorFlow - Hello World Edition
[Introduction à Python] Qu'est-ce que Python, le langage de programmation le plus puissant actuellement?
Les débutants lisent "Introduction à TensorFlow 2.0 pour les experts"
Introduction à Scrapy (1)
Introduction à Scrapy (3)
Premiers pas avec Supervisor
Introduction à Python Préparons l'environnement de développement
Introduction à Tkinter 1: Introduction
L'inexactitude de Tensorflow était due à log (0)
[Introduction à AWS] Le premier Lambda est Transcribe ♪
Introduction à PyQt
Introduction à Scrapy (2)
[Introduction à TensorBoard] Visualisez le traitement TensorFlow pour approfondir la compréhension
[Linux] Introduction à Linux
[Introduction à Python3 Jour 20] Chapitre 9 Démêler le Web (9.1-9.4)
Introduction à Python avec Atom (en route)
Introduction à Scrapy (4)
Introduction à discord.py (2)
[Introduction à l'algorithme] Trouvez l'itinéraire le plus court [Python3]
De l'introduction de pyethapp à l'exécution du contrat
Jour 66 [Introduction à Kaggle] Les prévisions Titanic les plus faciles
Une introduction approximative à la bibliothèque de traduction automatique neuronale
[Introduction à Python] Comment itérer avec la fonction range?
[Introduction à Udemy Python3 + Application] 27. Comment utiliser le dictionnaire
[Introduction à Udemy Python3 + Application] 30. Comment utiliser l'ensemble
[Introduction à Python] Comment arrêter la boucle en utilisant break?
[Introduction à RasPi4] Construction de l'environnement; OpenCV / Tensorflow, entrée japonaise ♪
[Introduction à Python] Utilisation basique de la bibliothèque matplotlib
[Introduction à TensorBoard: image] TensorFlow Visualisez le traitement d'image pour approfondir la compréhension
Introduction à Lightning Pytorch
Introduction aux baies non paramétriques
Introduction à EV3 / MicroPython
Introduction à la reconnaissance d'image TensorFlow
Introduction à OpenCV (python) - (2)
Introduction à PyQt4 Partie 1
La route vers Pythonista
Introduction à l'injection de dépendances
Introduction à Private Chainer
La route vers Djangoist
Introduction à l'apprentissage automatique
[TensorFlow] Je souhaite maîtriser l'indexation pour Ragged Tensor
J'ai essayé de porter le code écrit pour TensorFlow sur Theano
J'ai essayé de trouver la moyenne de plusieurs colonnes avec TensorFlow
Une introduction à l'orientation des objets - changeons l'état interne d'un objet
[Explication pour les débutants] Introduction au traitement du pliage (expliqué dans TensorFlow)
[Explication pour les débutants] Introduction au traitement du pool (expliqué dans TensorFlow)
[Introduction à matplotlib] Lire l'heure de fin à partir des données COVID-19 ♬
Une introduction à l'API de socket moderne pour apprendre en C
[Apprentissage de renforcement d'introduction] Renforcement de l'apprentissage pour bouger pour le moment
[Introduction à Tensorflow] Comprendre correctement Tensorflow et essayer de créer un modèle
[Introduction à Python] Comment obtenir des données avec la fonction listdir
J'ai essayé de créer Othello AI avec tensorflow sans comprendre la théorie de l'apprentissage automatique ~ Introduction ~