Ich habe [TensorFlow Official Tutorial] ausprobiert (https://www.tensorflow.org/get_started/mnist/pros) Das Ergebnis ist im vorherigen NN immer noch schlecht. Durch die Verwendung von CNN wird die Genauigkeit weiter verbessert.
CNN CNN wird häufig bei der Bilderkennung und Spracherkennung verwendet. Dies kann durch Kombinieren einer "Faltungsschicht" und einer "Pooling-Schicht" erfolgen.
① Wenden Sie einen 3 * 3-Quadrat-Faltungsfilter auf die Eingabedaten an. Der Faltfilter bestimmt die zurückgelegte Strecke. Wenn 1 Pixel angegeben ist, wird es um 1 Pixel verschoben. Wenn Sie einen 5x5-Faltfilter auf 28x28-Daten anwenden, wird dieser 24x24 und kleiner. ← Es gibt keine Polsterung, um damit umzugehen. Beim Null-Auffüllen werden die Eingabedaten mit Nullen umgeben. (2) Ermitteln Sie die Summe der mit einem Filter erhaltenen Berechnungen.
Ein Prozess, der die Dimension des Ergebnisses des Faltungsprozesses reduziert. Beispiel: Angenommen, Sie haben einen 2x2-Pooling-Filter Max Pooling wendet einen 2x2-Pooling-Filter auf das Faltungsergebnis an und erhält den Maximalwert in diesem 2x2.
Dieses Mal werden wir die ReLu-Funktion verwenden
Die ReLu-Funktion lautet wie folgt
y = max(x, 0)
0 wenn 0 oder weniger
Wenn es 0 oder mehr ist, x
Funktion, die zurückgibt
from tensorflow.examples.tutorials.mnist import input_data
mnist = input_data.read_data_sets('MNIST_data', one_hot = True)
import tensorflow as tf
Verwenden Sie diesmal "InteractiveSession ()"
sess = tf.InteractiveSession()
Erstellt mit "Platzhalter". Übrigens habe ich auch Gewichte und Vorurteile geschaffen.
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]))
Das Gewicht initial = tf.truncated_normal (Form, stddev = 0.1) gibt den Anfangswert an. Es hat eine Form, in der die linke und rechte Seite der Normalverteilung abgeschnitten sind, und stddev gibt die Verteilung der Daten mit der Standardabweichung an.
Die Vorspannung "initial = tf.constant (0.1, shape = shape)" ergibt "0.1" als Vorspannung, da die Berechnung nicht fortgesetzt wird, wenn der Wert "0" ist.
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)
Argumentieren Sie die Eingabedaten und das Ohr.
"Schritte = [1,1,1,1]" bedeutet Anpassung durch Verschiebung um 1 Pixel.
padding = 'SAME' wird in Daten mit 0s links und rechts konvertiert (mit 0s gefüllt, damit die Ausgabe dieselbe Größe wie die Eingabe hat).
def conv2d(x, W):
return tf.nn.conv2d(x, W, strides=[1,1,1,1], padding='SAME')
Ebene zum Extrahieren von Features, um die Größe zu reduzieren
ksize = [1,2,2,1] Wende 2 * 2 Blöcke an.
"Schritte = [1,2,2,1]" bedeutet Anpassung durch Verschiebung um 2 Pixel.
padding = 'SAME' wird in Daten mit 0s links und rechts konvertiert (mit 0s gefüllt, damit die Ausgabe dieselbe Größe wie die Eingabe hat).
def max_pool_2x2(x):
return tf.nn.max_pool(x, ksize=[1,2,2,1], strides=[1,2,2,1], padding='SAME')
Bereiten Sie 32 5 * 5 Gewichtspflaster vor. [Patchgröße, Anzahl der Eingangskanäle, Anzahl der Ausgangskanäle]. Die Vorspannung wird so viele wie die Anzahl der Ausgangskanäle vorbereitet.
W_conv1 = weight_variable([5,5,1,32])
b_conv1 = bias_variable([32])
Um eine Ebene anzuwenden, transformieren Sie sie zunächst in einen 4d-Tensor mit x, wobei die zweite und dritte Dimension der Breite und Höhe des Bildes und die endgültige Dimension der Anzahl der Farbkanäle entsprechen. tf.reshape (x, [-1, 28, 28, 1]) transformiert die Form der Matrix. Die letzte '1' zeigt an, dass es sich um ein Schattenbild handelt.
x_image = tf.reshape(x, [-1, 28, 28, 1])
Falten Sie mit x_image, Gewichtstensor, Bias, wenden Sie die ReLU-Funktion an und wenden Sie schließlich den maximalen Pool an. Diese Methode max_pool_2x2 reduziert die Bildgröße auf 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]) hat 64 5 * 5 Patches von 32 Typen
Da es sich um die zweite Schicht handelt, erfolgt die Faltungsberechnung von "h_pool1" und "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 Wenden Sie vor der Leseschicht ein Dropout an, um eine Überanpassung zu vermeiden. Wir Platzhalter erstellen eine Wahrscheinlichkeit, dass eine neuronale Ausgabe während eines Ausfalls erhalten bleibt. Auf diese Weise können Sie Aussetzer während des Trainings ein- und während des Tests ausschalten.
keep_prob = tf.placeholder(tf.float32)
h_fc1_drop = tf.nn.dropout(h_fc1, keep_prob)
W_fc2 = weight_variable ([1024,10]) 1024 Zeilen x 10 Spalten (Festlegung von Zahlen von 0 bis 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))
redu_mean () nimmt den Durchschnittswert an
tf.nn.softmax_cross_entropy_with_logits (labels = y_, logits = y_conv) vergleicht das korrekte Label (y_) mit dem geschätzten Wert (y_conv)
Stellen Sie die Lernmethode mit tf.train.AdamOptimizer (1e-4) .minimize (cross_entropy) ein. Diesmal 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}))
Hier ist eine Zusammenfassung des obigen Ablaufs
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}))
Ausgabe
step 0, training accuracy 0
step 100, training accuracy 0.9
step 200, training accuracy 0.9
~~~~~~~~~~~~~~~~Abkürzung~~~~~~~~~~~~~~~~~
step 19900, training accuracy 1
test accuracy 0.9916
99% !! Die Genauigkeit wurde verbessert, da sie beim letzten Mal 92% betrug.
Recommended Posts