Keras Tutorial: Deep-Learning Beispiel mit Keras & Python


Bei Keras handelt es sich um eine Open-Source-Bibliothek zur Erstellung von Deep-Learning-Anwendungen. Keras ist in Python geschrieben und bietet eine einheitliche Schnittstelle für verschiedene Deep-Learning-Backends wie „TensorFlow” und „Theano”. Deep Learning ist ein Teilbereich von Machine Learning und basiert auf künstlichen neuronalen Netzen.

Keras zielt darauf ab, den Einstieg in Deep Learning zu vereinfachen. Im Verlauf dieses Keras-Tutorials werden wir die Funktionsweise von Keras anhand eines einfachen Beispiels erläutern.

Maximaler Schutz für Ihre Daten von IONOS

Einfache Backups für Cloud-Infrastruktur, PCs und Smartphones, inklusive persönlichem Berater!

Umfassender Schutz
Einfache Wiederherstellung
Schnelle Datenspeicherung

Ihr System für die Nutzung von Keras vorbereiten

Bereiten Sie Ihr System für die Nutzung von Keras am besten vor, indem Sie das Softwarepaket „Anaconda” installieren. Dabei handelt es sich um eine kostenlos verfügbare Plattform für Data Science. Sie beinhaltet nützliche Bibliotheken und Tools und bringt eine Python3-Installation von Haus aus mit.

Anaconda und Python installieren

Die nachfolgenden Erklärungen und der abgebildete Code beziehen sich auf macOS. Prinzipiell sollte der Code auch unter anderen Betriebssystemen laufen. Es kann jedoch sein, dass Sie einige Anpassungen vornehmen müssen, insbesondere, wenn Sie Windows verwenden.

Wenn Sie mit der Kommandozeile vertraut sind und die freie Paketverwaltung Homebrew auf Ihrem Mac installiert haben, nutzen Sie diese, um Anaconda zu installieren. Öffnen Sie dazu eine Kommandozeile (‚Terminal.App‘ auf dem Mac), kopieren Sie die folgende Codezeile in das Terminal und führen Sie sie aus.

brew cask install anaconda

Sollten Ihnen Homebrew kein Begriff sein oder möchten Sie Anaconda unter Windows oder Linux installieren, laden Sie das für Ihr System passende Installationspaket von der folgenden Seite herunter: Anaconda – Individual Edition.

Anaconda- und Python-Installation testen

Um sicherzustellen, dass Anaconda und Python korrekt installiert wurden, führen Sie die folgenden Befehle auf der Kommandozeile aus:

Um sich die Version des Conda-Paketmanagers anzeigen zu lassen

Um die Version des Python-Interpreters angezeigt zu bekommen

Sollten Ihnen bei der Eingabe die Fehlermeldung „Befehl nicht gefunden” angezeigt werden, müssen Sie gegebenenfalls den Pfad auf die Anaconda-Binaries setzen. Lesen Sie dafür den nächsten Abschnitt. Haben die Tests funktioniert, überspringen Sie ihn.

Pfad für Anaconda-Binaries setzen

Die Pfad-Umgebungsvariable „PATH“ enthält Informationen darüber, wo im Dateisystem sich bestimmte Hilfsprogramme befinden. Einzelne Pfade innerhalb der Umgebungsvariable werden mit einem Doppelpunkt getrennt. Sie können weitere Pfade anhängen, hier dargestellt für Anaconda in der Version 3:

export PATH=/usr/local/anaconda3/bin:"$PATH"

Damit der Pfad auch tatsächlich aktiv wird, müssen Sie diese Codezeile in Ihrem System hinterlegen. Je nach System und der eingesetzten Shell (Bash, zsh etc.) unterscheidet sich die Datei, in der die Änderung vorgenommen wird. Wir zeigen dies hier exemplarisch für Bash unter macOS.

Führen Sie die folgenden Codezeilen auf der Kommandozeile aus, um die Pfad-Variable in der Datei „.bash_profile“ anzupassen:

Pfad-Variable, um die Anaconda-Installation zu erweitern

echo -n 'export PATH=/usr/local/anaconda3/bin:"$PATH"' >> "$HOME/.bash_profile"

Die .bash_profile-Datei laden

source "$HOME/.bash_profile"

Tipp

Verwenden Sie auf der Kommandozeile den Befehl ‚cat „$HOME/.bash_profile“‚, um sich die bestehende ‚.bash_profile‘-Datei anzeigen zu lassen.

Wiederholen Sie nun die Tests:

Version des Conda-Paketmanagers anzeigen

Version des Python-Interpreters anzeigen

Ihnen sollten nun die Versionsnummern angezeigt werden. Ist dies der Fall, können Sie mit den folgenden Schritten weitermachen.

Anaconda- und Python-Installation auf den neuesten Stand bringen

Bevor Sie ein neues Projekt beginnen, ist es ratsam, die unterliegenden Bibliotheken auf den neuesten Stand zu bringen. Die Anaconda-Plattform bringt den Paketmanager „conda“ mit. Verwenden Sie die folgenden Conda-Befehle, um verfügbare Updates einzuspielen:

Updates für den Conda-Paketmanager installieren

Anaconda-Updates installieren

Versionsnummern der installierten Keras-Deep-Learning-Pakete überprüfen

Keras ist in Python geschrieben und baut auf einer Vielzahl anderer Python-Module auf. Führen Sie den folgenden Codeblock auf der Kommandozeile aus, um die Versionsnummern der meistgenutzten Keras Deep-Learning-Pakete anzuzeigen:

python << EOF
print()
# scipy
import scipy
print('scipy: %s' % scipy.__version__)
# numpy
import numpy
print('numpy: %s' % numpy.__version__)
# matplotlib
import matplotlib
print('matplotlib: %s' % matplotlib.__version__)
# pandas
import pandas
print('pandas: %s' % pandas.__version__)
# statsmodels
import statsmodels
print('statsmodels: %s' % statsmodels.__version__)
# scikit-learn
import sklearn
print('sklearn: %s' % sklearn.__version__)
print()
EOF

Keras auf Ihrem System installieren

Nachdem wir das System vorbereitet haben, installieren wir nun Keras. Führen Sie dafür die folgenden Codezeilen auf der Kommandozeile aus:

TensorFlow installieren

Wie gehabt, überprüfen Sie als nächstes die installierte Keras-Version. Verwenden Sie dafür die folgende Codezeile:

python -c "import keras; print(keras.__version__)"

Liegt die Keras-Installation bereits einige Zeit zurück, sollten Sie nach verfügbaren Updates suchen und diese installieren. Die folgende Codezeile erledigt dies für Sie. Kopieren Sie diese wie gewohnt und führen Sie den Code auf der Kommandozeile aus:

pip install --upgrade keras

Beispiel für ein einfaches Keras Deep-Learning

Das Keras-Team veröffentlicht eine Liste mit Keras-Beispielen unter einer freien Lizenz auf GitHub. Wir werden exemplarisch das spezifische Beispiel ‚mnist_cnn.py‘ behandeln. Der Code erzeugt ein „Convolutional Neural Network“ (CNN oder ConvNet) und trainiert es auf die Trainingsdaten.

Für Trainings- und Testdaten nutzt das Keras Beispiel-Script den MNIST-Datensatz. Dabei handelt es sich um eine große Sammlung kleiner Bilder mit jeweils 28 x 28 Pixel. Jedes Bild enthält eine per Hand geschriebene Zahl. Der MNIST-Datensatz gilt als Standard für Mustererkennung und wird mit Keras ausgeliefert.

Falls Sie neugierig sind, können Sie sich die Trainings- und Testdatenanschauen. Kopieren Sie dazu den folgenden Codeblock und führen Sie ihn auf der Kommandozeile aus. Bei jeder Ausführung wird Ihnen eines der Trainingsbilder angezeigt.

python << EOF
# Keras laden
import keras
# MNIST Training- und Test-Datensätze laden
from keras.datasets import mnist
# Bibliothek für grafische Darstellung laden
import matplotlib.pyplot as plt
# Funktion für zufällige Bildauswahl laden
from random import randint

# Datensätze laden
(train_images, train_labels), (test_images, test_labels) = mnist.load_data()

# Bild zeigen
plt.figure()
plt.imshow(train_images[randint(1, len(train_images) - 1)])
plt.grid(False)
plt.show()
EOF

Wir werden im Folgenden das neuronale Netzwerk darauf trainieren, die handschriftlichen Ziffern korrekt zuzuordnen. Das Trainieren des Netzwerks ist rechenaufwendig. Wundern Sie sich also nicht, wenn ihr Computer ordentlich ins Stocken gerät — das ist normal. Sollten Sie ein mobiles Gerät verwenden, achten Sie darauf, dass die Batterie ausreichend geladen ist, oder schließen Sie das Gerät an das Stromnetz an.

Wir werden zunächst einen Test-Ordner auf dem Desktop anlegen, in den Ordner wechseln und dort ein leeres Python-Skript erzeugen. Verwenden Sie dafür die folgenden Codezeilen; kopieren Sie diese und führen Sie sie auf der Kommandozeile aus:

Um einen Ordner „keras-test“ auf dem Desktop anzulegen

mkdir "$HOME/Desktop/keras-test/" && cd "$HOME/Desktop/keras-test/"

Um ein leeres Python-Skript anzulegen

Danach müssen Sie das Skript in die Datei „keras-test.py“ kopieren und speichern.

Ist der Test-Ordner angelegt, erstellen Sie als nächstes das Keras Beispiel-Skript. Kopieren Sie dafür den Code am Ende dieses Artikels und fügen Sie ihn in ein leeres Textdokument ein. Speichern Sie das Dokument im soeben auf dem Desktop erstellten Ordner „keras-test“ in der bis dato leeren Datei „keras-test.py“. Um das Keras-Beispiel-Skript mithilfe des Python-Interpreters auszuführen, geben Sie schließlich noch die folgenden Codezeilen auf der Kommandozeile ein:

cd "$HOME/Desktop/keras-test/" && python keras-test.py

Ihnen sollten nun einige Status-Informationen angezeigt werden. Dann beginnt das Skript mit dem Trainieren des ConvNet, wobei Ihnen der Fortschritt beim Durchlaufen der einzelnen Epochen angezeigt wird. Nach Durchlaufen des Skripts ist das ConvNet trainiert und steht für die Klassifizierung handschriftlicher Ziffern zur Verfügung.

Hinweis

Benutzen Sie zum Speichern des Codes ausschließlich einen Code-Editor/„Plain Text“-Editor. Keinesfalls sollten Sie Textverarbeitungssoftware wie Word, OpenOffice oder LibreOffice verwenden.

# Code in der Datei 'keras-test.py' im Ordner 'keras-test' speichern
from __future__ import print_function
# Keras laden
import keras
# MNIST Training- und Test-Datensätze laden
from keras.datasets import mnist
# Sequentielles Modell laden
from keras.models import Sequential
# Ebenen des neuronalen Netzes laden
from keras.layers import Dense, Dropout, Flatten
from keras.layers import Conv2D, MaxPooling2D
from keras import backend as K

# Anzahl unterschiedlicher Daten-Ausprägungen: Ziffern 0–9
num_classes = 10
# Anzahl der Durchgänge für Training des neuronalen Netzes
epochs = 12
# Anzahl der während eines Durchgangs genutzten Daten
batch_size = 128

# Dimensionen der Eingabebilder (28 x 28 Pixel pro Bild)
img_rows, img_cols = 28, 28

# Trainings- und Testdaten laden
(train_images, train_labels), (test_images, test_labels) = mnist.load_data()

if K.image_data_format() == 'channels_first':
    train_images = train_images.reshape(train_images.shape[0], 1, img_rows, img_cols)
    test_images = test_images.reshape(test_images.shape[0], 1, img_rows, img_cols)
    input_shape = (1, img_rows, img_cols)
else:
    train_images = train_images.reshape(train_images.shape[0], img_rows, img_cols, 1)
    test_images = test_images.reshape(test_images.shape[0], img_rows, img_cols, 1)
    input_shape = (img_rows, img_cols, 1)

# Gleitkomma-Datentyp setzen
train_images = train_images.astype('float32')
test_images = test_images.astype('float32')
# Bilddaten normalisieren
train_images /= 255
test_images /= 255

print('train_images shape:', train_images.shape)
print(train_images.shape[0], 'train samples')
print(test_images.shape[0], 'test samples')

# Klassen-Vektoren in binäre Klassen-Matrizen konvertieren
train_labels = keras.utils.to_categorical(train_labels, num_classes)
test_labels = keras.utils.to_categorical(test_labels, num_classes)

# Modell erzeugen
model = Sequential()
# Ebenen zum Modell hinzufügen
model.add(Conv2D(32, kernel_size=(3, 3),
                 activation='relu',
                 input_shape=input_shape))
model.add(Conv2D(64, (3, 3), activation='relu'))
model.add(MaxPooling2D(pool_size=(2, 2)))
model.add(Dropout(0.25))
model.add(Flatten())
model.add(Dense(128, activation='relu'))
model.add(Dropout(0.5))
model.add(Dense(num_classes, activation='softmax'))

# Modell kompilieren
model.compile(loss=keras.losses.categorical_crossentropy,
              optimizer=keras.optimizers.Adadelta(),
              metrics=['accuracy'])

# Modell trainieren
model.fit(train_images, train_labels,
          batch_size=batch_size,
          epochs=epochs,
          verbose=1,
          validation_data=(test_images, test_labels))

# Modell auswerten
score = model.evaluate(test_images, test_labels, verbose=0)
print('Test loss:', score[0])
print('Test accuracy:', score[1])



Source link

Schreibe einen Kommentar

Deine E-Mail-Adresse wird nicht veröffentlicht. Erforderliche Felder sind mit * markiert.