J'ai essayé le Tutoriel officiel de TensorFlow Le résultat est toujours mauvais dans le NN précédent. L'utilisation de CNN améliorera encore la précision.
CNN CNN est souvent utilisé dans la reconnaissance d'image et la reconnaissance vocale. Il peut être créé en combinant une "couche de convolution" et une "couche de regroupement".
① Appliquez un filtre de convolution carré 3 * 3 aux données d'entrée. Le filtre pliable détermine la distance parcourue par la foulée. Si 1 pixel est spécifié, il sera décalé de 1 pixel. Si vous appliquez un filtre pliant 5x5 aux données 28x28, il devient 24x24, ce qui est plus petit. ← Il n'y a aucun remplissage pour gérer cela. Le remplissage à zéro est le processus qui consiste à entourer les données d'entrée de 0. (2) Trouvez la somme des calculs obtenus avec un filtre.
Un processus qui réduit la dimension du résultat du processus de convolution. Exemple: supposons que vous ayez un filtre de pooling 2x2 max pooling applique un filtre de pooling 2x2 au résultat de la convolution et obtient la valeur maximale de ce 2x2.
Cette fois, nous utiliserons la fonction ReLu
La fonction ReLu est la suivante
y = max(x, 0)
0 lorsque 0 ou moins
Lorsqu'il est égal ou supérieur à 0, x
Fonction qui retourne
from tensorflow.examples.tutorials.mnist import input_data
mnist = input_data.read_data_sets('MNIST_data', one_hot = True)
import tensorflow as tf
Cette fois, nous utilisons ʻInteractiveSession () `
sess = tf.InteractiveSession()
Créé avec placeholder. Au fait, j'ai également créé des poids et des biais.
x = tf.placeholder(tf.float32, shape=[None, 784])
y_ = tf.placeholder(tf.float32, shape=[None,10])
W = tf.Variable(tf.zeros([783, 10]))
b = tf.Variable(tf.zeros([10]))
Le poids ʻinitial = tf.truncated_normal (shape, stddev = 0.1) `donne la valeur initiale. Il a une forme dans laquelle les côtés gauche et droit de la distribution normale sont coupés, et stddev spécifie la distribution des données avec l'écart type.
Le biais ʻinitial = tf.constant (0.1, shape = shape) `donne '0.1' comme biais car le calcul ne se poursuit pas si la valeur est" 0 ".
def weight_variable(shape):
initial = tf.truncated_normal(shape, stddev=0.1)
return tf.Variable(initial)
def bias_variable(shape):
initial = tf.constant(0.1, shape=shape)
return tf.Variable(initial)
Argumentez les données d'entrée et l'oreille.
foulées = [1,1,1,1] signifie s'adapter en décalant de 1 pixel.
padding = 'SAME' est converti en données avec des 0 à gauche et à droite (remplis de 0 pour que la sortie ait la même taille que l'entrée).
def conv2d(x, W):
return tf.nn.conv2d(x, W, strides=[1,1,1,1], padding='SAME')
Calque pour extraire des fonctionnalités afin de réduire la taille
ksize = [1,2,2,1] Applique 2 * 2 blocs.
strides = [1,2,2,1] signifie s'adapter en décalant de 2 pixels.
padding = 'SAME' est converti en données avec des 0 à gauche et à droite (remplis de 0 pour que la sortie ait la même taille que l'entrée).
def max_pool_2x2(x):
return tf.nn.max_pool(x, ksize=[1,2,2,1], strides=[1,2,2,1], padding='SAME')
Préparez 32 patchs de poids 5 * 5. [Taille du patch, nombre de canaux d'entrée, nombre de canaux de sortie]. Le biais est préparé autant que le nombre de canaux de sortie.
W_conv1 = weight_variable([5,5,1,32])
b_conv1 = bias_variable([32])
Pour appliquer un calque, commencez par le transformer en un tenseur 4d avec x, les deuxième et troisième dimensions correspondant à la largeur et à la hauteur de l'image, et la dimension finale correspondant au nombre de canaux de couleur. tf.reshape (x, [-1, 28, 28, 1]) transforme la forme de la matrice. Le dernier «1» indique qu'il s'agit d'une image d'ombre.
x_image = tf.reshape(x, [-1, 28, 28, 1])
Pliez avec x_image, tenseur de poids, biais, appliquez la fonction ReLU et enfin appliquez le pool maximum. Cette méthode max_pool_2x2 réduit la taille de l'image à 14x14.
h_conv1 = tf.nn.relu(conv2d(x_image, W_conv1) + b_conv1)
h_pool1 = max_pool_2x2(h_conv1)
W_conv2 = weight_variable ([5,5,32,64]) a 64 patches 5 * 5 de 32 types
Puisqu'il s'agit de la deuxième couche, le calcul de convolution de h_pool1 et W_conv2
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)
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_fc1 = tf.nn.relu(tf.matmul(h_pool2_flat, W_fc1) + b_fc1)
Dropout Appliquez une suppression avant la couche de lecture pour réduire le surajustement. Nous créons des espaces réservés à propos de la probabilité qu'une sortie neuronale soit conservée pendant un abandon. Cela vous permet d'activer les abandons pendant l'entraînement et de les désactiver pendant les tests.
keep_prob = tf.placeholder(tf.float32)
h_fc1_drop = tf.nn.dropout(h_fc1, keep_prob)
W_fc2 = weight_variable ([1024,10]) 1024 lignes x 10 colonnes (établissement des nombres de 0 à 9)
W_fc2 = weight_variable([1024,10])
b_fc2 = bias_variable([10])
y_conv = tf.matmul(h_fc1_drop, W_fc2) + b_fc2
cross_entropy = tf.reduce_mean( tf.nn.softmax_cross_entropy_with_logits(labels=y_, logits=y_conv))
reduction_mean () prend la valeur moyenne
tf.nn.softmax_cross_entropy_with_logits (labels = y_, logits = y_conv) compare l'étiquette correcte (y_) avec la valeur estimée (y_conv)
Définissez la méthode d'apprentissage avec tf.train.AdamOptimizer (1e-4) .minimize (cross_entropy) Cette fois AdamOptimizer
cross_entropy = tf.reduce_mean(
tf.nn.softmax_cross_entropy_with_logits(labels=y_, logits=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, tf.float32))
with tf.Session() as sess:
sess.run(tf.global_variables_initializer())
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}))
Voici un résumé du flux ci-dessus
mnist_cnn.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])
W = tf.Variable(tf.zeros([783, 10]))
b = tf.Variable(tf.zeros([10]))
def weight_variable(shape):
initial = tf.truncated_normal(shape, stddev=0.1)
return tf.Variable(initial)
def bias_variable(shape):
initial = tf.constant(0.1, shape=shape)
return tf.Variable(initial)
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')
W_conv1 = weight_variable([5,5,1,32])
b_conv1 = bias_variable([32])
x_image = tf.reshape(x, [-1, 28, 28, 1])
h_conv1 = tf.nn.relu(conv2d(x_image, W_conv1) + b_conv1)
h_pool1 = max_pool_2x2(h_conv1)
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)
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_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 = weight_variable([1024,10])
b_fc2 = bias_variable([10])
y_conv = tf.matmul(h_fc1_drop, W_fc2) + b_fc2
cross_entropy = tf.reduce_mean(
tf.nn.softmax_cross_entropy_with_logits(labels=y_, logits=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, tf.float32))
with tf.Session() as sess:
sess.run(tf.global_variables_initializer())
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}))
production
step 0, training accuracy 0
step 100, training accuracy 0.9
step 200, training accuracy 0.9
~~~~~~~~~~~~~~~~Abréviation~~~~~~~~~~~~~~~~~
step 19900, training accuracy 1
test accuracy 0.9916
99% !! La précision a été améliorée car elle était de 92% la dernière fois.
Recommended Posts