Deep Learning mit Keras - Daten vorbereiten
Bevor wir die Daten in unser Netzwerk einspeisen, müssen sie in das vom Netzwerk benötigte Format konvertiert werden. Dies wird als Vorbereiten von Daten für das Netzwerk bezeichnet. Es besteht im Allgemeinen darin, eine mehrdimensionale Eingabe in einen eindimensionalen Vektor umzuwandeln und die Datenpunkte zu normalisieren.
Eingangsvektor umformen
Die Bilder in unserem Datensatz bestehen aus 28 x 28 Pixel. Dies muss in einen eindimensionalen Vektor der Größe 28 * 28 = 784 umgewandelt werden, um ihn in unser Netzwerk einzuspeisen. Wir tun dies, indem wir die anrufenreshape Methode auf dem Vektor.
X_train = X_train.reshape(60000, 784)
X_test = X_test.reshape(10000, 784)
Jetzt besteht unser Trainingsvektor aus 60000 Datenpunkten, die jeweils aus einem eindimensionalen Vektor der Größe 784 bestehen. In ähnlicher Weise besteht unser Testvektor aus 10000 Datenpunkten eines eindimensionalen Vektors der Größe 784.
Daten normalisieren
Die Daten, die der Eingabevektor enthält, haben derzeit einen diskreten Wert zwischen 0 und 255 - die Graustufen. Das Normalisieren dieser Pixelwerte zwischen 0 und 1 hilft, das Training zu beschleunigen. Da wir einen stochastischen Gradientenabstieg verwenden, hilft die Normalisierung der Daten auch dabei, die Wahrscheinlichkeit zu verringern, dass sie in lokalen Optima stecken bleiben.
Um die Daten zu normalisieren, stellen wir sie als Float-Typ dar und teilen sie durch 255, wie im folgenden Code-Snippet gezeigt -
X_train = X_train.astype('float32')
X_test = X_test.astype('float32')
X_train /= 255
X_test /= 255
Schauen wir uns nun an, wie die normalisierten Daten aussehen.
Untersuchen normalisierter Daten
Um die normalisierten Daten anzuzeigen, rufen wir die hier gezeigte Histogrammfunktion auf -
plot.hist(X_train[0])
plot.title("Digit: {}".format(y_train[0]))
Hier zeichnen wir das Histogramm des ersten Elements der X_trainVektor. Wir drucken auch die durch diesen Datenpunkt dargestellte Ziffer. Die Ausgabe des Ausführens des obigen Codes wird hier gezeigt -
Sie werden eine dicke Punktdichte mit einem Wert nahe Null bemerken. Dies sind die schwarzen Punkte im Bild, die offensichtlich den Hauptteil des Bildes ausmachen. Die restlichen Graustufenpunkte, die nahe an der weißen Farbe liegen, repräsentieren die Ziffer. Sie können die Pixelverteilung für eine andere Ziffer überprüfen. Der folgende Code druckt das Histogramm einer Ziffer mit dem Index 2 im Trainingsdatensatz.
plot.hist(X_train[2])
plot.title("Digit: {}".format(y_train[2])
Die Ausgabe des Ausführens des obigen Codes wird unten gezeigt -
Wenn Sie die beiden obigen Abbildungen vergleichen, werden Sie feststellen, dass die Verteilung der weißen Pixel in zwei Bildern unterschiedlich ist, was auf eine Darstellung einer anderen Ziffer hinweist - "5" und "4" in den beiden obigen Bildern.
Als nächstes werden wir die Verteilung der Daten in unserem vollständigen Trainingsdatensatz untersuchen.
Untersuchen der Datenverteilung
Bevor wir unser Modell für maschinelles Lernen in unserem Datensatz trainieren, sollten wir die Verteilung der eindeutigen Ziffern in unserem Datensatz kennen. Unsere Bilder repräsentieren 10 verschiedene Ziffern im Bereich von 0 bis 9. Wir möchten die Anzahl der Ziffern 0, 1 usw. in unserem Datensatz wissen. Wir können diese Informationen über dieunique Methode von Numpy.
Verwenden Sie den folgenden Befehl, um die Anzahl der eindeutigen Werte und die Anzahl der Vorkommen jedes einzelnen zu drucken
print(np.unique(y_train, return_counts=True))
Wenn Sie den obigen Befehl ausführen, wird die folgende Ausgabe angezeigt:
(array([0, 1, 2, 3, 4, 5, 6, 7, 8, 9], dtype=uint8), array([5923, 6742, 5958, 6131, 5842, 5421, 5918, 6265, 5851, 5949]))
Es zeigt, dass es 10 verschiedene Werte gibt - 0 bis 9. Es gibt 5923 Vorkommen von Ziffer 0, 6742 Vorkommen von Ziffer 1 und so weiter. Der Screenshot der Ausgabe wird hier gezeigt -
Als letzten Schritt bei der Datenaufbereitung müssen wir unsere Daten verschlüsseln.
Daten codieren
Wir haben zehn Kategorien in unserem Datensatz. Wir werden daher unsere Ausgabe in diesen zehn Kategorien mit One-Hot-Codierung codieren. Wir verwenden die to_categorial-Methode von Numpy-Dienstprogrammen, um die Codierung durchzuführen. Nachdem die Ausgabedaten codiert wurden, würde jeder Datenpunkt in einen eindimensionalen Vektor der Größe 10 konvertiert. Beispielsweise wird die Ziffer 5 nun als [0,0,0,0,0,1,0,0,0 "dargestellt , 0].
Codieren Sie die Daten mit dem folgenden Code:
n_classes = 10
Y_train = np_utils.to_categorical(y_train, n_classes)
Sie können das Ergebnis der Codierung überprüfen, indem Sie die ersten 5 Elemente des kategorisierten Y_train-Vektors drucken.
Verwenden Sie den folgenden Code, um die ersten 5 Vektoren zu drucken -
for i in range(5):
print (Y_train[i])
Sie sehen die folgende Ausgabe -
[0. 0. 0. 0. 0. 1. 0. 0. 0. 0.]
[1. 0. 0. 0. 0. 0. 0. 0. 0. 0.]
[0. 0. 0. 0. 1. 0. 0. 0. 0. 0.]
[0. 1. 0. 0. 0. 0. 0. 0. 0. 0.]
[0. 0. 0. 0. 0. 0. 0. 0. 0. 1.]
Das erste Element repräsentiert die Ziffer 5, das zweite die Ziffer 0 und so weiter.
Schließlich müssen Sie auch die Testdaten kategorisieren, was mit der folgenden Anweisung erfolgt:
Y_test = np_utils.to_categorical(y_test, n_classes)
Zu diesem Zeitpunkt sind Ihre Daten vollständig für die Einspeisung in das Netzwerk vorbereitet.
Als nächstes kommt der wichtigste Teil und das ist das Training unseres Netzwerkmodells.