Tutoriel TensorFlow J'ai essayé CNN 4th

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

Processus de pliage

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

Processus de mise en commun

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.

Fonction d'activation

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

Flux de programme

Lire les données

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

Importer tensorflow

import tensorflow as tf

Configurer une session

Cette fois, nous utilisons ʻInteractiveSession () `

sess = tf.InteractiveSession()

Créez un conteneur pour l'entrée x et corrigez l'étiquette y_

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

Créer une fonction pour calculer les poids et les biais

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)

Processus de pliage / couche de pliage

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

Couche de regroupement

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

Réglage de la première couche de convolution

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

Donne la valeur de x

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

Le résultat du pliage de la première couche

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)

Réglage de la deuxième couche de convolution et résultat de la convolution

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)

Couche de liaison

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)

Lire la couche

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

Formation et évaluation de modèles

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

Programme complet

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

Tutoriel TensorFlow J'ai essayé CNN 4th
J'ai essayé le tutoriel TensorFlow 1er
J'ai essayé le tutoriel TensorFlow 2ème
Tutoriel TensorFlow J'ai essayé MNIST 3rd
J'ai essayé d'exécuter TensorFlow
J'ai essayé d'utiliser magenta / TensorFlow
J'ai essayé le tutoriel MNIST de tensorflow pour les débutants.
J'ai essayé de refactoriser le modèle CNN de TensorFlow en utilisant TF-Slim
Tutoriel du didacticiel TensorFlow
J'ai essayé un réseau de neurones convolutifs (CNN) avec un tutoriel TensorFlow sur Cloud9-Classification des images manuscrites-
J'ai essayé d'exécuter le didacticiel TensorFlow avec des commentaires (_TensorFlow_2_0_Introduction pour les débutants)
J'ai essayé tensorflow pour la première fois
J'ai essayé de visualiser AutoEncoder avec TensorFlow
J'ai essayé de jouer au jeu ○ ✕ en utilisant TensorFlow
J'ai essayé de classer le texte en utilisant TensorFlow
J'ai essayé le réglage fin de CNN avec Resnet
J'ai essayé de gratter
J'ai essayé PyQ
J'ai essayé AutoKeras
J'ai essayé le moulin à papier
J'ai essayé django-slack
J'ai essayé Django
J'ai essayé spleeter
J'ai essayé cgo
J'ai essayé la décomposition matricielle non négative (NMF) avec TensorFlow
J'ai créé un jeu ○ ✕ avec TensorFlow
J'ai essayé le tutoriel TensorFlow (MNIST pour les débutants) sur Cloud9-Classification des images manuscrites-
J'ai couru le tutoriel TensorFlow avec des commentaires (classification du texte des critiques de films)
J'ai essayé d'utiliser paramétré
J'ai essayé d'utiliser argparse
J'ai essayé d'utiliser la mimesis
J'ai essayé d'utiliser anytree
J'ai essayé d'exécuter pymc
J'ai essayé le spoofing ARP
J'ai essayé d'utiliser aiomysql
J'ai essayé Python> autopep8
J'ai essayé d'utiliser coturn
J'ai essayé d'utiliser Pipenv
J'ai essayé d'utiliser matplotlib
J'ai essayé d'utiliser "Anvil".
J'ai essayé d'utiliser Hubot
J'ai essayé d'utiliser ESPCN
J'ai essayé PyCaret2.0 (pycaret-nightly)
J'ai essayé d'utiliser openpyxl
J'ai essayé d'exécuter TensorFlow dans l'environnement AWS Lambda: Préparation
J'ai essayé le deep learning
J'ai essayé AWS CDK!
J'ai essayé d'utiliser Ipython
J'ai essayé de déboguer.
J'ai essayé d'utiliser PyCaret
J'ai essayé d'utiliser cron
[TensorFlow] J'ai essayé d'introduire l'IA dans le repassage des véhicules
J'ai essayé la mapview de Kivy
J'ai essayé d'utiliser ngrok
J'ai essayé d'utiliser face_recognition
J'ai essayé d'utiliser Jupyter
J'ai essayé de déplacer EfficientDet
J'ai essayé la programmation shell