Ich habe das TensorFlow-Tutorial (MNIST für Anfänger) in der Cloud9-Klassifizierung handgeschriebener Bilder ausprobiert-, um einfaches maschinelles Lernen zu implementieren Ich tat. Als nächstes habe ich TensorFlows "Deep MNIST for Experts" ausprobiert. Da es für Profis geschrieben wurde, werden verschiedene Methoden verwendet, aber es ist leichter zu verstehen, wenn Sie den Code schreiben. Hier werden wir ein bewährtes Faltungs-Neuronales Netzwerk (CNN) bei der Klassifizierung von Bildern implementieren.
Die Umgebung ist die gleiche wie beim letzten Mal. Cloud9 Python 2.7.6 Sample Codes : GitHub Die Umgebungskonstruktion lautet "TensorFlow in Cloud-integrierter Entwicklungsumgebung Cloud9 ~ GetStarted ~ verwenden" Die grundlegende Verwendung von TesorFlow lautet "Verwenden von TensorFlow in einer Cloud-integrierten Entwicklungsumgebung Cloud9-Grundlagen der Verwendung-". Sehen
Wie beim letzten Mal wird es durch den Lernverarbeitungscode und den handgeschriebenen Datenvorhersagecode in zwei Teile geteilt. Schauen wir uns zunächst den Code des Lernprozesses an.
nist_neural_train.py
from tensorflow.examples.tutorials.mnist import input_data
import tensorflow as tf
# Define method
def weight_variable(shape, name):
initial = tf.truncated_normal(shape, stddev=0.1)
return tf.Variable(initial, name=name)
def bias_variable(shape, name):
initial= tf.constant(0.1, shape=shape)
return tf.Variable(initial, name=name)
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')
# Download gz files to MNIST_data directory
mnist = input_data.read_data_sets('MNIST_data', one_hot=True)
# Initializing
sess = tf.InteractiveSession()
x = tf.placeholder(tf.float32, shape=[None, 28*28])
y_ = tf.placeholder(tf.float32, shape=[None, 10])
x_image = tf.reshape(x, [-1, 28, 28, 1])
W_conv1 = weight_variable([5, 5, 1, 32], name="W_conv1")
b_conv1 = bias_variable([32], name="b_conv1")
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], name="W_conv2")
b_conv2 = bias_variable([64], name="b_conv2")
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], name="W_fc1")
b_fc1 = bias_variable([1024], name="b_fc1")
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], name="W_fc2")
b_fc2 = bias_variable([10], name="b_fc2")
y_conv = tf.matmul(h_fc1_drop, W_fc2) + b_fc2
# Making model
cross_entropy = tf.reduce_mean(tf.nn.softmax_cross_entropy_with_logits(y_conv, y_))
# Training
train_step = tf.train.GradientDescentOptimizer(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))
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})
# Evaluating
#print("test accuracy %g" %accuracy.eval(feed_dict={x: mnist.test.images, y_: mnist.test.labels, keep_prob: 1.0}))
# Save train data
saver = tf.train.Saver()
saver.save(sess, 'param/neural.param')
Der Grundablauf ist der gleiche wie beim letzten Mal, aber ich werde den Unterschied erklären.
def weight_variable(shape, name):
initial = tf.truncated_normal(shape, stddev=0.1)
return tf.Variable(initial, name=name)
def bias_variable(shape, name):
initial= tf.constant(0.1, shape=shape)
return tf.Variable(initial, name=name)
Definition des Parameterinitialisierungsprozesses. Das letzte Mal wurde es tatsächlich mit 0 initialisiert, aber es scheint besser, nicht 0 zu sein. Ich verwende eine Funktion namens ReLU, eine spezielle Funktion mit einer Steigung von 1, wenn es sich um einen positiven Wert handelt, und 0, wenn es sich um einen negativen Wert handelt, und aus diesem Grund diejenigen, die einen kleinen positiven Wert als Anfangswert haben Scheint gut zu sein.
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')
Faltung (conv2d) und Pooling (max_pool_2x2), die die Ursprünge des Namens des neuronalen Faltungsnetzwerks sind. Die detaillierte Verarbeitung wird unten erläutert.
W_conv1 = weight_variable([5, 5, 1, 32], name="W_conv1")
b_conv1 = bias_variable([32], name="b_conv1")
h_conv1 = tf.nn.relu(conv2d(x_image, W_conv1) + b_conv1)
h_pool1 = max_pool_2x2(h_conv1)
Es ist eine Faltschicht. Von den [5, 5, 1, 32] in W_conv1 repräsentiert 5 * 5 den Patch. Eine Ebene zum Erfassen der Merkmale eines Bildes, die einen Teil des Bildes herausnimmt (5 * 5) und den Übereinstimmungsstatus mit diesem Teil für das Bild berechnet. Auf diese Weise können Sie die Funktionen des Bildes erfassen. 1 ist eine Eingabe und repräsentiert eine Bilddaten, die eingegeben werden sollen. 32 ist die Ausgabe, und 32 Arten von Patches erfassen die Eigenschaften der Bilddaten.
Das Relu von h_conv1 ist die ReLU-Funktion. Wenn es ein negativer Wert ist, ist es 0, wenn es ein positiver Wert ist, ist die Steigung 1, das heißt, es ist eine Funktion, die den Eingabewert so verwendet, wie er ist. Da die Neigung 1 ist, wird verhindert, dass die Neigung zu klein oder zu 0 wird und Sie nicht lernen können.
h_pool1 wird als Pooling-Ebene bezeichnet und ist ein Prozess, bei dem der Maximalwert von 4 Quadraten von 2 * 2 im Bild zu 1 Quadrat zusammengefasst wird. Das Bild war ursprünglich 28 * 28, was einem Viertel von 14 * 14 entspricht. Selbst wenn die Bilddaten ein wenig abweichen, werden es unterschiedliche Daten sein, aber ich denke, dass die Abweichung durch Aggregation durch Pooling absorbiert werden kann. (Ich entschuldige mich, wenn ich falsch liege)
W_conv2 = weight_variable([5, 5, 32, 64], name="W_conv2")
b_conv2 = bias_variable([64], name="b_conv2")
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], name="W_fc1")
b_fc1 = bias_variable([1024], name="b_fc1")
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)
conv2 implementiert lediglich die oben beschriebene Faltungsschicht erneut. fc1 ist genau die gleiche Berechnung wie beim letzten Mal. Bei h_pool2_flat wird das mehrdimensionale Array jedoch in eine Dimension konvertiert, sodass fc1 berechnet werden kann.
keep_prob = tf.placeholder(tf.float32)
h_fc1_drop = tf.nn.dropout(h_fc1, keep_prob)
Dropout bedeutet, dass einige Daten nicht mit der von keep_prob festgelegten Wahrscheinlichkeit verwendet werden. Auf diese Weise können Sie ein Überlernen verhindern (eine Situation, in der die Genauigkeit in den Trainingsdaten hoch ist, jedoch nicht in den Testdaten). Der Wert von keep_prob wird während der Verarbeitung festgelegt, während des Trainings wird jedoch 0,5 verwendet und 1,0 wird zur Überprüfung mit Testdaten verwendet (ohne Dropout).
#print("test accuracy %g" %accuracy.eval(feed_dict={x: mnist.test.images, y_: mnist.test.labels, keep_prob: 1.0}))
Es ist ein Verifikationsteil mit Testdaten, der jedoch auskommentiert ist. Dies liegt daran, dass cloud9 anscheinend nicht mehr genügend Speicherplatz hat und hier ein Fehler auftritt. Das oben beschriebene Dropout keep_prob ist auf 1.0 gesetzt.
Sie können die nachfolgende Verarbeitung anhand der zuletzt erläuterten Inhalte verstehen. Als ich das Training durchführte, war cloud9 sehr zeitaufwändig, da es kostenlos war und eine schlechte CPU und Speicher hatte. Es dauert mehrere Stunden bis einen halben Tag. Da die Parameter gespeichert werden, können die folgenden Daten sofort vorhergesagt werden, aber es war schwierig, als das Lernen wiederholt werden musste.
Als ich versuchte, meine handschriftlichen Daten wie zuvor vorherzusagen, waren es 50%. Ursprünglich sollte die Genauigkeit zunehmen, im Gegenteil, sie nimmt ab. .. .. Ich weiß nicht, ob die handschriftlichen Daten 1 und 0 sind oder ob es nur 10 handgeschriebene Daten gibt, daher weiß ich nicht, ob sie zufällig ausgeschaltet sind, aber ich denke, sie sind nicht gut genug. ⇒ Vorverarbeitung war erforderlich, um handschriftliche Daten vorherzusagen. Weitere Informationen finden Sie im Artikel Vorhersagen Ihrer handschriftlichen Daten mit TensorFlow.
mnist_neural.py
from tensorflow.examples.tutorials.mnist import input_data
import tensorflow as tf
import sys
import numpy as np
import parsebmp as pb
# Define method
def weight_variable(shape, name):
initial = tf.truncated_normal(shape, stddev=0.1)
return tf.Variable(initial, name=name)
def bias_variable(shape, name):
initial= tf.constant(0.1, shape=shape)
return tf.Variable(initial, name=name)
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')
def whatisit(file, sess):
print("File name is %s" % file)
data = pb.parse_bmp(file)
# Show bmp data
for i in range(len(data)):
sys.stdout.write(str(int(data[i])))
if (i+1) % 28 == 0:
print("")
# Predicting
d = np.array([data])
x_image = tf.reshape(d, [-1, 28, 28, 1])
h_conv1 = tf.nn.relu(conv2d(x_image, W_conv1) + b_conv1)
h_pool1 = max_pool_2x2(h_conv1)
h_conv2 = tf.nn.relu(conv2d(h_pool1, W_conv2) + b_conv2)
h_pool2 = max_pool_2x2(h_conv2)
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)
h_fc1_drop = tf.nn.dropout(h_fc1, 1.0)
y_conv = tf.matmul(h_fc1_drop, W_fc2) + b_fc2
result = sess.run(y_conv)
# Show result
print(result)
print(np.argmax(result, 1))
if __name__ == "__main__":
# Restore parameters
W = tf.Variable(tf.zeros([28*28, 10]), name="W")
b = tf.Variable(tf.zeros([10]), name="b")
W_conv1 = weight_variable([5, 5, 1, 32], name="W_conv1")
b_conv1 = bias_variable([32], name="b_conv1")
W_conv2 = weight_variable([5, 5, 32, 64], name="W_conv2")
b_conv2 = bias_variable([64], name="b_conv2")
W_fc1 = weight_variable([7 * 7 * 64, 1024], name="W_fc1")
b_fc1 = bias_variable([1024], name="b_fc1")
W_fc2 = weight_variable([1024, 10], name="W_fc2")
b_fc2 = bias_variable([10], name="b_fc2")
sess = tf.InteractiveSession()
saver = tf.train.Saver()
saver.restore(sess, 'param/neural.param')
# My data
whatisit("My_data/0.bmp", sess)
whatisit("My_data/1.bmp", sess)
whatisit("My_data/2.bmp", sess)
whatisit("My_data/3.bmp", sess)
whatisit("My_data/4.bmp", sess)
whatisit("My_data/5.bmp", sess)
whatisit("My_data/6.bmp", sess)
whatisit("My_data/7.bmp", sess)
whatisit("My_data/8.bmp", sess)
whatisit("My_data/9.bmp", sess)
Anfangs konnte ich es überhaupt nicht verstehen, aber ich vertiefte mein Verständnis, indem ich in verschiedenen Büchern und im Web studierte und Code implementierte. Als nächstes möchte ich über das Netzwerk nachdenken und es selbst implementieren.
--2018 / 06/12: Hinzugefügt zur Vorhersage handschriftlicher Daten --2017 / 03/28: Neuer Beitrag
Recommended Posts