Ich habe "MNIST für ML-Anfänger" ausprobiert, das im TensorFlow-Tutorial für Anfänger des maschinellen Lernens geschrieben ist. Also habe ich die Nummernerkennung von MNIST implementiert, die als Hello World of Machine Learning geschrieben ist. MNIST ist ein Datensatz handgeschriebener Bilder. Hier werden Bilder handgeschriebener Zahlen von 0 bis 9 gelesen und durch Gelegenheitslernen klassifiziert. Der Beispielcode auf Github von TensorFlow scheint schwierig zu sein, aber als ich nur die erforderliche Implementierung ausprobierte, war er wirklich einfach und konnte in 20 Zeilen implementiert werden.
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
Es befindet sich auf Github, aber das Folgende ist der implementierte Code.
mnist_softmax_train.py
from tensorflow.examples.tutorials.mnist import input_data
import tensorflow as tf
# 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])
W = tf.Variable(tf.zeros([28*28, 10]), name="W")
b = tf.Variable(tf.zeros([10]), name="b")
sess.run(tf.initialize_all_variables())
# Making model
y = tf.matmul(x, W) + b
cross_entropy = tf.reduce_mean(tf.nn.softmax_cross_entropy_with_logits(y, y_))
# Training
train_step = tf.train.GradientDescentOptimizer(0.5).minimize(cross_entropy)
for i in range(1000):
batch = mnist.train.next_batch(100)
train_step.run(feed_dict={x: batch[0], y_: batch[1]})
# Evaluating
correct_prediction = tf.equal(tf.argmax(y, 1), tf.argmax(y_, 1))
accuracy = tf.reduce_mean(tf.cast(correct_prediction, tf.float32))
print(accuracy.eval(feed_dict={x: mnist.test.images, y_: mnist.test.labels}))
# Save train data
saver = tf.train.Saver()
saver.save(sess, 'param/softmax.param')
Wenn ich es ausführe, scheint die Genauigkeit etwa 92% zu betragen, wie im Tutorial beschrieben.
mnist = input_data.read_data_sets('MNIST_data', one_hot=True)
Ich bekomme Daten. Ich habe ein Verzeichnis namens MNIST_data erstellt und dort 4 Dateien heruntergeladen. Der Inhalt ist eine Blackbox, daher müssen Sie ihn überprüfen.
sess = tf.InteractiveSession()
x = tf.placeholder(tf.float32, shape=[None, 28*28])
y_ = tf.placeholder(tf.float32, shape=[None, 10])
W = tf.Variable(tf.zeros([28*28, 10]), name="W")
b = tf.Variable(tf.zeros([10]), name="b")
sess.run(tf.initialize_all_variables())
Dies ist der Initialisierungsprozess. x enthält die Bilddaten (28 Pixel x 28 Pixel) und y_ enthält die Beschriftung (0-9) des Bildes. Da es sich um einen Platzhalter handelt, werde ich ihn später zuweisen. W und b sind Parameter, wobei W das Gewicht jedes Pixels im Bild und b der Abschnitt ist.
y = tf.matmul(x, W) + b
cross_entropy = tf.reduce_mean(tf.nn.softmax_cross_entropy_with_logits(y, y_))
y ist ein Ausdruck, der den vorhergesagten Wert aus den Parametern und x berechnet. Die folgende Formel ist die Softmax-Regression. Die logistische Regression ist ein Modell, das 0 und 1 vorhersagt. Es wird jedoch erweitert, um mehrere Bezeichnungen vorhersagen zu können (in diesem Fall 0 bis 9). Das Tutorial enthielt auch detaillierte Formeln, daher denke ich, dass Sie das auch studieren müssen.
train_step = tf.train.GradientDescentOptimizer(0.5).minimize(cross_entropy)
for i in range(1000):
batch = mnist.train.next_batch(100)
train_step.run(feed_dict={x: batch[0], y_: batch[1]})
GradientDescentOptimizer ist eine probabilistische Gradientenabstiegsmethode. Die ersten mit mnist.train.next_batch heruntergeladenen Daten werden der Reihe nach erfasst und der Variablen mit feed_dict = {x: batch [0], y_: batch [1]} zugewiesen. Wir suchen nach der optimalen Lösung, indem wir sie wiederholt ausführen.
correct_prediction = tf.equal(tf.argmax(y, 1), tf.argmax(y_, 1))
accuracy = tf.reduce_mean(tf.cast(correct_prediction, tf.float32))
print(accuracy.eval(feed_dict={x: mnist.test.images, y_: mnist.test.labels}))
Wir überprüfen die Genauigkeit von y (vorhergesagter Wert) und y_ (tatsächlicher Wert) anhand von Testdaten.
saver = tf.train.Saver()
saver.save(sess, 'param/softmax.param')
Dies ist der Vorgang zum Speichern der gelernten Parameter. Sie können die Bilder später nur anhand der Parameter klassifizieren.
Sie haben die handschriftlichen numerischen Daten oben gelernt. Mit diesem Parameter habe ich versucht, die handgeschriebenen Daten zu klassifizieren, die ich geschrieben habe. Meine handschriftlichen Daten sind auch auf Github, aber es ist ein Schwarz-Weiß-BMP. Ich lade es mit parsebmp.py. Die MNIST-Daten werden mit numerischen Werten von 0 bis 1 trainiert, aber dieser Vorgang ist mit nur 0- und 1-Daten einfach. Als ich es tatsächlich bewegte, war es zu 60% genau. Es ist weit von 92% entfernt, aber es kann gesagt werden, dass es bis zu einem gewissen Grad beurteilt werden kann. ⇒ Vorverarbeitung war erforderlich, um handschriftliche Daten vorherzusagen. Weitere Informationen finden Sie im Artikel Vorhersagen Ihrer handschriftlichen Daten mit TensorFlow.
mnist_softmax.py
from tensorflow.examples.tutorials.mnist import input_data
import tensorflow as tf
import sys
import numpy as np
import parsebmp as pb
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])
result = sess.run(y, feed_dict={x: d})
# Show result
print(result)
print(np.argmax(result, 1))
if __name__ == "__main__":
# Restore parameters
x = tf.placeholder(tf.float32, shape=[None, 28*28])
y_ = tf.placeholder(tf.float32, shape=[None, 10])
W = tf.Variable(tf.zeros([28*28, 10]), name="W")
b = tf.Variable(tf.zeros([10]), name="b")
y = tf.matmul(x, W) + b
sess = tf.InteractiveSession()
saver = tf.train.Saver()
saver.restore(sess, 'param/softmax.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)
Zuerst habe ich den Code implementiert, während ich mir das Tutorial angesehen habe. Es ist wirklich einfach zu implementieren, aber ich denke, Sie müssen die folgenden Punkte verstehen.
--Inhalt der Nutzungsdaten
Um es wirklich zu verstehen, möchte ich auch meine eigenen handschriftlichen Daten aufnehmen und Vorhersagen treffen können. Ich denke, das wird zu einer praktischen Anwendung führen. ⇒ Ich habe versucht, meine handschriftlichen Daten am 27.03.2017 vorherzusagen.
--2018 / 06/12: Hinzugefügt zur Vorhersage handschriftlicher Daten --2017 / 03/27: Es wurde hinzugefügt, wie Parameter und vorhergesagte Inhalte Ihrer eigenen handschriftlichen Daten gespeichert werden
Recommended Posts