[PYTHON] Erstellen Sie mithilfe des TensorFlow-Faltungsnetzwerks einen Klassifikator mit einer Handschrifterkennungsrate von 99,2%

TensorFlow ist Googles Bibliothek für maschinelles Lernen, die am 9. November 2015 als Open-Source-Version verfügbar war. In diesem Artikel bauen wir mit TensorFlow ein mehrschichtiges neuronales Netzwerk namens Deep Learning auf.

TensorFlow kann von Python aus bedient werden, aber das Backend berechnet mit C ++ mit hoher Geschwindigkeit. Dies ist eine Arbeitsnotiz, als ein Tutorial für fortgeschrittene Benutzer von TensorFlow in der Python 2.7-Systemumgebung von Mac durchgeführt wurde und ein Klassifikator eines mehrschichtigen Faltungsmodells für neuronale Netze mit einer Handschrifterkennungsrate von 99,2% erstellt wurde. Es wurde parallel mit 270% CPU-Auslastung und 600 MByte Speicher ohne spezielle Einstellungen berechnet. Im MNIST-Ranking scheint die Erkennungsrate von 99,2% das Topmodell zu sein.

TensorFlow-Tutorial

Ich habe an zwei TensorFlow-Tutorials für Anfänger und Fortgeschrittene gearbeitet. Im Tutorial verwenden wir einen handgeschriebenen Datensatz namens MNIST, um einen Klassifikator zu erstellen, der maschinelles Lernen verwendet, und Lerndaten, um handgeschriebene Bilder zu erkennen. Für Anfänger werden wir einen Klassifikator mit einer Genauigkeit von ungefähr 90% erstellen, und für fortgeschrittene Benutzer werden wir einen Klassifikator mit einer Genauigkeit von ungefähr 99,2% bauen. Das erweiterte Lernprogramm ist ein Lernprogramm zum Aufbau eines mehrschichtigen neuronalen Netzwerks, das als Deep Learning bezeichnet wird. MNIST For ML Beginners Deep MNIST for Experts

■ Bild: Teil des für diesen Test verwendeten handgeschriebenen MNIST-Datensatzes MNIST-Daten sind handgeschriebene Datensätze mit 28 x 28 Pixel.

installieren

Die Umgebung ist Mac und Python 2.7-Serie. Es ist eine schlechte Übersetzung, aber ich habe so viele Kommentare wie möglich hinterlassen. Wenn Sie sich misstrauisch fühlen, empfehle ich, den Originaltext des Tutorials zu lesen.

installieren

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

#Bestätigung der TensorFlow-Installation
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 Verzeichnis für die handschriftliche Datenerweiterung erstellen
mkdir ~/tensorflow
cd ~/tensorflow

touch input_data.py
vi input_data.py
#Geben Sie diesen Inhalt ein_data.Auf py kopieren
# https://tensorflow.googlesource.com/tensorflow/+/master/tensorflow/g3doc/tutorials/mnist/input_data.py
# input_data.Durch das interne Importieren von py wird das MNIST-Dataset heruntergeladen und im Speicher erweitert.

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

MNIST-Tutorial für Anfänger

Erstellen Sie mit TensorFlow einen einfachen MNIST-Klassifikator, um handgeschriebene Zeichen zu erkennen. Ich habe es so geschrieben, dass es funktioniert, auch wenn ich es kopiere. Referenz: MNIST für ML-Anfänger

mnist_beginner.py

# -*- coding: utf-8 -*-
from __future__ import absolute_import, unicode_literals
import input_data
import tensorflow as tf
#mnist Daten lesen
print "****MNIST-Daten lesen****"
mnist = input_data.read_data_sets("MNIST_data/", one_hot=True)

"""
Das TensorFlow-Tutorial wurde gestartet
C am hinteren Ende von TtensorFlow++Verwendet die schnelle Bibliothek von.
Erstellen Sie ein logistisches Regressionsmodell.
"""
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)

#Lernvariablen und Sitzungsinitialisierung
print "****init****"
init = tf.initialize_all_variables()
sess = tf.Session()
sess.run(init)

#Lerne 1000 mal
print "****Lernen Sie 1000 Mal und zeigen Sie Ergebnisse an****"
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})

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

Ausführungsergebnis

>>>python ./mnist_beginner.py
****MNIST-Daten lesen****
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
****Lernen Sie 1000 Mal und zeigen Sie Ergebnisse an****
0.9098

MNIST-Tutorial für fortgeschrittene Benutzer

Dies ist ein Tutorial zum Erstellen eines MNIST-Klassifikators für neuronale Netze mit tiefer Faltung unter Verwendung von TensorFlow und zum Erkennen handgeschriebener Zeichen. Ich habe es so geschrieben, dass es funktioniert, auch wenn ich es kopiere. Deep MNIST for Experts

mnist_expert.py

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

#mnist Daten lesen
mnist = input_data.read_data_sets("MNIST_data/", one_hot=True)

# cross_Implementieren Sie 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)

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

#Ergebnisanzeige
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})
#Ergebnisgenauigkeit 91%Vorher und nachher

##########################################
#Bauen Sie ein neuronales Netzwerk mit tiefer Faltung auf
# Build a Multilayer Convolutional Network
#Genauigkeit 91%Bauen Sie ein Modell 99 für tiefe Faltung, weil es schlecht ist.2%Es zielt darauf ab
###########################################

"""
Ich konnte es einfach nicht verstehen.. 
Problem des Verschwindens des Gradienten, bei dem der Parametergradient der Verlustfunktion bei mehreren Schichten unendlich gegen Null geht(Vanishing gradient problem)Es scheint eine Funktion zu sein, die das Gewicht als Gegenmaßnahme mit einem geringen Geräuschpegel initialisiert.

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')
"""
Berechnen Sie 32 Features mit dem 5x5-Patch der ersten Ebene
[5, 5, 1, 32]Ist der erste 5,5 ist die Patchgröße,1 ist die Anzahl der Eingangskanäle,32 ist die Anzahl der Ausgangskanäle
"""
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)

"""
Berechnen Sie 64 Features mit dem 5x5-Patch der 2. Ebene
"""
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)

"""
Dichte Verbindungsschicht

Da die Bildgröße auf 7x7 reduziert ist, beträgt die Schicht, die vollständig mit 1024 Neuronen verbunden ist (bitte lesen Sie das Original, da die Übersetzung ziemlich verdächtig ist), MNIST-Daten 28x28 Pixel, also 1/Es scheint 16 auf einmal zu lesen.

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)

"""
Überanpassung beseitigen

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)

"""
Ebene lesen
Fügen Sie eine logistische Regressionsebene hinzu, wie die logistische Regression der ersten Ebene

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)

"""
Modelllernen und Evaluieren
Verwenden Sie TensorFlow, um anspruchsvolle und tiefgreifende Lernmodelle zu trainieren und zu bewerten.
"""
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})

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

Ausführungsergebnis (die Ausführung dauerte ca. 1 Stunde)

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

■ Bild: Betriebsablauf von TensorFlow Nachdem ich das fortgeschrittene Tutorial beendet hatte, überprüfte ich dieses GIF und es machte ein wenig Sinn.

Referenz

TensorFlow MNIST For ML Beginners Deep MNIST for Experts import_data.py Handgeschriebener MNIST-Datensatz Google macht TensorFlow, eine Bibliothek für künstliche Intelligenz, zu Open Source. Grundlegende Technologie für Sprachsuche, Fotoerkennung und Übersetzung zur kommerziellen Nutzung freigegeben