Python: Deep Learning-Praxis

Überblick über tiefes Lernen

Code wird mit einem "Framework" geschrieben, das die Programmierung optimieren kann. Für Deep-Learning-Frameworks "Tensor Flow" von US Google entwickelt Es gibt verschiedene Typen wie "PyTorch", die von Facebook in den USA entwickelt wurden.

Hier werden TensorFlow und TensorFlow benutzerfreundlicher. Verwenden Sie das Framework "Keras".

Beispiel für tiefes Lernen

Anzahl der Epochen (gibt an, wie oft eine Trainingsdaten wiederholt trainiert werden) Wie es geht

Richtige Antwortrate gemäß Trainingsdaten Richtige Antwortrate val_acc für Testdaten Lassen Sie uns überprüfen, wie es geht.

import numpy as np
import matplotlib.pyplot as plt
from keras.datasets import mnist
from keras.layers import Activation, Dense, Dropout
from keras.models import Sequential, load_model
from keras import optimizers
from keras.utils.np_utils import to_categorical

(X_train, y_train), (X_test, y_test) = mnist.load_data()

X_train = X_train.reshape(X_train.shape[0], 784)[:6000]
X_test = X_test.reshape(X_test.shape[0], 784)[:1000]
y_train = to_categorical(y_train)[:6000]
y_test = to_categorical(y_test)[:1000]

model = Sequential()
model.add(Dense(256, input_dim=784))
model.add(Activation("sigmoid"))
model.add(Dense(128))
model.add(Activation("sigmoid"))
model.add(Dropout(rate=0.5))
model.add(Dense(10))
model.add(Activation("softmax"))

sgd = optimizers.SGD(lr=0.1)
model.compile(optimizer=sgd, loss="categorical_crossentropy", metrics=["accuracy"])

#Geben Sie 5 für die Anzahl der Epochen an
history = model.fit(X_train, y_train, batch_size=500, epochs=5, verbose=1, validation_data=(X_test, y_test))

#acc, val_gem. Grundstück
plt.plot(history.history["acc"], label="acc", ls="-", marker="o")
plt.plot(history.history["val_acc"], label="val_acc", ls="-", marker="x")
plt.ylabel("accuracy")
plt.xlabel("epoch")
plt.legend(loc="best")
plt.show()

Was ist tiefes Lernen? (1)

Deep Learning, auch Deep Learning genannt, ist eine Art maschinelles Lernen, das noch einen Schritt weiter geht. Referenzierung biologischer neuronaler Netze zur Klassifizierung und Regression von Daten Wir verwenden ein Modell namens Deep Neural Network.

Der Zweck des tiefen Lernens besteht jedoch nicht darin, das neuronale Netzwerk des Gehirns zu reproduzieren. Forschung wird mit dem Ziel durchgeführt, die Erkennungsgenauigkeit von Bildern und Tönen zu verbessern.

Realisiert durch automatische Fahrtechnik mit Bilderkennung, Videoanalyse und Sprachanalyse Intelligente Lautsprecher wie "Google Home" und "Siri" Diese Technologie wird in vielen Bereichen unseres täglichen Lebens eingesetzt.

Einer der Gründe, warum tiefes Lernen Aufmerksamkeit erregt, ist die Automatisierung der Arbeit, die Menschen traditionell geleistet haben. Das spart Zeit und Mühe und verbessert die Genauigkeit.

Zum Beispiel beim Erstellen eines Programms, das ein "Auto" anhand eines Bildes erkennt Beim maschinellen Lernen werden im Voraus detaillierte Informationen wie die Eigenschaften verschiedener Arten von Autoreifen und Windschutzscheiben erstellt. Ich musste ein Modell machen, das es trainierte.

Deep Learning kann jedoch automatisch die Merkmale von Autoteilen ohne ein solches Modell finden.

Was ist tiefes Lernen? (2)

Die folgende Abbildung zeigt die Neuronen, aus denen das neuronale Netzwerk besteht. x1 und x2 sind Eingabewerte und w1 und w2 sind Gewichtsparameter.

Wenn in diesem Modell der Wert von x1w1 + x2w2 höher als der Schwellenwert θ ist, wird das Neuron ausgelöst. Ansonsten 1 und 0 ausgeben.

Wenn die Eingabe den Schwellenwert überschreitet, überträgt das Neuron Informationen an das nächste Neuron.

Dies wird als neuronales Feuern bezeichnet.

Das neuronale Netzwerk empfängt Eingabewerte wie Vektoren und Matrizen Es gibt schließlich Werte wie Skalare und Vektoren über eine Zündkette aus.

Wenn Sie dies mit der Bilderkennung vergleichen, geben Sie die Pixeldaten des Tierbildes ein Es ist ein Bild, das Informationen darüber ausgibt, zu welcher Kategorie (Katze, Hund, Vogel usw.) wahrscheinlich gehört.

Dann wurden, wie in der folgenden Abbildung gezeigt, die Schichten der Neuronen gestapelt, damit komplexere Probleme behandelt werden konnten. Es ist ein tiefes neuronales Netzwerk. Insbesondere bezieht es sich oft auf eine Struktur mit drei oder mehr Schichten. Es wurde wegen der Tiefe seiner Struktur "Deep" genannt.

Eigentlich heißt das mathematische Modell neuronales Netzwerk Es existiert bereits seit den 1950er Jahren.

In den letzten Jahren wurde eine Computerumgebung eingerichtet, die tiefe neuronale Netze nutzen kann. Mit fortschreitender Forschung zu Lernmethoden hat sie viel Aufmerksamkeit erhalten.

Beim tiefen Lernen wird der Gewichtsparameter jedes Neurons mechanisch angepasst. Erstellen Sie ein Klassifizierungsmodell oder ein Regressionsmodell.

Klassifizierungsfluss durch tiefes Lernen

Schauen wir uns den Fluss der Klassifizierung mithilfe von Deep Learning an.

① Erstellen Sie ein Netzwerkmodell

Durch Stapeln von Schichten, die mehrere Neuronen bündeln, wie in der Abbildung gezeigt Erstellen Sie ein tiefes Netzwerkmodell.

Anfangs reagieren die Neuronen zufällig auf die Eingabe und geben bedeutungslose Werte aus.

② Geben Sie die Modell-Trainingsdaten an und führen Sie das Lernen durch

Das Modell nimmt den Eingabewert X und gibt den Ausgabewert y aus.

Stellen Sie zu diesem Zeitpunkt sicher, dass ΔE, das die Differenz zwischen y und den richtigen Antwortdaten (Lehrerbezeichnung) T ist, klein wird. Das Gewicht des Neurons wird automatisch durch eine Methode angepasst, die als Fehlerrückausbreitung bezeichnet wird.

Dann wird durch Geben von Rohdaten X wie einem Bild und korrekten Antwortdaten T das Gewicht wiederholt angepasst. Allmählich erhalten Sie den gewünschten Ausgabewert.

Wenn das Training gut verläuft, haben Sie ein Modell, das entsprechende Vorhersagen zurückgibt.

③ Übergeben Sie die Klassifizierungsdaten an das Modell

Daten können durch tiefes Lernen gemäß dem in der Abbildung gezeigten Fluss klassifiziert werden. Mit anderen Worten, Deep Learning ermöglicht es Ihnen, Modelle für die Klassifizierung und Regression zu erstellen, ohne die Details des Verfahrens verstehen zu müssen.

Klassifizierung handschriftlicher Zahlen

Ablauf zur Klassifizierung

Implementieren wir das folgende neuronale Netzwerkmodell mithilfe einer Bibliothek namens Keras. Zunächst wird das folgende Verfahren verwendet, um handschriftliche Zahlen zu klassifizieren, die als Standard für tiefes Lernen gelten können.

1, bereiten Sie die Daten vor 2, bauen Sie ein neuronales Netzwerkmodell 3, geben Sie dem Modell Daten und trainieren Sie es 4, bewerten Sie die Klassifizierungsgenauigkeit des Modells Geben Sie abschließend ein Bild von handgeschriebenen Zahlen, um die vorhergesagten Werte anzuzeigen.

Tiefes neuronales Netzwerk

Ein neuronales Netzwerk mit einer bestimmten Tiefe

Wird ein tiefes neuronales Netzwerk genannt

Eingabeebene: Eingabeebene Ausgabeschicht: Ausgabeschicht Versteckte Ebene: Zwischen der Eingabeebene und der Ausgabeebene Es heißt.

Dieses Mal waren alle Neuronen mit den Neuronen in der vorherigen Schicht verbunden

Vollständig verbundene Schicht

Erstellen Sie ein neuronales Netzwerk mit einer einfachen Struktur mit zwei.

Wenn die eingegebenen handgeschriebenen Bilddaten "7" sind Die korrekte Antwortbezeichnung der Lehrerdaten ist 1 für das Element entsprechend 7 und 0 für die anderen Elemente.

Daten mit allen Nullwerten außer einem Element

one-Es wird ein heißer Vektor genannt.

Da wir diesmal Zahlen erkennen, repräsentieren die Elemente 0 bis 9 die Zeichen "0" bis "9".

Wenn dies eine Bilderkennung ist, z. B. "Welche Art von Tier ist auf dem Bild?" Das 0. bis N-te Element entspricht jedem Tier, das eine Erkennungsoption darstellt. Solche Klassifikationen (Klassen) werden in der Reihenfolge zugewiesen und numerisch ausgedrückt, was als "Klassenbezeichnung" bezeichnet wird.

Knoteneinheit

Die einzugebenden Daten sind ein Schwarzweißbild mit 28 Pixel in Höhe und Breite. Sogar ein Bild wird als Vektor bezeichnet, da es für einen Computer wie eine Sammlung von 28 x 28 Zahlen aussieht.

Das durch "○" dargestellte Element, das den Vektor empfängt und die Berechnung durchführt

Es wird als "Knoten" oder "Einheit" bezeichnet.

Von der Eingangsseite aus gesehen, sind die Einheiten in der obigen Abbildung vertikal angeordnet

Es wird eine "Schicht" oder "Schicht" genannt.

So heißt es, wenn es so organisiert ist, dass es für den Menschen leicht zu sehen ist. Von wo zu wo sich die Einheiten in derselben Ebene befinden, ändert sich von Zeit zu Zeit.

Diesmal

model.add(Dense(256, input_dim=784))
#Ich habe eine Eingabeebene erstellt. 256 ist die Anzahl der Einheiten.
# input_In dim wird die Anzahl der Elemente des Eingabevektors angegeben.
# input_dim kann als Anzahl der Spalten behandelt werden.

Da 28 × 28 = 784 ist, geben wir an, dass ein Vektor mit 784 Elementen eingegeben wird.

Ich habe mich entschlossen auszudrücken, welches Zeichen die Ausgabe mit einer Wahrscheinlichkeit ist. Die Wahrscheinlichkeit wird für jeden der 10 Typen von 0 bis 9 ausgegeben. Bereiten Sie 10 Einheiten vor, die alle von den Einheiten der verborgenen Ebene ausgegebenen Werte akzeptieren, und geben Sie die Wahrscheinlichkeit aus.

Einführung von Keras

Umfrage der Data Mining-Informationsseite KD Nuggets In Deep Learning Framework Power Scores 2018 Die Ergebnisse zeigen, dass Keras nach TensorFlow das zweitbeliebteste ist.

TensorFlow ist eine Open-Source-Softwarebibliothek für maschinelles Lernen, die von Google bereitgestellt wird. Keras ist eine TensorFlow-Wrapper-Bibliothek, mit der Sie Code intuitiver und präziser schreiben können.

Um es klar auszudrücken, Keras befindet sich irgendwo zwischen TensorFlow und dem Code, anstatt TensorFlow direkt zu schreiben. Sie können den Code auf einen Bruchteil reduzieren.

Der Wrapper bedeutet in diesem Fall, dass das System enthalten ist, um die Verwendung zu vereinfachen.

Vorbereitung der Daten

Zum Erlernen handschriftlicher Zahlen wird es auf der Website von Yann LeCun veröffentlicht.

MNIST(Emnist)Verwenden Sie den Datensatz.

MNIST kann auch heruntergeladen werden, indem der folgende Code in Keras ausgeführt wird.

from keras.datasets import mnist
(X_train, y_train), (X_test, y_test) = mnist.load_data()

Im Code sind X die Bilddaten und y die Lehreretikettendaten. Zug sind Trainingsdaten und Test sind Daten, die zur Bewertung der Leistung des Modells verwendet werden.

Es gibt jedoch keinen wesentlichen Unterschied zwischen Zugdaten und Testdaten. Sie können die Daten auch lesen, indem Sie MNIST im heruntergeladenen Zustand ausführen.

Lassen Sie uns die Größe von X_train, y_train, X_test und y_test ausgeben.

from keras.datasets import mnist

(X_train, y_train), (X_test, y_test) = mnist.load_data()

print(X_train.shape, y_train.shape, X_test.shape, y_test.shape)

#Ausgabeergebnis

(60000, 28, 28) (60000,) (10000, 28, 28) (10000,)

Modellgenerierung

Erstellen Sie bei Keras zunächst eine Instanz, um das Modell zu verwalten

Definieren Sie es Schicht für Schicht mit der Methode add.

Erstellen Sie eine Instanz.

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

model = Sequential()

Dieses Mal definieren wir eine vollständig verbundene Schicht von 128 Einheiten. Definieren Sie das Modell Schicht für Schicht mit der unten gezeigten Add-Methode.

model.add(Dense(128))

Eine als Aktivierungsfunktion bezeichnete Funktion wird auf den Ausgang der vollständig verbundenen Schicht angewendet.

model.add(Activation("sigmoid"))

Dies ist ein Mechanismus, der dem Abfeuern der Nerven des Tieres entspricht.

Stellen Sie die Sigmoid-Funktion Sigmoid und die ReLU-Funktion relu ein.

Und schlussendlich

Kompilierungsmethode kompilieren()Stellen Sie den Trainingsprozess mit ein und die Modellgenerierung ist abgeschlossen.

model.compile(optimizer=sgd, loss="categorical_crossentropy", metrics=["accuracy"])
#Diese Funktionen und Parameter werden später erläutert.

Wenn Sie ein Beispiel geben

Erfassen Sie zunächst das Konstruktionsbild des Netzwerkmodells. Im folgenden Code nach dem Generieren eines Netzwerkmodells mit einer verborgenen Schicht. Generieren Sie ein Modell mit zwei ausgeblendeten Ebenen, wie unten gezeigt. Verwenden Sie die ReLU-Funktion relu als Aktivierungsfunktion.

from keras.datasets import mnist
from keras.models import Sequential
from keras.layers import Dense, Activation
from keras.utils.vis_utils import plot_model
from keras.utils.np_utils import to_categorical
import matplotlib.pyplot as plt

(X_train, y_train), (X_test, y_test) = mnist.load_data()

# (◯, 28, 28)Daten(◯, 784)Dimensionsreduzierung auf.(Reduzieren Sie der Einfachheit halber die Anzahl der Daten)
shapes = X_train.shape[1] * X_train.shape[2]
X_train = X_train.reshape(X_train.shape[0], shapes)[:6000]
X_test = X_test.reshape(X_test.shape[0], shapes)[:1000]
y_train = to_categorical(y_train)[:6000]
y_test = to_categorical(y_test)[:1000]

model = Sequential()
#Die Anzahl der Eingabeeinheiten beträgt 784,Die Anzahl der Ausgabeeinheiten in der ersten vollständig verbundenen Schicht beträgt 256
model.add(Dense(256, input_dim=784))
model.add(Activation("sigmoid"))

#Die Anzahl der Ausgabeeinheiten in der zweiten vollständig verbundenen Schicht beträgt 128. Die Aktivierungsfunktion ist relu.
#　---------------------------
#Es werden zwei versteckte Ebenen erstellt.
model.add(Dense(128))
model.add(Activation("relu"))

#　---------------------------

#Die Anzahl der Ausgabeeinheiten in der dritten vollständig verbundenen Schicht (Ausgangsschicht) beträgt 10.
model.add(Dense(10))
model.add(Activation("softmax"))

model.compile(optimizer="sgd", loss="categorical_crossentropy", metrics=["accuracy"])

#Ausgabe der Modellstruktur
plot_model(model, "model125.png ", show_layer_names=False)
#Visualisierung der Modellstruktur
image = plt.imread("model125.png ")
plt.figure(dpi=150)
plt.imshow(image)
plt.axis('off')
plt.show()

Modelllernen

#Das Training wird mithilfe der Anpassungsmethode durchgeführt und die Trainingsdaten an das Modell übergeben.
model.fit(X_train, y_train, verbose=1, epochs=3)

Bei der Anpassungsmethode werden die Trainingsdaten der Reihe nach in das Modell eingegeben. Aktualisieren Sie das Gewicht jedes Neurons so, dass der Unterschied zwischen der Ausgabe und den Lehrerdaten gering ist Wir werden die Vorhersagegenauigkeit des Modells verbessern.

(1) Als Rückgabewert wird ein Verlaufsobjekt zurückgegeben, das eine Aufzeichnung des Lernens enthält.
② Argument X._Zug ist Trainingsdaten, y_Zug ist Lehrerdaten.
③ 1 für ausführlich(Oder wahr)Wenn angegeben, wird der Lernfortschritt ausgegeben, und wenn er 0 ist, wird er nicht ausgegeben.
④ Epochen geben die Anzahl der Schulungen an, die mit demselben Datensatz durchgeführt werden sollen.

Hier ist ein Beispiel.

from keras.datasets import mnist
from keras.layers import Activation, Dense
from keras.models import Sequential
from keras import optimizers
from keras.utils.np_utils import to_categorical
import matplotlib.pyplot as plt

(X_train, y_train), (X_test, y_test) = mnist.load_data()

X_train = X_train.reshape(X_train.shape[0], 784)[:6000]
X_test = X_test.reshape(X_test.shape[0], 784)[:1000]
y_train = to_categorical(y_train)[:6000]
y_test = to_categorical(y_test)[:1000]

model = Sequential()
model.add(Dense(256, input_dim=784))
model.add(Activation("sigmoid"))
model.add(Dense(128))
model.add(Activation("sigmoid"))
model.add(Dense(10))
model.add(Activation("softmax"))

model.compile(optimizer="sgd", loss="categorical_crossentropy", metrics=["accuracy"])
#---------------------------
history = model.fit(X_train, y_train, verbose=True, epochs=3)
#---------------------------
#acc, val_gem. Grundstück
plt.plot(history.history["acc"], label="acc", ls="-", marker="o")
plt.ylabel("accuracy")
plt.xlabel("epoch")
plt.legend(loc="best")
plt.show()

Modellbewertung

Auch wenn die Abstimmung durch Lernen abgeschlossen ist und die Genauigkeit des Modells verbessert wird Es ist möglich, dass seine Leistung nur mit Trainingsdaten nachgewiesen werden kann. Daher können die trainierten Daten nicht zur korrekten Bewertung der Leistung des Modells verwendet werden.

Daher werden wir das Modell anhand von Testdaten bewerten, die nicht für das Training verwendet wurden. Die Genauigkeit zu diesem Zeitpunkt

Generalisierungsgenauigkeit(Genauigkeit für neue Daten)Es heißt.

Zur Berechnung der Generalisierungsgenauigkeit

Verwenden Sie die Auswertungsmethode.

score = model.evaluate(X_test, y_test, verbose=1)

X_test sind die Eingabedaten für die Bewertung (Test) und y_test sind die Lehrerdaten. Der Wert der Verlustfunktion und die durch die Bewertungsmethode erhaltene Genauigkeitsrate werden in der Punktzahl gespeichert.

Die Testdaten dienen zur Berechnung der Generalisierungsgenauigkeit und werden nicht für das Training verwendet.

import numpy as np
import matplotlib.pyplot as plt
from keras.datasets import mnist
from keras.layers import Activation, Dense
from keras.models import Sequential, load_model
from keras import optimizers
from keras.utils.np_utils import to_categorical

(X_train, y_train), (X_test, y_test) = mnist.load_data()

X_train = X_train.reshape(X_train.shape[0], 784)[:6000]
X_test = X_test.reshape(X_test.shape[0], 784)[:1000]
y_train = to_categorical(y_train)[:6000]
y_test = to_categorical(y_test)[:1000]

model = Sequential()
model.add(Dense(256, input_dim=784))
model.add(Activation("sigmoid"))
model.add(Dense(128))
model.add(Activation("sigmoid"))
model.add(Dense(10))
model.add(Activation("softmax"))

model.compile(optimizer="sgd", loss="categorical_crossentropy", metrics=["accuracy"])

model.fit(X_train, y_train)

# ---------------------------
score = model.evaluate(X_test, y_test, verbose=True)
# ---------------------------
print("evaluate loss: {0[0]}\nevaluate acc: {0[1]}".format(score))

Klassifizierung nach Modell

Verwenden Sie die Vorhersagemethode, um den vorhergesagten Wert der Eingabedaten zu erhalten.

predict(self, x, batch_size=None, verbose=0, steps=None)

Streit

①　x:Eingabedaten. Numpy Array-Format.
②　batch_size:ganze Zahl. Der Standardwert ist 32.
③　verbose:Ausgabemodus für Fortschrittsmeldungen. 0 oder 1.
④　steps:Gesamtzahl der Schritte (Probencharge) vor dem Ende der Bewertungsrunde. Wenn Keine (Standardwert), wird dies ignoriert.

Rückgabewert

Numpy Array mit vorhergesagten Werten

Wenn Sie beispielsweise die Anzahl von zwei Bildern von X_test vorhersagen, ist dies wie folgt.

import numpy as np
#Bereiten Sie ein geschultes Modell vor.
model = ...

#Vorhersagen
pred = np.argmax(model.predict(X_test[0:2]))
print("Voraussichtlicher Wert:" + str(pred))

Beachten Sie, dass bei der Vorhersage mehrere Bilder vorausgesetzt werden. Bei der Vorhersage nur eines Blattes muss auf die Abmessung geachtet werden. Wenn Sie nur eine vorhersagen möchten Es ist notwendig, das Argument als X_test [0] .reshape (1, -1) zu beschreiben.

In MNIST beträgt die Ausgabe der Vorhersagemethode 10 Dimensionen Verwenden Sie die Funktion argmax, um den Index des Maximalwerts des Arrays zurückzugeben Ruft die Position des Neurons ab, das den höchsten Wert zurückgibt.

import numpy as np
x = np.array([[0, 1, 2], [-1, 1000, 1]])
print(np.argmax(x)) #Rückgabe 4.
print(np.argmax(x, axis=0)) # [0, 1, 0]Kehrt zurück.
print(np.argmax(x, axis=1)) # [2, 1]Kehrt zurück.

Die Argmax-Funktion ist

(1) Geben Sie die Achse mit der optionalen Argumentachse an und geben Sie sie mit dem ersten Argument an
Überprüfen Sie den Index des Maximalwerts für das Array.

(2) Wenn keine Achse angegeben ist, ist das Array eindimensional.
Gibt den Index des Maximalwerts bei Umformung zurück.

Geben Sie nach dem Lernen den vorhergesagten Wert von X_test [0:10] aus und sehen Sie ihn.

import numpy as np
import matplotlib.pyplot as plt
from keras.datasets import mnist
from keras.layers import Activation, Dense
from keras.models import Sequential, load_model
from keras.utils.np_utils import to_categorical

(X_train, y_train), (X_test, y_test) = mnist.load_data()

X_train = X_train.reshape(X_train.shape[0], 784)[:6000]
X_test = X_test.reshape(X_test.shape[0], 784)[:1000]
y_train = to_categorical(y_train)[:6000]
y_test = to_categorical(y_test)[:1000]

model = Sequential()
model.add(Dense(256, input_dim=784))
model.add(Activation("sigmoid"))
model.add(Dense(128))
model.add(Activation("sigmoid"))
model.add(Dense(10))
model.add(Activation("softmax"))

model.compile(optimizer="sgd", loss="categorical_crossentropy", metrics=["accuracy"])

model.fit(X_train, y_train, verbose=True)

score = model.evaluate(X_test, y_test, verbose=False)
print("evaluate loss: {0[0]}\nevaluate acc: {0[1]}".format(score))

#Zeigen Sie die ersten 10 Blätter mit Testdaten an
for i in range(10):
    plt.subplot(1, 10, i+1)
    plt.imshow(X_test[i].reshape((28,28)), "gray")
plt.show()

# X_Zeigt die ersten 10 vorhergesagten Testetiketten an
#---------------------------
pred = np.argmax(model.predict(X_test[0:10]), axis=1)
print(pred)
#---------------------------