[PYTHON] 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.

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.

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