[PYTHON] Ergänzende Hinweise zu TensorFlow MNIST für ML-Anfänger

TensorFlow MNIST für ML-Anfänger ist ein Tutorial zur Bilderkennung handgeschriebener Zahlen mit TensorFlow, TensorFlow Tutorial-MNIST für ML-Anfänger --Qiita](http://qiita.com/KojiOhki/items/ff6ae04d6cf02f1b6edf) verfügt über eine japanische Übersetzung.

Was die Denkweise betrifft, denke ich, dass die Erklärung von [MNIST (MNIST = Multi-Class Identification Problem) der handschriftlichen Zeichenerkennung (MNIST) von TensorFlow Kotohajime) (http://yaju3d.hatenablog.jp/entry/2016/04/22/073249) leicht zu verstehen ist.

MNIST-Bilddaten

MNIST-Bilddaten sind ein handgeschriebenes 28-Pixel x 28-Pixel-Bild mit der Nummer 0-9 und ein entsprechender Etikettendatensatz. Im Fall des folgenden Bildes sind beispielsweise die Bilddatei und die Beschriftungsinformationen "7" ein Satz.

Zeigen Sie die vom Programm gelesenen Bilddaten an

Wenn Sie den folgenden Code ausführen, wird vorerst das erste Bild des Trainingsbildes von MNIST wie im obigen Beispiel ausgegeben. Es gibt viele lange Einführungen, aber die letzten 5 Zeilen sind der Code für die Anzeige von Bildern. Selbst wenn Sie die direkt mit input_data heruntergeladene Archivdatei erweitern, können Sie das Bild einfach überprüfen. .. ..

mnist_picture_sample.py

"""This is a test program."""
# -*- coding: utf-8 -*-

import time
import numpy as np
import tensorflow as tf
from tensorflow.examples.tutorials.mnist import input_data
import matplotlib.cm as cm
from matplotlib import pylab as plt

#Startzeit
START_TIME = time.time()
print("Startzeit: " + str(START_TIME))

#MNIST-Daten lesen
#55.000 Trainingsbilder(Es scheint eine Theorie zu geben, dass es 60.000 Fälle gibt)
#10000 Verifizierungsbilder
#Die Trainingsdaten und Testdaten werden mit Bildern von 0 bis 9 und entsprechenden Beschriftungen (0 bis 9) eingestellt.
#Die Bildgröße beträgt 28 x 28 Pixel(=784)
# mnist.train.Bilder[55000, 784]Anordnung von
# mnist.train.Etiketten lesen_data_eine der Sets-Methoden_heißes T./Wie folgt von F.
#   one_hot =Wenn wahr: [55000, 10]Wenn das Bild der entsprechenden Bilder im Array von "3" ist[0,0,0,1,0,0,0,0,0,0]
#                         np.argmax([0,0,0,1,0,0,0,0,0,0])⇒ Kann in 3 umgewandelt werden
#   one_hot =Wenn falsch: [55000, 1]Wenn das Bild der entsprechenden Bilder "3" in der Anordnung von 3 ist
# mnist.test.Bilder[10000, 784]Array von, mnist.test.Etiketten[10000, 10]Der Inhalt ist mnist.Ähnlich wie beim Zug

print("---Beginnen Sie mit dem Lesen der MNIST-Daten---")
is_one_hot = True
mnist = input_data.read_data_sets("MNIST_data/", one_hot=is_one_hot)
print("---Abschluss des Lesens der MNIST-Daten---")

###Überprüfen Sie, welche Nummer das erste Bild ist###
# one_hot=Wenn wahr
if is_one_hot == True:
    label = np.argmax(mnist.train.labels[0])
else:
    label = mnist.train.labels[0]

###Überprüfen Sie die Anzahl der Trainingsbilder###
print('mnist.train.images = ' + str(len(mnist.train.images)))
###Überprüfen Sie die Anzahl der Überprüfungsbilder###
print('mnist.test.images = ' + str(len(mnist.test.images)))

#Anzeige von in einem Array gespeicherten Bilddaten
#Selbst wenn Sie die 28x28-Bildinformationen (Anordnung) numerisch betrachten, ist dies nicht klar. Hinterlassen Sie sie daher als Kommentar
#print(mnist.train.images[0].reshape(28, 28))

#Endzeit
END_TIME = time.time()
print("Endzeit: " + str(END_TIME))
print("Benötigte Zeit: " + str(END_TIME - START_TIME))

#Zeigen Sie das erste Bild des Lernbilds als Graustufenbild an
plt.imshow(mnist.train.images[0].reshape(28, 28), cmap = cm.Greys_r)
plt.title(str(label))
plt.axis('off')
plt.show()
plt.close()

Wenn Sie den Vorgang wie folgt von "# Das erste Bild des Trainingsbildes als Graustufenbild anzeigen" ändern, werden 10 Bilder vom Anfang des Trainingsbildes ausgegeben.

#Zeigen Sie die ersten 10 Bilder des Lernbilds als Graustufenbilder an
#Reservieren Sie einen Bildausgabebereich von 2 Zeilen x 5 Spalten
fig, axarr = plt.subplots(2, 5)

#Stellen Sie in jedem Ausgabebereich ein Bild ein
for idx in range(10):
    ax = axarr[int(idx / 5)][idx % 5]
    ax.imshow(mnist.train.images[idx].reshape(28, 28), cmap = cm.Greys_r)

    label = ''
    if IS_ONE_HOT == True:
        label = np.argmax(mnist.train.labels[idx])
    else:
        label = mnist.train.labels[idx]
    ax.set_title(str(label))
    ax.axes.get_xaxis().set_visible(False)
    ax.axes.get_yaxis().set_visible(False)
#Ein Bild ausgeben
plt.show()
plt.close()

Das Ausführungsergebnis sieht so aus.

Irgendwie sieht das Bild von "7" am Anfang nur wie "wo" aus. .. .. Vielmehr scheint "4" eher wie "7" auszusehen. .. ..

Arbeitscode für TensorFlow MNIST Für ML-Anfänger

Versuchen Sie das TensorFlow-Tutorial (1) | mwSoft Ich werde versuchen, den veröffentlichten Code zu vervollständigen und auszuführen. Ich werde.

mnist_beginner.py

import tensorflow as tf
from tensorflow.examples.tutorials.mnist import input_data

#Daten gelesen
mnist = input_data.read_data_sets('MNIST_data', one_hot=True)

#Platzhalter bereit
x = tf.placeholder(tf.float32, [None, 784])
y_ = tf.placeholder(tf.float32, [None, 10])

#Gewicht und Voreingenommenheit
W = tf.Variable(tf.zeros([784, 10]))
b = tf.Variable(tf.zeros([10]))

#Verwenden Sie die Softmax-Regression
y = tf.nn.softmax(tf.matmul(x, W) + b)

#Gekreuzte Entropie
cross_entropy = -tf.reduce_sum(y_ * tf.log(y))

#Der Gradient Descent Optimizer, den ich früher verwendet habe, diesmal gekreuzt_Verwenden Sie Entropie
train_step = tf.train.GradientDescentOptimizer(0.01).minimize(cross_entropy)

#Initialisieren
# initialize_all_Variablen Methode ist 2017/3/Es scheint, dass es nach 2 gelöscht wird
# global_variables_Wechseln Sie zum Initialisierer.
# (2017/6 Derzeit nicht gelöscht)
#init = tf.initialize_all_variables()
init = tf.global_variables_initializer()
sess = tf.Session()
sess.run(init)

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

#Vorausgesagt durch Testdaten
correct_prediction = tf.equal(tf.argmax(y,1), tf.argmax(y_,1))
accuracy = tf.reduce_mean(tf.cast(correct_prediction, tf.float32))
#Geändert, um Ergebnisse anzuzeigen
print(sess.run(accuracy, feed_dict={x: mnist.test.images, y_: mnist.test.labels}))

Wenn Sie es wiederholt ausführen, ändert sich das Ergebnis ein wenig, aber Sie können bestätigen, dass es (wahrscheinlich) mit einer Wahrscheinlichkeit von etwa 90% erkannt wird.

Anschließend wird die Erläuterung der Fortsetzung des Hauptcodes von TensorFlow-Lernprogramm (1) | mwSoft wie folgt erläutert. Wenn Sie es unter "Ändern" hinzufügen, können Sie auch den Bias-Wert und das Gewicht sehen.

・ ・ ・
#Geändert, um Ergebnisse anzuzeigen
print(sess.run(accuracy, feed_dict={x: mnist.test.images, y_: mnist.test.labels}))

#Anzeige des Bias-Wertes
print(sess.run(b))

#Import der für das Zeichnen von Bildern erforderlichen Bibliothek
import matplotlib.cm as cm
from matplotlib import pylab as plt

#Inhalt der Gewichte
weights = sess.run(W)
f, axarr = plt.subplots(2, 5)
for idx in range(10):
    ax = axarr[int(idx / 5)][idx % 5]
    ax.imshow(weights[:, idx].reshape(28, 28), cmap = cm.Greys_r)
    ax.set_title(str(idx))
    ax.axes.get_xaxis().set_visible(False)
    ax.axes.get_yaxis().set_visible(False)
plt.show()
plt.close()

#Anzeige der korrekten Antwortrate für jeden numerischen Wert
corrects = sess.run(correct_prediction, feed_dict={x: mnist.test.images, y_: mnist.test.labels})
for i in range(10):
    positive = sum(mnist.test.labels[corrects][:, i] == 1)
    all = sum(mnist.test.labels[:, i] == 1)
    print(i, positive / all)

#Anzeige des richtigen Bildes
f, axarr = plt.subplots(5, 8)
for idx, img in enumerate(mnist.test.images[corrects][0:40]):
        ax= axarr[int(idx / 8)][idx % 8]
        ax.imshow(img.reshape(28, 28), cmap = cm.Greys_r)
        ax.axes.get_xaxis().set_visible(False)
        ax.axes.get_yaxis().set_visible(False)
plt.show()
plt.close()

#Anzeige eines falschen Bildes
f, axarr = plt.subplots(5, 8)
for idx, img in enumerate(mnist.test.images[~ corrects][0:40]):
        ax = axarr[int(idx / 8)][idx % 8]
        ax.imshow(img.reshape(28, 28), cmap = cm.Greys_r)
        ax.axes.get_xaxis().set_visible(False)
        ax.axes.get_yaxis().set_visible(False)
plt.show()
plt.close()

Erkennen Sie das handgeschriebene Bild

Wenn ich den obigen Code ausführe, scheint es, dass Tensorflow verwendet werden kann, um handgeschriebene Zeichenbilder zu etwa 90% zu erkennen, aber ich kann es irgendwie verstehen.

Wie viele bin ich :? PC: "3".

Ich kann so etwas nicht machen. Fügen Sie anhand des gelernten Ergebnisses den Code hinzu, um das unter "# Ändern, damit das Ergebnis angezeigt werden kann" vorbereitete Bild zu erkennen.

・ ・ ・
#Geändert, um Ergebnisse anzuzeigen
print(sess.run(accuracy, feed_dict={x: mnist.test.images, y_: mnist.test.labels}))

#Bild wird geladen
import cv2
import numpy as np

img = input("Bitte geben Sie den Pfad der Bilddatei ein>")
img = cv2.imread(img, cv2.IMREAD_GRAYSCALE)
img = cv2.resize(img, (28, 28))
ximage = img.flatten().astype(np.float32)/255.0     #Format ändern
ximage = np.expand_dims(ximage, axis=0)             #Vertauschen Sie Zeilen und Spalten(784, 1) ⇒ (1, 784)Umstellung auf

#Führen Sie eine Bilderkennung durch
predict = sess.run(y, feed_dict={x: ximage})
print('Das Bilderkennungsergebnis ist "' + str(sess.run(tf.argmax(predict[0]))) + '"ist')

Wenn Sie das Skript nach dem Hinzufügen des Codes ausführen, sollte es das Bilderkennungsergebnis des vom Benutzer angegebenen Bildes zurückgeben.

Separate Lern- und Bilderkennungsskripte

Da es ineffizient ist, jedes Mal, wenn ein Bild erkannt wird, von Grund auf neu zu lernen, speichert das Lernskript das Lernergebnis in einer Datei, und das Bilderkennungsskript verwendet das Lernergebnis, um die Bilderkennung durchzuführen. Ich werde es so ändern, dass es wird.

Lernskript

Geben Sie die beiden Codes ein, die in "######## Von hier ########" bis "######## Bis hierher ########" enthalten sind. Nach dem Hinzufügen werden die Lernergebnisse in einer Datei gespeichert.

mnist_beginner_learn.py

import tensorflow as tf
from tensorflow.examples.tutorials.mnist import input_data

#Daten gelesen
mnist = input_data.read_data_sets('MNIST_data', one_hot=True)

#Platzhalter bereit
x = tf.placeholder(tf.float32, [None, 784])
y_ = tf.placeholder(tf.float32, [None, 10])

#Gewicht und Voreingenommenheit
W = tf.Variable(tf.zeros([784, 10]))
b = tf.Variable(tf.zeros([10]))

#Verwenden Sie die Softmax-Regression
y = tf.nn.softmax(tf.matmul(x, W) + b)

#Gekreuzte Entropie
cross_entropy = -tf.reduce_sum(y_ * tf.log(y))

#Der Gradient Descent Optimizer, den ich früher verwendet habe, diesmal gekreuzt_Verwenden Sie Entropie
train_step = tf.train.GradientDescentOptimizer(0.01).minimize(cross_entropy)

#Initialisieren
init = tf.global_variables_initializer()
sess = tf.Session()
sess.run(init)

########von hier########
# tf.train.Wenn Sie die Saver-Methode ohne Argumente ausführen,
#Alle tf.Variable wird gespeichert
saver = tf.train.Saver()
########Bisher########

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

#Vorausgesagt durch Testdaten
correct_prediction = tf.equal(tf.argmax(y,1), tf.argmax(y_,1))
accuracy = tf.reduce_mean(tf.cast(correct_prediction, tf.float32))
#Geändert, um Ergebnisse anzuzeigen
print(sess.run(accuracy, feed_dict={x: mnist.test.images, y_: mnist.test.labels}))

########von hier########
# tf.Variable speichern
#Erstellen Sie vorerst ein ckpt-Verzeichnis im aktuellen Verzeichnis.
#Die Datei wird darunter ausgegeben.
import os
if os.path.exists('ckpt') == False:
    os.mkdir('ckpt')
saver.save(sess, 'ckpt' + os.sep + 'model.ckpt')
########Bisher########

Bilderkennungsskript

Der Hauptcode ist der gleiche wie das Lernskript. Nach dem Initialisieren der Parameter wird der zu lernende Code in den Code umgeschrieben, der aus der Datei geladen werden soll.

mnist_predict.py

import tensorflow as tf
from tensorflow.examples.tutorials.mnist import input_data

#Daten gelesen
mnist = input_data.read_data_sets('MNIST_data', one_hot=True)

#Platzhalter bereit
x = tf.placeholder(tf.float32, [None, 784])
y_ = tf.placeholder(tf.float32, [None, 10])

#Gewicht und Voreingenommenheit
W = tf.Variable(tf.zeros([784, 10]))
b = tf.Variable(tf.zeros([10]))

#Verwenden Sie die Softmax-Regression
y = tf.nn.softmax(tf.matmul(x, W) + b)

#Gekreuzte Entropie
cross_entropy = -tf.reduce_sum(y_ * tf.log(y))

#Der Gradient Descent Optimizer, den ich früher verwendet habe, diesmal gekreuzt_Verwenden Sie Entropie
train_step = tf.train.GradientDescentOptimizer(0.01).minimize(cross_entropy)

#Initialisieren
init = tf.global_variables_initializer()
sess = tf.Session()
sess.run(init)

########Bis zu diesem Punkt ist es dasselbe wie das Lernskript########

#Lernergebnisse laden
saver = tf.train.Saver()
sess.run(tf.global_variables_initializer())
ckpt = tf.train.get_checkpoint_state('./ckpt')
saver.restore(sess, ckpt.model_checkpoint_path) #Variable Daten lesen

########Von hier an ist unten dasselbe wie "Erkennen Sie das handgeschriebene Bild".########
#Bild wird geladen
import cv2
import numpy as np

img = input("Bitte geben Sie den Pfad der Bilddatei ein>")
img = cv2.imread(img, cv2.IMREAD_GRAYSCALE)
img = cv2.resize(img, (28, 28))
ximage = img.flatten().astype(np.float32)/255.0     #Format ändern
ximage = np.expand_dims(ximage, axis=0)             #Vertauschen Sie Zeilen und Spalten(784, 1) ⇒ (1, 784)Umstellung auf

#Führen Sie eine Bilderkennung durch
predict = sess.run(y, feed_dict={x: ximage})
print('Das Bilderkennungsergebnis ist "' + str(sess.run(tf.argmax(predict[0]))) + '"ist')