Essayez l'apprentissage en profondeur avec TensorFlow Partie 2

http://qiita.com/northriver/items/17e936343110d392cce8 J'ai essayé le tutoriel pour les débutants ci-dessus, alors allez sur Deep MNIST for Experts

https://www.tensorflow.org/versions/master/tutorials/mnist/pros/index.html

Tout d'abord, apprenons une fois, comme pour les débutants

from tensorflow.examples.tutorials.mnist import input_data
mnist = input_data.read_data_sets('MNIST_data', one_hot=True)

import tensorflow as tf
sess = tf.InteractiveSession()

x = tf.placeholder(tf.float32, [None, 784])
y_ = tf.placeholder(tf.float32, [None, 10])
W = tf.Variable(tf.zeros([784, 10]))
B = tf.Variable(tf.zeros([10]))

#L'initialisation semble être un peu raccourcie
sess.run(tf.initialize_all_variables())

y = tf.nn.softmax(tf.matmul(x,W) + b)
cross_entropy = tf.reduce_mean(-tf.reduce_sum(y_ * tf.log(y), reduction_indices=[1]))
train_step = tf.train.GradientDescentOptimizer(0.5).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, tf.float32))
print(accuracy.eval(feed_dict={x: mnist.test.images, y_: mnist.test.labels}))

0.9085 Jusqu'à présent, le premier examen

D'ici au réseau de convolution multicouche

Selon l'apprentissage MNIST, la précision de 91% est étonnamment faible. Utilisez un réseau de convolution multicouche pour augmenter la précision jusqu'à 99%

Puisque je suis un débutant, je ne peux pas comprendre s'il y a une fonction que j'ai faite, donc tout d'abord, je vais tout restaurer. Tout d'abord, créez un nœud de graphe Partie 1

from tensorflow.examples.tutorials.mnist import input_data
mnist = input_data.read_data_sets("MNIST_data/", one_hot=True)

import tensorflow as tf
sess = tf.InteractiveSession()

x = tf.placeholder(tf.float32, shape=[None, 784])
y_ = tf.placeholder(tf.float32, shape=[None, 10])

w1=tf.Variable(tf.truncated_normal([5,5,1,32],stddev=0.1))
b1=tf.Variable(0.1,[32])
x_image = tf.reshape(x,[-1,28,28,1])
#Couche pliante, couche de mise en commun 1
h_conv1=tf.nn.relu(tf.nn.conv2d(x_image, w1, strides=[1, 1, 1, 1], padding='SAME')+b1)
h_pool1 = tf.nn.max_pool(h_conv1, ksize=[1, 2, 2, 1],strides=[1, 2, 2, 1], padding='SAME')

Quelles sont la couche de pliage et la couche de mise en commun? Ce sont ces couches qui font la différence entre les réseaux de neurones et l'apprentissage profond.

La couche convolutionnelle est "où l'image d'entrée est filtrée et l'extraction de caractéristiques est effectuée". La couche de mise en commun "améliore la robustesse contre les déplacements infimes", hein? Amélioration de la robustesse?

On pense que c'est parce que, par exemple, la zone de frappe est élargie de sorte que même si le nombre "7" est écrit au centre de l'image ou est légèrement décalé vers la gauche ou la droite, il peut être jugé comme "7" de la même manière. Ça fait du bien

En passant, la signification de [5, 5, 1, 32] est [largeur, hauteur, entrée, filtres], et il semble que des filtres de taille 5x5 sont appliqués à chaque image. x_image = tf.reshape (x, [-1,28,28,1]) Il semble que ce qui a été traité avec la matrice 28x28 est retourné à la forme vectorielle d'origine

Faire la deuxième couche

w2=tf.Variable(tf.truncated_normal([5,5,32,64],stddev=0.1))
b2=tf.Variable(0.1,[64])

h_conv2 =tf.nn.relu(tf.nn.conv2d(h_pool1, w2, strides=[1, 1, 1, 1], padding='SAME')+b2)
h_pool2 = tf.nn.max_pool(h_conv2, ksize=[1, 2, 2, 1],strides=[1, 2, 2, 1], padding='SAME')

Créez une couche entièrement connectée À ce stade, la taille de l'image est tombée à 7x7. Ajoutez à cela une couche entièrement connectée avec 1024 éléments neuronaux

W_fc1=tf.Variable(tf.truncated_normal([7 * 7 * 64, 1024],stddev=0.1))
b_fc1=tf.Variable(0.1,[1024])

h_pool2_flat = tf.reshape(h_pool2, [-1, 7*7*64])
h_fc1 = tf.nn.relu(tf.matmul(h_pool2_flat, W_fc1) + b_fc1)

J'ai entendu dire que je voulais me rapprocher de la réponse tout en laissant le plus de fonctionnalités possible, et pour éviter le sur-apprentissage qui ne s'adapte qu'aux données d'entraînement, j'ai entendu dire que cette couche cachée sera créée une fois ... je ne sais pas.

Paramètres de suppression ... Je ne suis pas sûr, mais cela semble nécessaire

keep_prob = tf.placeholder(tf.float32)
h_fc1_drop = tf.nn.dropout(h_fc1, keep_prob)

Lire la couche C'est la même chose que pour les débutants

W_fc2=tf.Variable(tf.truncated_normal([1024, 10],stddev=0.1))
b_fc2=tf.Variable(0.1,[10])

y_conv=tf.nn.softmax(tf.matmul(h_fc1_drop, W_fc2) + b_fc2)

Apprenez et évaluez le modèle

cross_entropy = tf.reduce_mean(-tf.reduce_sum(y_ * tf.log(y_conv), reduction_indices=[1]))
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, tf.float32))
sess.run(tf.initialize_all_variables())

Courir

Courir

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}))

step 0, training accuracy 0.12 step 100, training accuracy 0.8 step 200, training accuracy 0.88 step 300, training accuracy 0.84 step 400, training accuracy 0.96 ・ ・ ・ step 19900, training accuracy 1 test accuracy 0.9914

Je vais le faire 20 000 fois, donc cela prendra du temps. Cela semble prendre plusieurs heures Précision 99%

Ver intégré.py



from tensorflow.examples.tutorials.mnist import input_data
mnist = input_data.read_data_sets("MNIST_data/", one_hot=True)


import tensorflow as tf
sess = tf.InteractiveSession()

x = tf.placeholder(tf.float32, shape=[None, 784])
y_ = tf.placeholder(tf.float32, shape=[None, 10])

w1=tf.Variable(tf.truncated_normal([5,5,1,32],stddev=0.1))
b1=tf.Variable(0.1,[32])
x_image = tf.reshape(x,[-1,28,28,1])

h_conv1=tf.nn.relu(tf.nn.conv2d(x_image, w1, strides=[1, 1, 1, 1], padding='SAME')+b1)
h_pool1 = tf.nn.max_pool(h_conv1, ksize=[1, 2, 2, 1],strides=[1, 2, 2, 1], padding='SAME')

w2=tf.Variable(tf.truncated_normal([5,5,32,64],stddev=0.1))
b2=tf.Variable(0.1,[64])

h_conv2 =tf.nn.relu(tf.nn.conv2d(h_pool1, w2, strides=[1, 1, 1, 1], padding='SAME')+b2)
h_pool2 = tf.nn.max_pool(h_conv2, ksize=[1, 2, 2, 1],strides=[1, 2, 2, 1], padding='SAME')

W_fc1=tf.Variable(tf.truncated_normal([7 * 7 * 64, 1024],stddev=0.1))
b_fc1=tf.Variable(0.1,[1024])

h_pool2_flat = tf.reshape(h_pool2, [-1, 7*7*64])
h_fc1 = tf.nn.relu(tf.matmul(h_pool2_flat, W_fc1) + b_fc1)

keep_prob = tf.placeholder(tf.float32)
h_fc1_drop = tf.nn.dropout(h_fc1, keep_prob)

W_fc2=tf.Variable(tf.truncated_normal([1024, 10],stddev=0.1))
b_fc2=tf.Variable(0.1,[10])

y_conv=tf.nn.softmax(tf.matmul(h_fc1_drop, W_fc2) + b_fc2)

cross_entropy = tf.reduce_mean(-tf.reduce_sum(y_ * tf.log(y_conv), reduction_indices=[1]))
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, tf.float32))
sess.run(tf.initialize_all_variables())

for i in range(10000):
  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

Essayez l'apprentissage en profondeur avec TensorFlow Partie 2
Essayez l'apprentissage en profondeur avec TensorFlow
Essayez le Deep Learning avec FPGA
Essayez le Deep Learning avec les concombres FPGA-Select
Essayez les prévisions de prix Bitcoin avec Deep Learning
Essayez avec Chainer Deep Q Learning - Lancement
Essayez l'apprentissage profond de la génomique avec Kipoi
Essayez la régression avec TensorFlow
Prévision du cours des actions à l'aide du Deep Learning (TensorFlow) - Partie 2
Apprentissage profond du noyau avec Pyro
Essayez le machine learning à la légère avec Kaggle
Générez des Pokémon avec Deep Learning
Essayez TensorFlow MNIST avec RNN
Identification de la race de chat avec Deep Learning
Renforcer l'apprentissage 13 Essayez Mountain_car avec ChainerRL.
[Evangelion] Essayez de générer automatiquement des lignes de type Asuka avec Deep Learning
Faites de l'art ASCII avec l'apprentissage en profondeur
[Tutoriel PyTorch ⑤] Apprentissage de PyTorch avec des exemples (Partie 2)
SVM essayant l'apprentissage automatique avec scikit-learn
Vérifiez la forme de squat avec l'apprentissage en profondeur
[Tutoriel PyTorch ⑤] Apprentissage de PyTorch avec des exemples (Partie 1)
Catégoriser les articles de presse grâce au Deep Learning
Prévisions des ventes de collations avec apprentissage en profondeur
L'apprentissage en profondeur
Essayez l'apprentissage de la représentation commune avec le chainer
Faites sourire les gens avec le Deep Learning
Essayez les données en parallèle avec TensorFlow distribué
Recommandation de manga par machine learning Partie 1 Commençons par diviser sans penser à rien
Introduction au Deep Learning (2) - Essayez votre propre régression non linéaire avec Chainer-
La gestion du tensorflow a soudainement cessé de fonctionner en utilisant le GPU dans l'apprentissage en profondeur
Prédire la demande de puissance avec l'apprentissage automatique, partie 2
Classez les visages d'anime avec l'apprentissage en profondeur avec Chainer
Apprentissage profond / Apprentissage profond à partir de zéro 2-Essayez de déplacer GRU
Prévision du cours des actions à l'aide du Deep Learning (TensorFlow)
Analyse émotionnelle des tweets avec apprentissage en profondeur
Python: Identification du genre (développement de l'apprentissage profond) Partie 1
Python: Identification du genre (développement de l'apprentissage profond) Partie 2
Prévision de stock avec TensorFlow (LSTM) ~ Prévision de stock Partie 1 ~
Mémo d'auto-apprentissage "Deep Learning from scratch" (partie 12) Deep learning
Essayez TensorFlow RNN avec un modèle de base
Renforcer l'apprentissage 11 Essayez OpenAI acrobot avec ChainerRL.
Report_Apprentissage approfondi (partie 2)
Report_Apprentissage approfondi (partie 1)
Essayez Distributed Tensor Flow
Mémorandum d'apprentissage profond
Commencer l'apprentissage en profondeur
Report_Apprentissage approfondi (partie 2)
Une excellente introduction au TensorFlow de Cousera pour vous familiariser avec le Deep Learning
Apprentissage en profondeur Python
Apprentissage profond × Python
Zundokokiyoshi avec TensorFlow
Prédire FX avec LSTM à l'aide de Keras + Tensorflow Partie 2 (Calculer avec GPU)
Casser des blocs avec Tensorflow
Apprentissage automatique à partir de Python Personal Memorandum Part2
Essayez Tensorflow avec une instance GPU sur AWS
Apprentissage automatique à partir de Python Personal Memorandum Part1
Une fuite de mémoire s'est produite après l'apprentissage du DQN avec tensorflow == 2.0.0
99,78% de précision avec apprentissage en profondeur en reconnaissant les hiragana manuscrits
Interpolation d'images vidéo par apprentissage en profondeur, partie 1 [Python]
Essayez Katsuhiro Morishita / Aso_Sea_Clouds_Pridiction Memo-Excluant la partie d'apprentissage-