Depuis la sortie de TensorFlow, j'ai décidé d'étudier les réseaux neuronaux tout en l'utilisant. Je garderai une trace de mes études en fonction de mon humeur.
Avec pip, la version CPU exécute simplement la commande comme indiqué par readme. https://github.com/tensorflow/tensorflow
J'ai pu confirmer qu'il fonctionne correctement sur Ubuntu et Mac. Les utilisateurs de Windows ne savent pas comment faire, alors faites de votre mieux. Une fois installé, tapez ʻimport tensorflow as tf` pour vous assurer de ne pas vous fâcher.
J'ai commencé avec le tutoriel suivant. http://tensorflow.org/tutorials/mnist/beginners/index.md
Eh bien, c'est comme une régression logistique avec une sortie en 10 dimensions, et c'est la classification habituelle des caractères manuscrits MNIST. Je pensais que j'écrirais un diagramme ou une formule, mais le diagramme dans le didacticiel était si beau que j'ai pensé que c'était correct.
Veuillez noter que input_data.py est nécessaire pour exécuter le code du didacticiel.
# -*- coding: utf-8 -*-
import input_data
import tensorflow as tf
#Téléchargement et chargement des ensembles de données MNIST
mnist = input_data.read_data_sets("MNIST_data/", one_hot=True)
#Préparer des variables qui représentent des poids et des seuils(La valeur initiale est zéro)
W = tf.Variable(tf.zeros([784, 10]))
b = tf.Variable(tf.zeros([10]))
#Variables pour insérer des vecteurs de caractéristiques pendant l'entraînement
x = tf.placeholder("float", [None, 784])
#Définir la fonction Softmax
y = tf.nn.softmax(tf.matmul(x, W) + b)
#Variable pour saisir la vraie valeur d'étiquette pendant l'entraînement
y_ = tf.placeholder("float", [None,10])
#Définition de la fonction de perte avec entropie croisée
cross_entropy = -tf.reduce_sum(y_ * tf.log(y))
#Définir la méthode d'apprentissage(Taille de pas 0.Visez à minimiser l'entropie croisée avec la méthode du gradient de 01)
train_step = tf.train.GradientDescentOptimizer(0.005).minimize(cross_entropy)
#Préparez une session
sess = tf.Session()
#Processus d'initialisation variable
init = tf.initialize_all_variables()
sess.run(init)
for i in range(1000):
#Données à utiliser dans un mini-lot
batch_xs, batch_ys = mnist.train.next_batch(100)
#Mettre à jour à l'aide du dégradé
sess.run(train_step, feed_dict={x: batch_xs, y_: batch_ys})
#Définissez une fonction qui renvoie le pourcentage de réponses correctes
correct_prediction = tf.equal(tf.argmax(y, 1), tf.argmax(y_, 1))
accuracy = tf.reduce_mean(tf.cast(correct_prediction, "float"))
#Voir les résultats
print sess.run(accuracy, feed_dict={x: mnist.test.images, y_: mnist.test.labels})
#Téléchargement et chargement des ensembles de données MNIST
mnist = input_data.read_data_sets("MNIST_data/", one_hot=True)
Préparez les données à l'aide du mystérieux module de téléchargement de l'ensemble de données MNIST fourni par Google. Je n'en ai pas besoin séparément, mais il est difficile de le réécrire, alors utilisons-le. Étant donné que ma maison est une ligne ADSL, le téléchargement prendra un certain temps, mais cela conviendra à votre maison.
#Préparer des variables qui représentent des poids et des seuils(La valeur initiale est zéro)
W = tf.Variable(tf.zeros([784, 10]))
b = tf.Variable(tf.zeros([10]))
Préparez une matrice W représentant les poids et un seuil b. C'est comme un tableau de numpy, mais nous le préparons comme un type appelé Variable pour être manipulé par TensorFlow. C'est gênant, mais supportons-le. Il semble que vous puissiez également convertir le tableau de numpy en variable comme suit.
W = tf.Variable(np.random.uniform(-1, 1, size=[784, 10]))
#Variables pour insérer des vecteurs de caractéristiques pendant l'entraînement
x = tf.placeholder("float", [None, 784])
#Définir la fonction Softmax
y = tf.nn.softmax(tf.matmul(x, W) + b)
#Variable pour saisir la vraie valeur d'étiquette pendant l'entraînement
y_ = tf.placeholder("float", [None,10])
#Définition de la fonction de perte avec entropie croisée
cross_entropy = -tf.reduce_sum(y_ * tf.log(y))
Une chose mystérieuse appelée placeholder est sortie. Il s'agit d'une variable dont la valeur n'a pas encore été donnée, et lorsque vous spécifiez la valeur de x ou y_ plus tard, c'est le résultat de l'opération qui l'utilise y Vous pouvez évaluer ce qui arrive aux valeurs de ʻet cross_entropy`.
Plus précisément, lorsque vous mettez la matrice de caractéristiques dans «x» et la vraie étiquette dans «y», vous évaluez la fonction de perte «cross_entropy».
#Définir la méthode d'apprentissage(Taille de pas 0.Visez à minimiser l'entropie croisée avec la méthode du gradient de 01)
train_step = tf.train.GradientDescentOptimizer(0.005).minimize(cross_entropy)
Spécifiez la méthode d'optimisation et la valeur que vous souhaitez minimiser. Ici, nous spécifions la méthode de descente la plus raide. 0,005 correspond à la taille du pas. Cela n'a pas d'importance, mais dans le réseau neuronal, il s'agit du taux d'apprentissage, alors que dans l'optimisation Étant donné que les gens utilisent la méthode du gradient autre que l'apprentissage automatique, elle est souvent appelée taille de pas.
#Préparez une session
sess = tf.Session()
#Processus d'initialisation variable
init = tf.initialize_all_variables()
sess.run(init)
À ce stade, le concept mystérieux d'une session est apparu. Je ne suis pas sûr, mais TensorFlow semble gérer les variables, etc. pour chaque session. Si vous ne créez pas de session et n'effectuez pas de traitement d'initialisation, Variable, etc. jusqu'à présent Il n'est pas possible d'apporter la valeur de ce qui a été créé. Une fois le processus d'initialisation terminé, par exemple, regardez le contenu de «W» via une session comme suit.
>>> sess.run(W)
array([[ 0.6923129 , -0.20792764, 0.03128824, ..., 0.91015261,
0.84531021, -0.81436723],
[-0.6045441 , 0.18968499, -0.48082295, ..., -0.65939605,
0.61858588, -0.2352511 ],
[-0.56046396, -0.35212722, -0.44472805, ..., 0.82507199,
0.77793002, -0.87778318],
...,
[ 0.73705292, 0.13759996, -0.33590671, ..., 0.15150025,
-0.2162281 , -0.36046752],
[-0.90121216, -0.09728234, -0.40505442, ..., 0.02105984,
-0.46720058, -0.49198067],
[ 0.29820383, 0.80599529, 0.97673845, ..., -0.43288365,
-0.73505884, -0.8707968 ]], dtype=float32)
for i in range(1000):
#Données à utiliser dans un mini-lot
batch_xs, batch_ys = mnist.train.next_batch(100)
#Mettre à jour à l'aide du dégradé
sess.run(train_step, feed_dict={x: batch_xs, y_: batch_ys})
J'ai mis les données dans «x», «y_» pour lesquelles aucune valeur spécifique n'a été définie et j'ai mis à jour «W», «b» en utilisant la méthode d'apprentissage spécifiée. Bien sûr, cette procédure passe également par la session. Je le ferai.
#Définissez une fonction qui renvoie le pourcentage de réponses correctes
correct_prediction = tf.equal(tf.argmax(y, 1), tf.argmax(y_, 1))
accuracy = tf.reduce_mean(tf.cast(correct_prediction, "float"))
#Voir les résultats
print sess.run(accuracy, feed_dict={x: mnist.test.images, y_: mnist.test.labels})
Je regarde le taux de réponse correct.
C'est assez similaire à Theano, mais je pense que c'est un peu plus facile à attacher que Theano. (Theano * 2 + Chainer) / 3 impression. TensorBoard semble incroyable, alors je veux y toucher.
Recommended Posts