Code pour TensorFlow MNIST débutant / expert avec commentaires japonais
Le code MNIST du didacticiel TensorFlow avec des commentaires japonais écrits par de nombreuses personnes a été très utile pendant l'apprentissage, j'ai donc résumé le mien. (Si vous trouvez des erreurs, je serais heureux si vous pouviez les signaler mm)
# coding: utf-8
#Lire les données
from tensorflow.examples.tutorials.mnist import input_data
mnist = input_data.read_data_sets("MNIST_data/", one_hot=True)
#Charger tensorflow comme tf
import tensorflow as tf
# y = softmax(x*W + b)Définir
##X[?, 784]Défini comme un tenseur de(Aucun signifie que je ne sais pas combien)
x = tf.placeholder(tf.float32, [None, 784])
##W[784, 10]Défini comme un tenseur de. 784 chaque pixel x chaque nombre de 0 à 9.
W = tf.Variable(tf.zeros([784, 10]))
##b[10](Initialiseravectousles0)Défini comme un tenseur de. Biais pour chaque valeur de 0 à 9
b = tf.Variable(tf.zeros([10]))
##Appliquer chaque variable définie à la formule
##matmul est une fonction qui intègre des matrices
y = tf.nn.softmax(tf.matmul(x, W) + b)
# y_(étiquette)À[?, 10]Défini comme un tenseur de
y_ = tf.placeholder(tf.float32, [None, 10])
# cross_Définir l'entropie
cross_entropy = tf.reduce_mean(-tf.reduce_sum(y_ * tf.log(y), reduction_indices=[1]))
# cross_Définir les étapes pour optimiser l'entropie à l'aide de la descente de gradient
train_step = tf.train.GradientDescentOptimizer(0.5).minimize(cross_entropy)
#Initialiser les variables
init = tf.initialize_all_variables()
sess = tf.Session()
sess.run(init)
#Effectuez l'apprentissage dans un mini-lot. Prenez au hasard 100 pièces des données d'entraînement et répétez l'opération pour optimiser 1000 fois
for i in range(1000):
batch_xs, batch_ys = mnist.train.next_batch(100)
sess.run(train_step, feed_dict = {x: batch_xs, y_: batch_ys})
#Calculez le taux de réponse correct en comparant le résultat de la prédiction avec l'étiquette
##Obtenez le résultat de la prédiction sous forme de matrice
correct_prediction = tf.equal(tf.argmax(y, 1), tf.argmax(y_, 1))
##Calculez le taux de réussite
accuracy = tf.reduce_mean(tf.cast(correct_prediction, tf.float32))
#Effectuer l'apprentissage et le taux de réussite de la sortie
print(sess.run(accuracy, feed_dict={x: mnist.test.images, y_: mnist.test.labels}))
Capturer
Ici est facile à comprendre pour les opérations de base de tensorflow telles que le traitement de reduction_xxxxx.
Ceci est facile à comprendre si vous regardez d'abord le diagramme du réseau avant de regarder le code.
Après avoir défini tous les réseaux, le calcul est effectué par rétropropagation à la fin.
# coding: utf-8
#Chargement tensorflow
import tensorflow as tf
#Lire les données
from tensorflow.examples.tutorials.mnist import input_data
mnist = input_data.read_data_sets('MNIST_data',one_hot=True)
#Lancer une session interactive
sess = tf.InteractiveSession()
# x, y_Définir un espace réservé
x = tf.placeholder(tf.float32,shape=[None,784])
y_ = tf.placeholder(tf.float32,shape=[None,10])
#Définir la fonction
##Fonction de traitement d'initialisation du poids
def weight_variable(shape):
#Initialisé avec les côtés gauche et droit de la découpe de distribution normale
initial = tf.truncated_normal(shape,stddev=0.1)
return tf.Variable(initial)
##Fonction de traitement d'initialisation de polarisation
def bias_variable(shape):
initial = tf.constant(0.1,shape=shape)
return tf.Variable(initial)
##Fonction de traitement de perspective de tatami bidimensionnel(Foulée 1,Zéro rembourrage)
def conv2d(x, W):
return tf.nn.conv2d(x,W,strides=[1,1,1,1],padding='SAME')
##Fonction de pooling
def max_pool_2x2(x):
return tf.nn.max_pool(x,ksize=[1,2,2,1],strides=[1,2,2,1],padding='SAME')
#Première fois
##W utilisé pour le premier pliage(Valeur pondérée)
## ([width, height, input, filters]28 × 28 image 1(input)5 pour chaque feuille(width)×5(height)32 types(filters)Pliez chacun avec le filtre pliable)
W_conv1 = weight_variable([5,5,1,32])
##Utilisé dans le premier pliage b(biais)
b_conv1 = bias_variable([32])
#Image d'entrée. Je le remets dans le tenseur pour le plier.
# -La valeur de 1 est déterminée dynamiquement au moment de l'exécution en définissant sur remodeler.
x_image = tf.reshape(x, [-1,28,28,1])
#1ère convolution
h_conv1 = tf.nn.relu(conv2d(x_image,W_conv1) + b_conv1)
#1er regroupement
h_pool1 = max_pool_2x2(h_conv1)
#Deuxième fois
##W utilisé pour le deuxième pliage(Valeur pondérée)
## ([width, height, input, filters]Pliez chacune des 32 images 14x14 avec 64 types de filtres pliants 5x5)
W_conv2 = weight_variable([5,5,32,64])
##Utilisé pour le deuxième pliage b(biais)
b_conv2 = bias_variable([64])
##Seconde convolution utilisant la sortie du tenseur du premier regroupement
h_conv2 = tf.nn.relu(conv2d(h_pool1, W_conv2) + b_conv2)
##Deuxième regroupement
h_pool2 = max_pool_2x2(h_conv2)
#Couche entièrement connectée(Mettez toutes les entrées ensemble dans la fonction softmax)
##W utilisé dans la couche entièrement connectée(Valeur pondérée)
W_fc1 = weight_variable([7*7*64,1024])
##Utilisé dans la couche entièrement connectée b(biais)
b_fc1 = bias_variable([1024])
##Sortie H dans la deuxième convolution_Convertir pool2 en tenseur à deux dimensions
h_pool2_flat = tf.reshape(h_pool2,[-1,7*7*64])
##Sortie du résultat dans la couche entièrement connectée
h_fc1 = tf.nn.relu(tf.matmul(h_pool2_flat,W_fc1) + b_fc1)
## DropOut(Traitement pour supprimer le surapprentissage)
keep_prob = tf.placeholder(tf.float32)
h_fc1_drop = tf.nn.dropout(h_fc1,keep_prob)
##W utilisé pour Drop Out vers une couche entièrement connectée(Valeur pondérée)
W_fc2 = weight_variable([1024,10])
##Utilisé dans Drop Out vers la couche b entièrement connectée(biais)
b_fc2 = bias_variable([10])
#Sortie prévision finale
y_conv = tf.matmul(h_fc1_drop, W_fc2) + b_fc2
#Je veux minimiser la croix_Définir l'entropie
cross_entropy = tf.reduce_mean(tf.nn.softmax_cross_entropy_with_logits(y_conv,y_))
#Définissez les étapes de minimisation avec Adam Optimizer
train_step = tf.train.AdamOptimizer(1e-4).minimize(cross_entropy)
#Cette zone est la même que Beginer
correct_prediction = tf.equal(tf.argmax(y_conv,1),tf.argmax(y_,1))
accuracy = tf.reduce_mean(tf.cast(correct_prediction,tf.float32))
sess.run(tf.initialize_all_variables())
#Effectuer l'apprentissage dans un mini-lot(Prenez au hasard 50 et répétez l'optimisation 50 fois)
for i in range(20000):
batch = mnist.train.next_batch(50)
#Progression de la sortie toutes les 100 fois
if i%100 == 0:
train_accuracy = accuracy.eval(feed_dict={x:batch[0],y_:batch[1],keep_prob:1.0})
print("step %d, training accuracy %g"%(i,train_accuracy))
train_step.run(feed_dict={x:batch[0],y_:batch[1],keep_prob:0.5})
print("test accuracy %g"%accuracy.eval(feed_dict={x: mnist.test.images, y_:mnist.test.labels, keep_prob: 1.0}))
Capturer
Ici a été très utile pour comprendre le réseau de neurones convolutifs.
Recommended Posts