Je publierai un mémorandum sur TensorFlow, une bibliothèque d'apprentissage en profondeur que Google a commencé à fournir. TensorFlow a une explication détaillée du didacticiel, j'ai donc essayé de le traduire en japonais. ・ À propos de TensorFlow-> http://www.tensorflow.org/ ・ Traduction originale de cette époque-> http://www.tensorflow.org/tutorials/mnist/pros/index.md Puisque je suis un vrai japonais, il peut y avoir des traductions étranges ou des erreurs de traduction, alors faites-le à vos risques et périls. [Référence [Traduction approximative du didacticiel TensorFlow en japonais] 1. MNIST pour les débutants en ML]
Ce tutoriel sera plus facile à comprendre si vous lisez le chapitre 6 du livre de M. Okaya "Deep Learning". Dans cet article, des termes techniques tels que foulée et rembourrage sont également mentionnés, les matériaux de référence sont donc essentiels.
Ensuite, le modèle créé cette fois est un modèle appelé réseau de neurones convolutifs (CNN).
Exécutez le script pour obtenir le jeu de données MNIST.
import input_data
mnist = input_data.read_data_sets('MNIST_data', one_hot=True)
TensorFlow exploite un backend C ++ hautement efficace pour effectuer ses propres calculs. Cette connexion au backend s'appelle une session. Une utilisation courante de TensorFlow consiste à créer d'abord un graphique, puis à exécuter une session.
Mais ici, nous utilisons une classe InteractiveSession pratique, qui donne à TensorFlow plus de flexibilité dans la manière dont les utilisateurs écrivent leur code. Ceci est utile lorsque vous travaillez de manière interactive, comme iPython. Si vous n'utilisez pas InteractiveSession, l'utilisateur devra créer l'intégralité du graphe de calcul avant de démarrer la session, puis exécuter le graphe.
import tensorflow as tf
sess = tf.Interactive Session()
Computation Graph TensorFlow vous permet d'écrire un "graphe" pour exécuter toutes les instructions interactives en dehors de python, au lieu d'exécuter une seule instruction lourde indépendamment en dehors de python. Des techniques similaires sont utilisées dans Theano et Torch.
Le rôle du code python est donc de construire ce graphe de calcul externe et de donner des instructions sur la partie de ce graphe à exécuter.
x = tf.placeholder("float", shape=[None, 784])
y_ = tf.placeholder("float", shape=[None, 10])
W = tf.Variable(tf.zeros([784,10]))
b = tf.Variable(tf.zeros([10]))
sess.run(tf.initialize_all_variables())
y = tf.nn.softmax(tf.matmul(x,W) + b)
cross_entropy = -tf.reduce_sum(y_*tf.log(y))
train_step = tf.train.GradientDescentOptimizer(0.01).minimize(cross_entropy)
for i in range(1000):
batch = mnist.train.next_batch(50)
train_step.run(feed_dict={x: batch[0], y_: batch[1]})
correct_prediction = tf.equal(tf.argmax(y,1), tf.argmax(y_,1))
accuracy = tf.reduce_mean(tf.cast(correct_prediction, "float"))
print accuracy.eval(feed_dict={x: mnist.test.images, y_: mnist.test.labels})
Le taux de réponse correcte du MNIST de 91% est embarrassant. Nous allons construire un petit réseau de neurones convolutifs et viser un taux de réponse correcte de 99,2%.
Pour créer un CNN, vous devez faire beaucoup de poids et de biais. En général, les poids doivent être initialisés avec une petite quantité de bruit pour briser la symétrie et éviter les gradients nuls. Puisque nous utilisons des neurones ReLU cette fois, c'est aussi une bonne idée d'initialiser chaque élément avec un biais initial avec une valeur légèrement positive (pour éviter les "neurones morts"). Au lieu de répéter cela chaque fois que vous construisez un modèle, créons deux fonctions pratiques qui le feront pour vous.
def weight_vairable(shape):
initial = tf.truncated_normal(shape, stddev=0.1)
return tf.Variable(initial)
def bias_variable(shape):
initial = tf.variable(0.1, shape=shape):
return tf.Variable(initial)
TensorFlow vous offre une grande flexibilité dans le pliage et la mise en commun. Comment gérer les limites? Quelle doit être la longueur de la diapositive? Utilisons le plus banal dans cet exemple. Ce CNN prend un pas de 1 et utilise un remplissage nul, donc la sortie est de la même taille que l'entrée. La mise en commun est une mise en commun maximale qui couvre 2 * 2 blocs. Pour garder votre code propre, rassemblons ces opérations dans une fonction.
def conv2d(x,W):
return tf.nn.conv2d(x,W,strides=[1,1,1,1], padding='SAME')
def max_pool_2x2(x):
return tf.nn.max_pool(x, ksize=[1,2,2,1], strides=[1,2,2,1],padding='SAME')
Nous pouvons déjà exécuter le premier niveau. Il y a d'abord une convolution, suivie d'un pooling max. Le pliage calcule 32 fonctionnalités pour chaque patch 5x5 (* Renvoie-t-il 32 numéros pour un patch 5x5?). La forme du tenseur de poids est [5,5,1,32]. Les deux premières dimensions sont la taille du patch, puis le nombre de canaux d'entrée et enfin le nombre de canaux de sortie. Préparez également un vecteur de biais. Chaque élément de ce vecteur est attribué à chaque canal de sortie.
w_conv1 = weight_variable([5,5,1,32])
b_conv1 = bias_variable([32])
Pour adapter cette couche, commencez par façonner le vecteur x en un tenseur à 4 dimensions. Les deuxième et troisième dimensions correspondent à la largeur et à la hauteur de l'image, et la quatrième dimension correspond au canal de couleur.
x_image = tf.reshape(x,[-1,28,28,1])
Maintenant, plions x_image avec un tenseur de poids, ajoutons un biais, affectons-le à la fonction ReLU et obtenons le pool max.
h_conv1 = tf.nn.relu(conv2d(x_image, W_conv1)+b_conv1)
h_pool1 = max_pool_2x2(h_conv1)
La deuxième couche prend 64 fonctionnalités pour un patch 5x5.
W_conv2 = weight_variable([5,5,32,64])
b_conv2 = bias_variable([64])
h_conv2 = tf.nn.relu(conv2d(h_pool1, W_conv2)+b_conv2)
h_pool2 = max_pool_2x2(h_conv2)
La taille de l'image est maintenant tombée à 7x7. Ajoutez à cela une couche entièrement connectée avec 1024 éléments neuronaux et laissez l'image entière être traitée. Tensol de la couche de mise en commun Convertissez la quantité en un lot de vecteurs, multipliez-la par la matrice de poids, ajoutez un biais et affectez-la à ReLU.
W_fc1 = weight_variable([7*7*64, 1024])
b_fc1 = bias_variable([1024])
h_pool2_flat = tf.reshape(h_pool2, [-1, 7*7*64])
h_fc = tf.nn.relu(tf.matmul(h_pool2_flat, W_fc1)+t_fc1)
Appliquez une suppression avant la couche de lecture pour éviter les problèmes de surentraînement. Utilisez une distribution de probabilité pour stocker la sortie du neurone pendant l'abandon et fournissez un espace réservé pour cette distribution de probabilité. (Je ne comprends pas bien le sens) Cela vous permet d'activer le décrochage pendant l'entraînement et de le désactiver pendant le test. En plus de masquer la sortie du neurone, l'instruction tf.nn.dropout de TensorFlow se met automatiquement à l'échelle (..?) Cela permet à la suppression de fonctionner sans mise à l'échelle supplémentaire. (.. ??)
keep_prob = tf.placeholder("float")
h_fc1_drop = tf.nn.dropout(h_fc1, keep_prob)
Enfin, ajoutez le calque Softmax.
W_fc2 = weight_variable([1024,10])
b_fc2 = bias_variable([10])
y_conv = tf.nn.softmax(tf.matmul(h_fc1_drop, W_fc2)+b_fc2)
Les différences avec le réseau Softmax monocouche mentionné ci-dessus sont les suivantes. -Remplace l'optimiseur de dégradé le plus raide par un optimiseur ADAM plus sophistiqué. · Un paramètre supplémentaire keep_prob a été ajouté à feed_dict pour manipuler le taux d'abandon. ・ J'essaie de tenir un journal toutes les 100 séances d'entraînement.
cross_entropy = -tf.reduce_sum(y_*tf.log(y_conv))
train_step = tf.train.AdamOptimizer(1e-4).minimize(cross_entropy)
correct_prediction = tf.equal(tf.argmax(y_conv,1), tf.argmax(y_,1))
accuracy = tf.reduce_mean(tf.cast(correct_prediction, "float"))
sess.run(tf.initialize_all_variables())
for i in range(20000):
batch = mnist.train.next_batch(50)
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})
Recommended Posts