Einführung

Dieser Beitrag richtet sich an Personen, die Deep Learning ausprobieren möchten, das in den letzten Jahren populär geworden ist, ohne die Theorie zu kennen, oder die es nur verwenden möchten. Ich habe es für mein eigenes Memo geschrieben. Bitte weisen Sie auf verwirrende Teile oder Fehler hin. Keras ist ein Python-Wrapper für Tensorflow und Theano, eine Deep-Learning-Bibliothek. Wenn Sie diese Bibliothek verwenden, können Sie sehr leicht tiefes Lernen erleben und viele Netzwerkstrukturen codieren, ohne sich schwieriger Theorien bewusst zu sein. In diesem Artikel werden wir Tensorflow und Keras vorstellen und zunächst Quadrate mit einem mehrschichtigen Perzeptron identifizieren.

(Ergänzung) Da es scheint, dass viele Leute es gesehen haben, haben wir auch die Identifikation durch Lesen der gelernten Parameter hinzugefügt. Ich hoffe, es wird für alle hilfreich sein.

(Hinzugefügt am 09.03.2017) TensorFlow 1.0 wurde am 15. Februar 2017 von Google veröffentlicht. Gleichzeitig wird in TensorFlow ein neues tf.keras-Modul eingeführt. (Derzeit scheint es, dass es in TensorFlow 1.2 hinzugefügt wird.) Daher können Sie die Keras-API direkt von TensorFlow aus verwenden, ohne TensorFlow im Backend wie zuvor mit Keras ausführen zu müssen. Ich frage mich, wo ich den nächsten Artikel schreiben soll, aber ich denke wahrscheinlich daran, diese Serie in reinem Keras zu schreiben. Wenn TensorFlow auch Keras unterstützt, wird es meiner Meinung nach unter Bezugnahme auf den Code von TensorFlow nach Gist hochgeladen.

Ausführungsumgebung

Windows 10（64bit）with only CPU
Python 3.5.2
Anaconda 4.2.0（64bit）
Tensorflow 0.12.1
Keras 1.2.1

Installationsverfahren für die Ausführungsumgebung

Installation von Anaconda

Ich verwende Anaconda als Laufumgebung für Python unter Windows. Wenn Sie bereits eine Umgebung haben, in der Sie sie verwenden, können Sie sie überspringen. Um Anaconda zu installieren, rufen Sie die offizielle Download-Seite (http://www.continuum.io/downloads#windows) auf und laden Sie das Installationsprogramm für Ihre Umgebung herunter. Führen Sie danach das Installationsprogramm aus und klicken Sie auf Weiter, um den Vorgang abzuschließen. Neben der Installation von Anaconda sind auch die zum Zeitpunkt des Downloads ausgewählten Editoren Python (in meinem Fall Python3) und Jupyter Notebook enthalten, sodass Python nicht separat installiert werden muss.

Installieren Sie Tensorflow

In Keras können Sie die Bibliothek auswählen, die im Backend mit Tensorflow oder Theano ausgeführt werden soll. Hier verwenden wir jedoch Tensorflow. Da pip für die Installation verwendet wird, suchen Sie zuerst auf dem Startbildschirm nach Anaconda und starten Sie es. Aktualisieren Sie pip unmittelbar nach der Installation für alle Fälle auf die neueste Version. Führen Sie den folgenden Befehl in der Anaconda-Eingabeaufforderung aus, um die neueste Version zu erhalten.

`pip_upgrade`


$ pip install --upgrade pip

Sobald Sie die neueste Version haben, installieren Sie Tensorflow. Führen Sie bei geöffneter Anaconda-Eingabeaufforderung den folgenden Befehl aus: Bitte beachten Sie, dass die Installationsbefehle für PCs mit GPU und PCs nur mit CPU unterschiedlich sind.

`tensorflow_install`


#Nur für CPU
$ pip install tensorflow
#Bei Ausstattung mit GPU
$ pip install tensorflow-gpu

#So überprüfen Sie, ob es installiert ist
#Führen Sie den folgenden Befehl aus. Wenn sich Tensorflow in der Liste befindet, ist dies in Ordnung.
$ pip list |grep tensorflow

(Ergänzung) (Stand: 8. März 2017) Tensorflow kann mit dem obigen Befehl nur installiert werden, wenn die Python-Version 3.5.x ist. Ich habe einen Artikel geschrieben, in dem zusammengefasst wird, wie dies vermieden werden kann. Wenn Sie ihn nicht installieren können, installieren Sie bitte Tensorflow, der darauf verweist. Das Folgende ist der Artikel. So installieren Sie das Deep Learning Framework Tensorflow 1.0 in der Anaconda-Umgebung von Windows

Keras-Installation

Führen Sie dann den folgenden Befehl aus, um die Installation von Keras abzuschließen.

`Keras_install`


#Keras-Installation
$ pip install keras

#Überprüfen Sie, ob es installiert ist
#Wenn Sie Keras bestätigen können, ist dies ebenfalls in Ordnung.
$ pip list |grep Keras

Überprüfen Sie, ob es installiert werden kann

Bevor wir uns dem Hauptthema zuwenden, überprüfen wir, ob die Installation korrekt ist. Ich denke, dass die Anaconda-Eingabeaufforderung geöffnet ist. Starten Sie dort Python und prüfen Sie, ob es ordnungsgemäß importiert werden kann. Es ist okay, wenn es so aussieht:

`introduction_confirmation`


#Starten Sie Python
$ python
#Tensorflow importieren
>>> import tensorflow 
#Keras-Import
>>> import keras
using TensorFlow backend

Mehrwertklassifizierung mit mehrschichtigem Perzeptron (MLP)

Klassifizierung der viereckigen Landschaft oder des Porträts

Datensatz herunterladen

Lassen Sie uns eine einfache Klassifizierung durchführen, indem Sie das folgende Bild eingeben. Zunächst werden Daten für das Deeplearning benötigt. Laden Sie die Daten daher von [Site] herunter (http://www.iro.umontreal.ca/~lisa/twiki/bin/view.cgi/Public/RectanglesData). .. Dieser Datensatz ist ein Datensatz des folgenden quadratischen Bildes. Als Ausgangspunkt verwenden wir Keras, um zwei Klassen zu klassifizieren: Hoch- und Querformat.

Programmierung

Informationen zur Verwendung von Jupyter finden Sie unter hier. Was nun die Vorgehensweise des Programms betrifft, so ist es ungefähr wie folgt.

Lesen Sie die Daten zum Lernen
Formatieren von Daten in eine lernbare Form (Vorverarbeitung)
Aufbau einer Netzwerkschicht
Lernen
Leistungsbewertung mit Testdaten
Zeigen Sie einen Teil des Ergebnisses auf dem Bildschirm an und überprüfen Sie es
Exportieren Sie Architektur und Gewichte

Sobald Sie es gelernt haben, können Sie die exportierte Architektur und die Gewichte ab dem zweiten Mal lesen und verwenden, sodass Sie keine 3 oder 4 benötigen. Bei der Implementierung sieht der Code folgendermaßen aus: Die Ausführungsergebnisse usw. werden auf Gist hochgeladen. Überprüfen Sie diese daher gegebenenfalls.

`rectangle_mlp.py`


import numpy as np
from scipy.misc import toimage
from keras.utils import np_utils
import matplotlib.pyplot as plt

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

#Quadratische Datenlesefunktion
def load_rectangles_data(filename):
    data = np.loadtxt(filename)
    #Extraktion von Bilddaten
    x = data[:,0:784]
    #Extraktion des korrekten Etiketts
    y = data[:,784]
    return [x,y]

#Parametereinstellungen
nb_classes = 2
epoch = 20
batch = 10

#Etikette:"Horizontal":Horizontal,"Vertical":Vertikal
label = ["Horizontal","Vertical"]

#Quadratische Trainingsdaten lesen
[X_train,y_train] = load_rectangles_data('rectangles_train.amat')

#Quadratische Testdaten lesen
[X_test,y_test] = load_rectangles_data('rectangles_test.amat')

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

#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'))
model.add(Activation('sigmoid'))
model.add(Dropout(0.5))
model.add(Dense(512, init='uniform'))
model.add(Activation('sigmoid'))
model.add(Dropout(0.5))
model.add(Dense(nb_classes, input_dim=512, init='uniform'))
model.add(Activation('softmax'))

#Da es sich um eine binäre Klassifizierung handelt, wählen Sie binär und wählen Sie RMSprop als Optimierungsalgorithmus.
model.compile(loss='binary_crossentropy',
              optimizer='rmsprop',
              metrics=['accuracy'])

model.fit(X_train, Y_train,
          nb_epoch=epoch,
          batch_size=batch)

#Bewertung des erstellten Modells und Gewichts anhand von Testdaten
score = model.evaluate(X_test, Y_test, batch_size=batch)
#Diesmal ist die richtige Antwortrate 92%
print(score)
#Sagen Sie einige Bezeichnungen von Testdaten voraus
classified_labels = model.predict_classes(X_test[0:10,:].reshape(-1,784))

#Geben Sie die anzuzeigende Größe an
plt.figure(figsize=(20,10))
for i in range(10):
    plt.subplot(2,5,i+1)
    #In Bilddaten konvertieren
    img = toimage(X_test[i].reshape(28,28))
    plt.imshow(img, cmap='gray')
    plt.title("Class {}".format(label[classified_labels[i]]),fontsize=20)
    plt.axis('off')
plt.show()

#Exportieren Sie Modell- und Gewichtsparameter
model_json = model.to_json()
open('rectangles_architecture.json', 'w').write(model_json)
model.save_weights('rectangles_weights.h5', overwrite=True)

Ergebnis

Wenn Sie die Parameter wie die Anzahl der Epochen, die Anzahl der Stapel und den Optimierungsalgorithmus entsprechend anpassen, scheint die korrekte Antwortrate bei dieser einfachen Klassifizierung etwa 92% zu betragen. Die Ergebnisse einiger Testdaten werden angezeigt. Sie können sehen, dass sie korrekt klassifiziert sind.

Klassifizierung anhand trainierter Daten

Es braucht noch Zeit, um zu lernen. In der Praxis besteht die Methode daher darin, die erlernten Gewichte im Voraus zu speichern und zu verwenden. Was speziell zu tun ist, denke ich, dass es mit den Erweiterungen JSON und h5 am Ende des vorherigen Skripts gespeichert wird. Laden Sie es also einfach. Es ist einfach. Oben haben wir die Testdaten klassifiziert, aber ich kann nicht darauf vertrauen, dass Daten klassifiziert werden können. Aus diesem Grund habe ich die folgenden vier quadratischen Daten mit 56 x 56 Pixel für das Malen vorbereitet. Mal sehen, ob dies kategorisiert werden kann. Wenn Sie sich die Ergebnisse ansehen, können Sie sehen, dass sie korrekt klassifiziert sind. Das zum Laden und Klassifizieren verwendete Python-Skript lautet: Die Ergebnisse des Jupyter-Notizbuchs werden auch auf Gist veröffentlicht. Überprüfen Sie dies daher, falls erforderlich.

`rectangle_load_learned_parameter.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.layers import Dense, Dropout, Activation
from keras.preprocessing import image
from keras.applications.imagenet_utils import preprocess_input, decode_predictions

#Eine Funktion, die Array-Werte durch Angabe eines Schwellenwerts auf 0 und 1 binärisiert
# array:Zweidimensionales Array, Schwelle:Schwelle
def array2d_binarization(array,threshold):
    (row,column) = array.shape
    for i in range(row):
        for j in range(column):
            if(array[i,j] > threshold):
                array[i,j] = 1
            else:
                array[i,j] = 0
    return array

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

#Bedeutung des identifizierten Etiketts
# "Horizontal":Horizontal,"Vertical":Vertikal
label = ["Horizontal","Vertical"]

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

for s in range(test_num):
    #Geben Sie den Dateinamen an
    img_path = "rectangle" + str(s)+".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)
    
    #Binarisieren Sie Bilddaten mit einem Schwellenwert von 50, x, um 28x28 als Argument zu erhalten[:,:,0]Zu
    x = array2d_binarization(x[:,:,0],50)
    #Formatieren Sie ein zweidimensionales 28x28-Array zur Eingabe in einen Vektor der Größe 784
    x = x.reshape(-1,784)

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

abschließend

Ich möchte weiterhin Artikel darüber schreiben, wie Keras in mehreren Teilen verwendet wird. Nächstes Mal werde ich über eine etwas kompliziertere Klassifizierung sprechen. Wenn es Fehler gibt, werden wir diese korrigieren. Bitte weisen Sie darauf hin.

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