[PYTHON] [Windows Edition] Keras-Kurs, eine Bibliothek, in der Sie Deep Learning sofort ausprobieren können - Teil 2

Einführung

Letztes Mal haben wir die Deep Learning-Bibliothek Keras in Windows eingeführt und eine binäre Klassifizierung durchgeführt, ob das Quadrat Hoch- oder Querformat ist. Wenn Sie es noch nicht gelesen haben, ist es möglicherweise einfacher, es von dort aus zu verstehen. Übrigens denke ich diesmal, dass die binäre Klassifizierung erst mit Deep Learning interessant ist. Als nächsten Schritt werde ich eine Klassifizierung von Zahlen in mehreren Klassen unter Verwendung eines Datensatzes handgeschriebener Zeichen der Zahlen 0 bis 9 namens MNIST durchführen. .. Auch in diesem Artikel wird das Netzwerk weiterhin Multilayer Perceptron (MLP) verwenden. Ich habe nicht über mehrschichtige Perzeptrone gesprochen, also lassen Sie uns zuerst kurz sprechen. Der Anfangswert und die Parametererklärung der Optimierung werden in ca. 5 separat behandelt.

Ausführungsumgebung

Was ist Multilayer Perceptron?

Perzeptron

Was genau ist Perceptron? Nach dem ersten Buch in den Referenzen

Perceptron ist ein Algorithmus, der 1957 von einem amerikanischen Forscher namens Rosen Blood entwickelt wurde und der Ursprung des neuronalen Netznetzes (Deep Learning) ist.

Es scheint, dass (der Ausdruck hat sich ein wenig geändert). Ich glaube nicht, dass ich genau sagen kann, was das ist, also werde ich erklären, was das Perceptron selbst ist. Um es mit Worten zu erklären, es ist "ein Gerät, das mehrere Signale als Ein- und Ausgänge eines Signals empfängt", und das Ausgangssignal nimmt zwei Werte an, 0 oder 1. perceptron3.png Das Neuron berechnet die Summe der gesendeten Signale und gibt 1 nur dann aus, wenn die Summe einen bestimmten Grenzwert überschreitet. Es wird gesagt, dass dies manchmal als "** Neuronen Feuer **" ausgedrückt wird. Der Grenzwert wird als Schwellenwert bezeichnet, und wenn er durch $ \ theta $ ausgedrückt wird, kann die Ausgabe $ y $ durch die folgende Formel ausgedrückt werden.

\begin{eqnarray}
y=\left\{ \begin{array}{ll}
0 & (\omega_1 x_1 + \omega_2 x_2 \leq \theta) \\
1 & (\omega_1 x_1 + \omega_2 x_2 > \theta) \\
\end{array} \right.
\end{eqnarray}

Mit anderen Worten, Perceptrons ** Gewicht $ \ omega $ repräsentiert die Wichtigkeit des Signals **, und ** Bias $ b $ ist ein ** Parameter, der die Leichtigkeit des Zündens anpasst. Die Vorspannung $ b $ ist $ b = - \ theta $. In einigen Kontexten wird diese Verzerrung auch als Gewicht bezeichnet. Wie Sie aus der obigen Gleichung sehen können, kann jedoch nur ein Perzeptron durch eine gerade Linie identifiziert werden. Daher ist es nicht möglich, nichtlineare Ereignisse zu behandeln.

Mehrschichtiges Perceptron

Einfache Perzeptrone können nur bei linearen Problemen verwendet werden. Da Perceptron jedoch geschichtet werden kann, kann es auch nichtlineare Probleme behandeln. Dies wird als mehrschichtiges Perzeptron bezeichnet. Hier sind einige Dinge zu beachten. Was üblicherweise als mehrschichtiges Perzeptron bezeichnet wird, unterscheidet sich von dem zuvor beschriebenen einfachen Perzeptron. Der Ausgabewert des mehrschichtigen Perzeptrons ist 0 oder 1 für das Perzeptron, während der Ausgabewert eine reelle Zahl von 0 bis 1 ist, wenn die Aktivierungsfunktion sigmoid ist. Nun, plötzlich kam ich auf die Wortaktivierungsfunktion. Die Aktivierungsfunktion besteht darin, dass das einfache Perzeptron durch den Schwellenwert bestimmt, ob die Ausgabe 0 oder 1 ist, während es im mehrschichtigen Perzeptron ausgegeben wird, indem die nichtlineare Aktivierungsfunktion $ h $ mit der Summe der Eingaben als Variable übergeben wird. Bestimmen Sie die tatsächliche Anzahl von.

\begin{eqnarray}
  a =& \omega_1 x_1 + \omega_2 x_2 + b\\
  y =& h(a)
\end{eqnarray}

Beispielsweise ist die Sigmoidfunktion die folgende Funktion, die abhängig vom Wert der Eingabevariablen einen realen Wert zwischen 0 und 1 ausgibt. sigmoid

\begin{equation}
h(x) = \frac{1}{1+\exp(-x)}
\end{equation}

sigmoid2.png

Schließlich kann das mehrschichtige Perceptron wie folgt zusammengefasst werden.

Identifizierung handschriftlicher Zeichen

Könnten Sie das mehrschichtige Perceptron irgendwie verstehen? An diesem Punkt identifizieren wir schließlich handgeschriebene Zeichen unter Verwendung eines mehrschichtigen Perzeptrons.

Lernen

MNIST kann Trainings- und Testdaten als Datensatz in Keras lesen. Sie müssen den Datensatz also nicht wie beim letzten Mal herunterladen. Sie können das Training und seine Ergebnisse mit einem Skript wie dem folgenden anzeigen: Ich habe das letzte Mal die Sigmoid-Funktion für die Aktivierungsfunktion des mehrschichtigen Perzeptrons verwendet, aber dieses Mal verwende ich die ReLU-Funktion. Der Grund für die Verwendung der ReLU-Funktion ist, dass sie genauer ist, aber ich werde den Grund in einem anderen Artikel ausführlich erläutern. Stellen Sie außerdem sicher, dass die Aktivierungsfunktion der letzten Ebene auf Softmax eingestellt ist, wenn Sie klassifizieren möchten. Andernfalls wird es nicht klassifiziert. Das Jupyter-Notizbuch wurde auf Gist hochgeladen.

mnist_detect_class10.py


import numpy as np
import matplotlib.pyplot as plt

from keras.utils import np_utils
from scipy.misc import toimage

#Erforderlich zum Lesen des MNIST-Datensatzes
from keras.datasets import mnist

from keras.models import Sequential
from keras.layers import Dense, Dropout, Activation

#Festlegen der Anzahl der zu klassifizierenden Klassen
class_num = 10

#Laden Sie den Mnist-Datensatz
(X_train, y_train),(X_test, y_test) = mnist.load_data()

#Trainingsdaten normalisieren
X_train = X_train/255
X_test = X_test/255

#Daten für die Eingabe formatieren
#Konvertieren Sie ein zweidimensionales Array mit 28 x 28 Pixel pro Bild in einen 784-dimensionalen Vektor
X_train = X_train.reshape(-1,784)
X_test = X_test.reshape(-1,784)

#Ändern Sie die Bezeichnung in ein Array, das der Anzahl der Klassen entspricht
#Beispiel: y_train:[0 1 7 5] -> Y_train:[[1 0 0 0 0 0 0 0 0 0],[0 1 0 0 0 0 0 0 0 0],[0 0 0 0 0 0 0 1 0 0],[0 0 0 0 0 1 0 0 0 0]]
Y_train = np_utils.to_categorical(y_train,class_num)
Y_test = np_utils.to_categorical(y_test,class_num)

#Mehrschichtige Perceptron-Netzwerkerstellung
#Geben Sie 784 Dimensionen ein(28x28)Stellen Sie die endgültige Ausgabe auf die Anzahl der Klassen ein
model = Sequential()
model.add(Dense(512, input_dim=784, init='uniform'))
#Verwenden Sie die ReLU-Funktion für die Aktivierungsfunktion
model.add(Activation('relu'))
model.add(Dropout(0.5))
model.add(Dense(512, init='uniform'))
#Verwenden Sie die ReLU-Funktion für die Aktivierungsfunktion
model.add(Activation('relu'))
model.add(Dropout(0.5))
model.add(Dense(class_num, input_dim=512, init='uniform'))
#Verwenden Sie bei der Klassifizierung immer Softmax für die letzte Ebene
model.add(Activation('softmax'))

#Wählen Sie kategorial, da es sich um eine mehrwertige Klassifizierung handelt. Wählen Sie RMSprop als Optimierungsalgorithmus aus
model.compile(loss='categorical_crossentropy',
              optimizer='rmsprop',
              metrics=['accuracy'])

#Trainieren Sie das Modell mit einer festen Anzahl von Versuchen (Datensatziterationen).
model.fit(X_train, Y_train,
          nb_epoch=5,
          batch_size=100)
#Bewerten Sie die Parameter nach dem Lernen
score = model.evaluate(X_test, Y_test, batch_size=100)
print(score)
#Schätzen Sie die Bezeichnung der Testdaten, der Rückgabewert ist die Bezeichnung
classified_label = model.predict_classes(X_test[0:10,:])

#Anzeige des geschätzten Etiketts und Bildes
for i in range(10):
    #Konvertieren Sie Vektordaten in ein Array und konvertieren Sie sie in Bilddaten
    img = toimage(X_test[i,:].reshape(28,28))
    plt.subplot(2,5,i+1)
    plt.imshow(img, cmap='gray')
    plt.title("Class {0}".format(classified_label[i]))
    plt.axis('off')
plt.show()

#Modell und Gewicht sparen
model_json = model.to_json()
open('mnist_architecture.json', 'w').write(model_json)
model.save_weights('mnist_weights.h5', overwrite=True)

Ergebnis

Die 10 geschätzten Beschriftungen und Bilder vom Beginn der Testdaten sind wie folgt. Sie können sehen, dass die Klasse und der Charakter übereinstimmen. Das Testergebnis dieses Bildes war übrigens ein ausreichend praktisches Niveau mit einer korrekten Antwortrate von 97,7%. Wenn man das Testbild betrachtet, scheint es, dass 5 mit 8 verwechselt wird, aber es kann korrekt klassifiziert werden. Bei Sigmaid lag die korrekte Antwortrate übrigens nur bei etwa 80%, daher ist es wichtig, geeignete Parameter festzulegen. mnist_result.png

Experimentieren Sie mit Zahlen, die Sie geschrieben haben

Zu diesem Zeitpunkt scheint das Lernen ziemlich genau zu sein. Ich möchte jedoch immer noch mit den Zeichen testen, die ich geschrieben habe. Aus diesem Grund habe ich ein Bild mit Zahlen von 0 bis 9 erstellt, das mit Farbe auf eine Leinwand mit 56 x 56 Pixel geschrieben wurde. Ich habe versucht, die Klasse vorherzusagen, indem ich die trainierten Gewichte mit dem folgenden Code gelesen habe. Das Jupyter-Notizbuch wurde auf [Gist] hochgeladen (http://gist.github.com/keit0222/0ea504d1484cb216eef4f7264793ad97).

my_mnist.py


import numpy as np
import matplotlib.pyplot as plt

from keras.utils import np_utils

from keras.models import Sequential,model_from_json
from keras.preprocessing import image
from keras.applications.imagenet_utils import preprocess_input, decode_predictions

#Anzahl der für den Test vorbereiteten Bilder
test_num = 10

#Modell laden
model = model_from_json(open('mnist_architecture.json').read())
#Modellgewichte laden
model.load_weights('mnist_weights.h5')

for i in range(test_num):
    #Geben Sie den Dateinamen an
    img_path = str(i)+".jpg "
    #28 Pixel x 28 Pixel, Bild in Graustufen laden
    img = image.load_img(img_path, grayscale=True, target_size=(28, 28))
    #Konvertieren Sie das geladene Bild in ein Array
    x = image.img_to_array(img)
    #Überprüfen der Arraygröße
    print(x.shape)
    
    #Formen Sie ein zweidimensionales 28x28-Array in einen Vektor der Größe 784 zur Eingabe in das Modell
    x = x[:,:,0].reshape(-1,784)

    #Klassenvorhersage
    classified_label = model.predict_classes(x)
    
    #Vorhersageergebnisplot
    plt.subplot(2,5,i+1)
    plt.imshow(img, cmap='gray')
    plt.title("Class {0}".format(classified_label[0]))
    plt.axis('off')
plt.show()

Vorhersageergebnis meiner handgeschriebenen Zeichen

Ich dachte, dass alle Vorhersageergebnisse korrekt waren, aber die Zahl, die ich schrieb, zeigte, dass die richtige Antwortrate 70% betrug. Dies liegt wahrscheinlich daran, dass es sich von der Handschrift des Datensatzes unterscheidet. Es ist nicht sehr ordentlich, deshalb werde ich das, was ich in CNN gelernt habe, später hier in einem Postskriptum veröffentlichen. mnist_result2.png

Ausführungsumgebung und Quellcode während des CNN-Lernens

Ausführungsumgebung

Ein normaler PC mit nur einer CPU benötigt zu viel Zeit, um CNN zu trainieren. Deshalb habe ich ihn in der Cloud mit einer GPU-Umgebung trainiert. Die Ausführungsumgebung war zu dieser Zeit so. Das Erlernen von MNIST in dieser Umgebung dauerte weniger als eine Minute.

Quellcode zum Zeitpunkt des Lernens

my_mnist_cnn_learning.py


import numpy as np

from keras.utils import np_utils

from keras.datasets import mnist

from keras.models import Sequential
from keras.layers import Dense, Dropout, Activation, Flatten
from keras.layers import Convolution2D, MaxPooling2D
from keras import backend as K

#Anzahl der Chargen
batch_size = 128
#Anzahl der zu klassifizierenden Klassen
nb_classes = 10
#Anzahl der Epochen
nb_epoch = 12

#Anzahl der Dimensionen des einzugebenden Bildes
img_rows, img_cols = 28, 28
#Anzahl der zur Faltung verwendeten Filter
nb_filters = 32
#Geben Sie die Größe der Poolebene an
pool_size = (2, 2)
#Gibt die Größe des Faltungskerns an
kernel_size = (3, 3)

#Lesen Sie die wichtigsten Daten
(X_train, y_train), (X_test, y_test) = mnist.load_data()

if K.image_dim_ordering() == 'th':
        X_train = X_train.reshape(X_train.shape[0], 1, img_rows, img_cols)
        X_test = X_test.reshape(X_test.shape[0], 1, img_rows, img_cols)
        input_shape = (1, img_rows, img_cols)
else:
        X_train = X_train.reshape(X_train.shape[0], img_rows, img_cols, 1)
        X_test = X_test.reshape(X_test.shape[0], img_rows, img_cols, 1)
        input_shape = (img_rows, img_cols, 1)

X_train = X_train.astype('float32')
X_test = X_test.astype('float32')

#Normalisierung
X_train /= 255
X_test /= 255

#In Binärmatrix konvertieren
Y_train = np_utils.to_categorical(y_train, nb_classes)
Y_test = np_utils.to_categorical(y_test, nb_classes)

#CNN-Modellierung
model = Sequential()

model.add(Convolution2D(nb_filters, kernel_size[0], kernel_size[1],
                                                border_mode='valid',
                                                input_shape=input_shape))
model.add(Activation('relu'))
model.add(Convolution2D(nb_filters, kernel_size[0], kernel_size[1]))
model.add(Activation('relu'))
model.add(MaxPooling2D(pool_size=pool_size))
model.add(Dropout(0.25))

model.add(Flatten())
model.add(Dense(128))
model.add(Activation('relu'))
model.add(Dropout(0.5))
model.add(Dense(nb_classes))
model.add(Activation('softmax'))

#Modell kompilieren
model.compile(loss='categorical_crossentropy',
                            optimizer='adadelta',
                            metrics=['accuracy'])

#Lernen
model.fit(X_train, Y_train, batch_size=batch_size, nb_epoch=nb_epoch,
                    verbose=1, validation_data=(X_test, Y_test))
#Modellbewertung
score = model.evaluate(X_test, Y_test, verbose=0)
print(score)

#Modell und Gewicht sparen
model_json = model.to_json()
open('mnist_cnn_architecture.json', 'w').write(model_json)
model.save_weights('mnist_cnn_weights.h5', overwrite=True)

Lernergebnisse in CNN

Ich habe es früher in der Cloud ausgeführt, aber das folgende Skript befindet sich in der ersten Windows-Umgebung Laufen

my_mnist_cnn.py


# coding: utf-8
import numpy as np
import matplotlib.pyplot as plt

from keras.utils import np_utils

from keras.models import Sequential,model_from_json
from keras.preprocessing import image
from keras.applications.imagenet_utils import preprocess_input, decode_predictions

from keras.datasets import mnist

#Anzahl der klassifizierten Klassen
nb_classes = 10
#Anzahl der für den Test vorbereiteten Bilder
test_num = 10
#Lesen Sie die wichtigsten Daten
(X_train, y_train), (X_test, y_test) = mnist.load_data()

X_test = X_test.astype('float32')
#Daten normalisieren
X_test /= 255

#In ein binäres Array konvertieren
Y_test = np_utils.to_categorical(y_test, nb_classes)

#Modell laden
model = model_from_json(open('mnist_cnn_architecture.json').read())
#Modellgewichte laden
model.load_weights('mnist_cnn_weights.h5')
#Nach dem Laden der Architektur und der Gewichte müssen Sie kompilieren, wenn Sie das Modell bewerten möchten
model.compile(loss='categorical_crossentropy',
              optimizer='adadelta',
              metrics=['accuracy'])
#Modellbewertung
score = model.evaluate(X_test.reshape(-1,28,28,1), Y_test, verbose=0)
print(score)

for i in range(test_num):
    #Geben Sie den Dateinamen an
    img_path = str(i)+".jpg "
    #28 Pixel x 28 Pixel, Bild in Graustufen laden
    img = image.load_img(img_path, grayscale=True, target_size=(28, 28))
    #Konvertieren Sie das geladene Bild in ein Array
    x = image.img_to_array(img)
    #Überprüfen der Arraygröße
    print(x.shape)

    #Klassenvorhersage
    classified_label = model.predict_classes(x.reshape(-1,28,28,1))

    #Vorhersageergebnisplot
    plt.subplot(2,5,i+1)
    plt.imshow(img, cmap='gray')
    plt.title("Class {0}".format(classified_label[0]))
    plt.axis('off')
plt.show()

Was passiert nun mit dem Ergebnis eines Faltungsnetzwerks? Das Ausführungsergebnis in Jupyter Notebook wird auf Gist hochgeladen.

mnist_result_cnn.png

Die richtige Antwortrate beträgt 80%, aber im Vergleich zu den Ergebnissen, die ich in MLP gelernt habe, weisen 6 und 8,7 und 1 bei den von mir geschriebenen Zahlen ähnliche Eigenschaften auf, sodass es leicht sein kann, einen Fehler zu machen. Wenn ich zusätzlich zu den vorhandenen Trainingsdaten das hinzufüge, was ich geschrieben habe, ist die Antwort möglicherweise richtig, aber ich habe nicht vor, dies zu tun.

abschließend

Dieses Mal haben wir die handgeschriebenen Zeichen MNIST klassifiziert. Obwohl die Ergebnisse des Lernens und Testens gut waren, war die richtige Antwortrate für die von mir geschriebenen Bilder nicht gut. Nächstes Mal werde ich über das Convolutional Neural Network (CNN) sprechen.

Verweise

Recommended Posts

[Windows Edition] Keras-Kurs, eine Bibliothek, in der Sie Deep Learning sofort ausprobieren können - Teil 2
Erstellen Sie unter Windows 10 eine Umgebung, in der Sie MXNet ausprobieren können
Eine Szene, in der GPU für tiefes Lernen nützlich ist?
Versuchen Sie, ein Deep Learning / Neuronales Netzwerk mit Scratch aufzubauen
Sinuswellenvorhersage mit RNN in der Deep-Learning-Bibliothek Keras
Site-Zusammenfassung, auf der Sie kostenlos maschinelles Lernen lernen können
[Kostenlos zu verwenden] 7 Lernseiten, auf denen Sie Python lernen können
Ich habe keine GPU, aber ich werde Deep Learning ausprobieren
Versuchen Sie es mit TensorFlow
Versuchen Sie Deep Learning mit FPGA
Mit Deep Learning können Sie die Erholungsrate von 100% im Pferderennen überschreiten
Ich habe einen LINE-Stempel erstellt, in dem Sie Linux-Befehle studieren können
Wie auch immer, wir haben eine Seite zusammengestellt, auf der Sie grundlegendes kostenloses Python und maschinelles Lernen lernen können.