Créez un classificateur avec un taux de reconnaissance de l'écriture manuscrite de 99,2% à l'aide du réseau neuronal convolutif TensorFlow

TensorFlow est la bibliothèque d'apprentissage automatique de Google qui a été ouverte le 9 novembre 2015. Dans cet article, nous construisons un réseau neuronal multicouche appelé apprentissage profond à l'aide de TensorFlow.

TensorFlow peut être utilisé à partir de Python, mais le backend calcule à grande vitesse avec C ++. Ceci est un mémo de travail lorsque j'ai fait un didacticiel pour les utilisateurs avancés de TensorFlow dans l'environnement système Python 2.7 de mac et construit un classificateur d'un modèle de réseau neuronal convolutif multicouche avec un taux de reconnaissance de l'écriture manuscrite de 99,2%. Il a calculé en parallèle avec une utilisation du processeur de 270% et une mémoire de 600 Mo sans aucun paramètre spécial. En regardant le classement MNIST, le taux de reconnaissance de 99,2% semble être le top model.

Tutoriel TensorFlow

J'ai travaillé sur deux tutoriels TensorFlow pour débutants et avancés. Dans le didacticiel, nous utiliserons un ensemble de données manuscrites appelé MNIST pour créer un classificateur à l'aide de l'apprentissage automatique et des données d'apprentissage pour reconnaître les images manuscrites. Pour les débutants, nous allons construire un classificateur avec une précision d'environ 90%, et pour les utilisateurs avancés, nous allons construire un classificateur avec une précision d'environ 99,2%. Le didacticiel avancé est un didacticiel permettant de créer un réseau neuronal multicouche appelé apprentissage profond. MNIST For ML Beginners Deep MNIST for Experts

■ Image: partie de l'ensemble de données manuscrites MNIST utilisé pour ce test Les données MNIST sont un ensemble de données manuscrites de 28 x 28 pixels. mn.png

installer

L'environnement est la série mac et python 2.7. C'est une mauvaise traduction, mais j'ai laissé autant de commentaires que possible. Si vous vous sentez suspect, je vous recommande de lire le texte original du tutoriel.

installer


#Installez TensorFlow
pip install https://storage.googleapis.com/tensorflow/mac/tensorflow-0.5.0-py2-none-any.whl

#Confirmation de l'installation de TensorFlow
python
>>> import tensorflow as tf
>>> hello = tf.constant('Hello, TensorFlow!')
>>> sess = tf.Session()
>>> print sess.run(hello)
Hello, TensorFlow!
>>> a = tf.constant(10)
>>> b = tf.constant(32)
>>> print sess.run(a+b)
42

#MNIST Créer un répertoire pour l'expansion des données manuscrites
mkdir ~/tensorflow
cd ~/tensorflow

touch input_data.py
vi input_data.py
#Saisissez ce contenu_data.Copier dans py
# https://tensorflow.googlesource.com/tensorflow/+/master/tensorflow/g3doc/tutorials/mnist/input_data.py
# input_data.L'importation de py télécharge en interne l'ensemble de données MNIST et l'étend en mémoire.

# input_data.examen py
python
>>>import input_data
>>>mnist = input_data.read_data_sets('MNIST_data', one_hot=True)

Tutoriel MNIST pour les débutants

Créez un classificateur MNIST simple à l'aide de TensorFlow pour reconnaître les caractères manuscrits. Je l'ai écrit pour que ça marche même si je le copie. Référence: MNIST For ML Beginners

mnist_beginner.py


# -*- coding: utf-8 -*-
from __future__ import absolute_import, unicode_literals
import input_data
import tensorflow as tf
#lecture de données mnist
print "****Lire les données MNIST****"
mnist = input_data.read_data_sets("MNIST_data/", one_hot=True)

"""
Démarrage du didacticiel TensorFlow
C à l'arrière de TtensorFlow++Utilise la bibliothèque rapide de.
Construisez un modèle de régression logistique.
"""
print "****Start Tutorial****"
x = tf.placeholder("float", [None, 784])
W = tf.Variable(tf.zeros([784, 10]))
b = tf.Variable(tf.zeros([10]))
y = tf.nn.softmax(tf.matmul(x, W) + b)
y_ = tf.placeholder("float", [None, 10])
cross_entropy = -tf.reduce_sum(y_ * tf.log(y))

# In this case, we ask TensorFlow to minimize cross_entropy
# using the gradient descent algorithm with a learning rate of 0.01.
train_step = tf.train.GradientDescentOptimizer(0.01).minimize(cross_entropy)

#Variables d'apprentissage et initialisation de session
print "****init****"
init = tf.initialize_all_variables()
sess = tf.Session()
sess.run(init)

#Apprenez 1000 fois
print "****Apprenez 1000 fois et affichez les résultats****"
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})

#Affichage des résultats
correct_prediction = tf.equal(tf.argmax(y, 1), tf.argmax(y_, 1))
accuracy = tf.reduce_mean(tf.cast(correct_prediction, "float"))
print sess.run(accuracy, feed_dict={x: mnist.test.images, y_: mnist.test.labels})

Résultat d'exécution


>>>python ./mnist_beginner.py
****Lire les données MNIST****
Extracting MNIST_data/train-images-idx3-ubyte.gz
Extracting MNIST_data/train-labels-idx1-ubyte.gz
Extracting MNIST_data/t10k-images-idx3-ubyte.gz
Extracting MNIST_data/t10k-labels-idx1-ubyte.gz
****Start Tutorial****
****init****
can't determine number of CPU cores: assuming 4
I tensorflow/core/common_runtime/local_device.cc:25] Local device intra op parallelism threads: 4
can't determine number of CPU cores: assuming 4
I tensorflow/core/common_runtime/local_session.cc:45] Local session inter op parallelism threads: 4
****Apprenez 1000 fois et affichez les résultats****
0.9098

Tutoriel MNIST pour les utilisateurs avancés

Il s'agit d'un tutoriel pour créer un classificateur MNIST de réseau neuronal à convolution profonde à l'aide de TensorFlow et reconnaître les caractères manuscrits. Je l'ai écrit pour que ça marche même si je le copie. Deep MNIST for Experts

mnist_expert.py


# -*- coding: utf-8 -*-
from __future__ import absolute_import, unicode_literals
import input_data
import tensorflow as tf

#lecture de données mnist
mnist = input_data.read_data_sets("MNIST_data/", one_hot=True)

# cross_Mettre en œuvre l'entropie
sess = tf.InteractiveSession()
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))

# In this case, we ask TensorFlow to minimize cross_entropy
# using the gradient descent algorithm with a learning rate of 0.01.
train_step = tf.train.GradientDescentOptimizer(0.01).minimize(cross_entropy)

#Apprenez 1000 fois
for i in range(1000):
    batch = mnist.train.next_batch(50)
    train_step.run(feed_dict={x: batch[0], y_: batch[1]})

#Affichage des résultats
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})
#Précision des résultats 91%Avant et après

##########################################
#Construisez un réseau neuronal à convolution profonde
# Build a Multilayer Convolutional Network
#Précision 91%Parce que c'est mauvais, construisez un modèle à convolution profonde 99.2%Il vise à
###########################################

"""
Je ne pouvais juste pas comprendre.. 
Problème de disparition de gradient où le paramètre gradient de la fonction de perte s'approche de zéro à l'infini lorsqu'il y a plusieurs couches(Vanishing gradient problem)Cela semble être une fonction qui initialise le poids avec une petite quantité de bruit comme contre-mesure.

Weight Initialization

To create this model, we're going to need to create a lot of weights and biases.
One should generally initialize weights with a small amount of noise for symmetry breaking,
and to prevent 0 gradients. Since we're using ReLU neurons, it is also good practice to initialize
them with a slightly positive initial bias to avoid "dead neurons." Instead of doing this repeatedly
while we build the model, let's create two handy functions to do it for us.
"""


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)

"""
Convolution and Pooling
TensorFlow also gives us a lot of flexibility in convolution and pooling operations.
How do we handle the boundaries? What is our stride size? In this example,
we're always going to choose the vanilla version. Our convolutions uses a stride of one
and are zero padded so that the output is the same size as the input. Our pooling is plain old
max pooling over 2x2 blocks. To keep our code cleaner, let's also abstract those operations into functions.
"""


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')
"""
Calculez 32 entités avec le patch 5x5 de 1ère couche
[5, 5, 1, 32]Est le premier 5,5 est la taille du patch,1 est le nombre de canaux d'entrée,32 est le nombre de canaux de sortie
"""
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)

"""
Calculez 64 entités avec le patch 5x5 de 2e couche
"""
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 connexion dense

La couche est complètement connectée à 1024 neurones car elle est réduite à une taille d'image de 7x7 (veuillez lire l'original car la traduction est assez suspecte) Les données MNIST sont de 28x28 pixels donc 1/Il semble lire 16 à la fois.

Densely Connected Layer

Now that the image size has been reduced to 7x7, we add a fully-connected layer with 1024 neurons to allow
processing on the entire image. We reshape the tensor from the pooling layer into a batch of vectors,
multiply by a weight matrix, add a bias, and apply a 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_fc1 = tf.nn.relu(tf.matmul(h_pool2_flat, W_fc1) + b_fc1)

"""
Élimine le sur-ajustement

Dropout

To reduce overfitting, we will apply dropout before the readout layer. We create a placeholder
for the probability that a neuron's output is kept during dropout. This allows us to turn dropout
on during training, and turn it off during testing. TensorFlow's tf.nn.dropout op automatically
handles scaling neuron outputs in addition to masking them, so dropout just works without any additional scaling.
"""
keep_prob = tf.placeholder("float")
h_fc1_drop = tf.nn.dropout(h_fc1, keep_prob)

"""
Lire la couche
Ajouter une couche de régression logistique, comme la régression logistique de première couche

Readout Layer
Finally, we add a softmax layer, just like for the one layer softmax regression above.
"""
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)

"""
Apprentissage et évaluation de modèles
Utilisez TensorFlow pour former et évaluer des modèles d'apprentissage sophistiqués et approfondis.
"""
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})

#Affichage des résultats
print "test accuracy %g" % accuracy.eval(feed_dict={
    x: mnist.test.images, y_: mnist.test.labels, keep_prob: 1.0})


Résultat de l'exécution (il a fallu environ 1 heure pour s'exécuter)


>>>python ./mnist_expert.py
Extracting MNIST_data/train-images-idx3-ubyte.gz
Extracting MNIST_data/train-labels-idx1-ubyte.gz
Extracting MNIST_data/t10k-images-idx3-ubyte.gz
Extracting MNIST_data/t10k-labels-idx1-ubyte.gz
can't determine number of CPU cores: assuming 4
I tensorflow/core/common_runtime/local_device.cc:25] Local device intra op parallelism threads: 4
can't determine number of CPU cores: assuming 4
I tensorflow/core/common_runtime/local_session.cc:45] Local session inter op parallelism threads: 4
0.9092
step 0, training accuracy 0.06
step 100, training accuracy 0.68
step 200, training accuracy 0.9
step 300, training accuracy 0.98
step 400, training accuracy 0.9
step 500, training accuracy 0.94
step 600, training accuracy 0.92
step 700, training accuracy 0.84
step 800, training accuracy 0.92
step 900, training accuracy 0.94
step 1000, training accuracy 0.98
step 1100, training accuracy 0.96
step 1200, training accuracy 0.98
step 1300, training accuracy 0.96
step 1400, training accuracy 0.98
step 1500, training accuracy 0.98
step 1600, training accuracy 0.96
step 1700, training accuracy 0.96
step 1800, training accuracy 0.96
....
step 19600, training accuracy 1
step 19700, training accuracy 0.98
step 19800, training accuracy 1
step 19900, training accuracy 1
test accuracy 0.992

■ Image: flux de fonctionnement de TensorFlow Après avoir terminé le tutoriel avancé, j'ai passé en revue ce gif et cela avait un peu de sens. tensors_flowing.gif

référence

TensorFlow MNIST For ML Beginners Deep MNIST for Experts import_data.py Ensemble de données manuscrites MNIST Google rend TensorFlow, une bibliothèque d'intelligence artificielle, open source. Technologie de base pour la recherche vocale, la reconnaissance de photos et la traduction à des fins commerciales

Recommended Posts

Créez un classificateur avec un taux de reconnaissance de l'écriture manuscrite de 99,2% à l'aide du réseau neuronal convolutif TensorFlow
J'ai essayé un réseau de neurones convolutifs (CNN) avec un tutoriel TensorFlow sur Cloud9-Classification des images manuscrites-
Implémentation d'un réseau de neurones convolutifs utilisant uniquement Numpy
Essayez de créer un réseau de neurones / d'apprentissage en profondeur avec scratch
Implémentation d'un réseau de neurones à deux couches 2
Qu'est-ce que le réseau neuronal convolutif?
[TensorFlow] [Keras] Construction d'un réseau neuronal avec Keras
Comprendre le nombre de paramètres d'entrée / sortie du réseau neuronal convolutif
Composez avec un réseau neuronal! Run Magenta
Créer un environnement Tensorflow avec Raspberry Pi [2020]
J'ai essayé la reconnaissance manuscrite des caractères des runes avec scikit-learn
Expérimentez avec divers algorithmes d'optimisation sur le réseau neuronal
Visualisez la couche interne du réseau neuronal
Vérification de la normalisation des lots avec un réseau neuronal multicouche
Reconnaissance des nombres manuscrits par un réseau neuronal multicouche
J'ai couru le tutoriel TensorFlow avec des commentaires (premier réseau de neurones: le début du problème de classification)
Entraînez les données MNIST avec PyTorch en utilisant un réseau neuronal
L'histoire de la création d'un réseau neuronal de génération musicale
Bases de PyTorch (2) -Comment créer un réseau de neurones-
Implémenter un réseau neuronal convolutif
Depuis que j'ai touché Tensorflow pendant 2 mois, j'ai expliqué le réseau de neurones convolutifs d'une manière facile à comprendre avec 95,04% d'identification «hiragana manuscrite».
Expérience de réseau de neurones pliable
Créez une application Web qui reconnaît les nombres avec un réseau neuronal
Un diagramme de réseau a été créé avec les données du COVID-19.
Créez un serveur API Web ultra-rapide avec Falcon
[Apprentissage en profondeur] Classification d'images avec un réseau neuronal convolutif [DW jour 4]
J'ai essayé la reconnaissance de caractères manuscrits des caractères runiques avec CNN en utilisant Keras
Construction d'un réseau neuronal qui reproduit XOR par Z3
Série d'accélération CNN ~ FCNN: Introduction du réseau neuronal convolutif de Fourier ~
Résumons les fonctions de base de TensorFlow en créant un réseau neuronal qui apprend les portes XOR.
Réseau de neurones avec Python (scikit-learn)
3. Distribution normale avec un réseau neuronal!
Réseau de neurones commençant par Chainer
4. Entourez les paramètres avec un réseau neuronal!
Tutoriel TensorFlow - Réseau neuronal à convolution (traduction)
Une histoire qui prend en charge la notation électronique des examens avec reconnaissance d'image