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)

MNIST For ML Beginners

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

Deep MNIST for Experts

Ceci est facile à comprendre si vous regardez d'abord le diagramme du réseau avant de regarder le code.

Screen Shot 2017-03-09 at 19.07.42.png

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

Code pour TensorFlow MNIST débutant / expert avec commentaires japonais
Essayez TensorFlow MNIST avec RNN
J'ai écrit le code pour la génération de phrases japonaises avec DeZero
[Traduisez approximativement le didacticiel TensorFlow en japonais] 1. MNIST pour les débutants en ML
[Traduisez approximativement le didacticiel TensorFlow en japonais] 2. Deep MNIST pour les experts
MNIST (DCNN) avec Keras (backend TensorFlow)
[Explication pour les débutants] Tutoriel TensorFlow MNIST (pour les débutants)
Traduction TensorFlow MNIST pour les débutants en ML
Classifier "Wine" avec le code MLP TensorFlow
Tutoriel TensorFlow MNIST pour les débutants en ML
J'ai essayé d'exécuter le didacticiel TensorFlow avec des commentaires (_TensorFlow_2_0_Introduction pour les débutants)
Tutoriel TensorFlow -MNIST pour les débutants en ML
TensorFlow Deep MNIST pour la traduction d'experts
[Explication pour les débutants] Tutoriel TensorFlow Deep MNIST
Afficher le graphique japonais avec VS Code + matplotlib
Notes supplémentaires pour TensorFlow MNIST pour les débutants en ML
J'ai réécrit le code MNIST de Chainer avec PyTorch + Ignite
Record of TensorFlow mnist Expert Edition (Visualisation de TensorBoard)
Réalisation du didacticiel TensorFlow MNIST pour débutants en ML