Bei Keras handelt es sich um eine Open-Source-Bi­blio­thek zur Er­stel­lung von Deep-Learning-An­wen­dun­gen. Keras ist in Python ge­schrie­ben und bietet eine ein­heit­li­che Schnitt­stel­le für ver­schie­de­ne Deep-Learning-Backends wie „Ten­sor­Flow” und „Theano”. Deep Learning ist ein Teil­be­reich von Machine Learning und basiert auf künst­li­chen neu­ro­na­len Netzen.

Keras zielt darauf ab, den Einstieg in Deep Learning zu ver­ein­fa­chen. Im Verlauf dieses Keras-Tutorials werden wir die Funk­ti­ons­wei­se von Keras anhand eines einfachen Beispiels erläutern.

Cloud Backup powered by Acronis
Mi­ni­mie­ren Sie Aus­fall­zei­ten mit unserem Kom­plett­schutz
  • Au­to­ma­tisch: Backups und Recovery
  • Intuitiv: Planung und Ma­nage­ment
  • In­tel­li­gent: KI-basierter Be­dro­hungs­schutz
  • Inkl. 300,- € Start­gut­ha­ben im 1. Monat

Ihr System für die Nutzung von Keras vor­be­rei­ten

Bereiten Sie Ihr System für die Nutzung von Keras am besten vor, indem Sie das Soft­ware­pa­ket „Anaconda” in­stal­lie­ren. Dabei handelt es sich um eine kostenlos ver­füg­ba­re Plattform für Data Science. Sie be­inhal­tet nützliche Bi­blio­the­ken und Tools und bringt eine Python3-In­stal­la­ti­on von Haus aus mit.

Anaconda und Python in­stal­lie­ren

Die nach­fol­gen­den Er­klä­run­gen und der ab­ge­bil­de­te Code beziehen sich auf macOS. Prin­zi­pi­ell sollte der Code auch unter anderen Be­triebs­sys­te­men laufen. Es kann jedoch sein, dass Sie einige An­pas­sun­gen vornehmen müssen, ins­be­son­de­re, wenn Sie Windows verwenden.

Wenn Sie mit der Kom­man­do­zei­le vertraut sind und die freie Pa­ket­ver­wal­tung Homebrew auf Ihrem Mac in­stal­liert haben, nutzen Sie diese, um Anaconda zu in­stal­lie­ren. Öffnen Sie dazu eine Kom­man­do­zei­le ('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 in­stal­lie­ren, laden Sie das für Ihr System passende In­stal­la­ti­ons­pa­ket von der folgenden Seite herunter: Anaconda – In­di­vi­du­al Edition.

Anaconda- und Python-In­stal­la­ti­on testen

Um si­cher­zu­stel­len, dass Anaconda und Python korrekt in­stal­liert wurden, führen Sie die folgenden Befehle auf der Kom­man­do­zei­le aus:

Um sich die Version des Conda-Pa­ket­ma­na­gers anzeigen zu lassen

conda -version

Um die Version des Python-In­ter­pre­ters angezeigt zu bekommen

python --version

Sollten Ihnen bei der Eingabe die Feh­ler­mel­dung „Befehl nicht gefunden” angezeigt werden, müssen Sie ge­ge­be­nen­falls den Pfad auf die Anaconda-Binaries setzen. Lesen Sie dafür den nächsten Abschnitt. Haben die Tests funk­tio­niert, über­sprin­gen Sie ihn.

Pfad für Anaconda-Binaries setzen

Die Pfad-Um­ge­bungs­va­ria­ble „PATH“ enthält In­for­ma­tio­nen darüber, wo im Da­tei­sys­tem sich bestimmte Hilfs­pro­gram­me befinden. Einzelne Pfade innerhalb der Um­ge­bungs­va­ria­ble werden mit einem Dop­pel­punkt getrennt. Sie können weitere Pfade anhängen, hier dar­ge­stellt für Anaconda in der Version 3:

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

Damit der Pfad auch tat­säch­lich aktiv wird, müssen Sie diese Codezeile in Ihrem System hin­ter­le­gen. Je nach System und der ein­ge­setz­ten Shell (Bash, zsh etc.) un­ter­schei­det sich die Datei, in der die Änderung vor­ge­nom­men wird. Wir zeigen dies hier ex­em­pla­risch für Bash unter macOS.

Führen Sie die folgenden Code­zei­len auf der Kom­man­do­zei­le aus, um die Pfad-Variable in der Datei „.bash_profile“ an­zu­pas­sen:

Pfad-Variable, um die Anaconda-In­stal­la­ti­on 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 Kom­man­do­zei­le den Befehl 'cat "$HOME/.bash_profile"', um sich die be­stehen­de '.bash_profile'-Datei anzeigen zu lassen.

Wie­der­ho­len Sie nun die Tests:

Version des Conda-Pa­ket­ma­na­gers anzeigen

conda -version

Version des Python-In­ter­pre­ters anzeigen

python --version

Ihnen sollten nun die Ver­si­ons­num­mern angezeigt werden. Ist dies der Fall, können Sie mit den folgenden Schritten wei­ter­ma­chen.

Anaconda- und Python-In­stal­la­ti­on auf den neuesten Stand bringen

Bevor Sie ein neues Projekt beginnen, ist es ratsam, die un­ter­lie­gen­den Bi­blio­the­ken auf den neuesten Stand zu bringen. Die Anaconda-Plattform bringt den Pa­ket­ma­na­ger „conda“ mit. Verwenden Sie die folgenden Conda-Befehle, um ver­füg­ba­re Updates ein­zu­spie­len:

Updates für den Conda-Pa­ket­ma­na­ger in­stal­lie­ren

conda update conda

Anaconda-Updates in­stal­lie­ren

conda update anaconda

Ver­si­ons­num­mern der in­stal­lier­ten Keras-Deep-Learning-Pakete über­prü­fen

Keras ist in Python ge­schrie­ben und baut auf einer Vielzahl anderer Python-Module auf. Führen Sie den folgenden Codeblock auf der Kom­man­do­zei­le aus, um die Ver­si­ons­num­mern der meist­ge­nutz­ten Keras Deep-Learning-Pakete an­zu­zei­gen:

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 in­stal­lie­ren

Nachdem wir das System vor­be­rei­tet haben, in­stal­lie­ren wir nun Keras. Führen Sie dafür die folgenden Code­zei­len auf der Kom­man­do­zei­le aus:

Ten­sor­Flow in­stal­lie­ren

pip install tensorflow

Keras in­stal­lie­ren

pip install keras

Wie gehabt, über­prü­fen Sie als nächstes die in­stal­lier­te Keras-Version. Verwenden Sie dafür die folgende Codezeile:

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

Liegt die Keras-In­stal­la­ti­on bereits einige Zeit zurück, sollten Sie nach ver­füg­ba­ren Updates suchen und diese in­stal­lie­ren. Die folgende Codezeile erledigt dies für Sie. Kopieren Sie diese wie gewohnt und führen Sie den Code auf der Kom­man­do­zei­le aus:

pip install --upgrade keras

Beispiel für ein einfaches Keras Deep-Learning

Das Keras-Team ver­öf­fent­licht eine Liste mit Keras-Bei­spie­len unter einer freien Lizenz auf GitHub. Wir werden ex­em­pla­risch das spe­zi­fi­sche Beispiel 'mnist_cnn.py' behandeln. Der Code erzeugt ein „Con­vo­lu­tio­nal Neural Network“ (CNN oder ConvNet) und trainiert es auf die Trai­nings­da­ten.

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 ge­schrie­be­ne Zahl. Der MNIST-Datensatz gilt als Standard für Mus­ter­er­ken­nung und wird mit Keras aus­ge­lie­fert.

Falls Sie neugierig sind, können Sie sich die Trainings- und Testdaten anschauen. Kopieren Sie dazu den folgenden Codeblock und führen Sie ihn auf der Kom­man­do­zei­le aus. Bei jeder Aus­füh­rung wird Ihnen eines der Trai­nings­bil­der 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 trai­nie­ren, die hand­schrift­li­chen Ziffern korrekt zu­zu­ord­nen. Das Trai­nie­ren des Netzwerks ist re­chen­auf­wen­dig. Wundern Sie sich also nicht, wenn ihr Computer or­dent­lich ins Stocken gerät — das ist normal. Sollten Sie ein mobiles Gerät verwenden, achten Sie darauf, dass die Batterie aus­rei­chend 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 Code­zei­len; kopieren Sie diese und führen Sie sie auf der Kom­man­do­zei­le 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

touch keras-test.py

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 Text­do­ku­ment ein. Speichern Sie das Dokument im soeben auf dem Desktop er­stell­ten Ordner „keras-test“ in der bis dato leeren Datei „keras-test.py“. Um das Keras-Beispiel-Skript mithilfe des Python-In­ter­pre­ters aus­zu­füh­ren, geben Sie schließ­lich noch die folgenden Code­zei­len auf der Kom­man­do­zei­le ein:

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

Ihnen sollten nun einige Status-In­for­ma­tio­nen angezeigt werden. Dann beginnt das Skript mit dem Trai­nie­ren des ConvNet, wobei Ihnen der Fort­schritt beim Durch­lau­fen der einzelnen Epochen angezeigt wird. Nach Durch­lau­fen des Skripts ist das ConvNet trainiert und steht für die Klas­si­fi­zie­rung hand­schrift­li­cher Ziffern zur Verfügung.

Hinweis

Benutzen Sie zum Speichern des Codes aus­schließ­lich einen Code-Editor/„Plain Text“-Editor. Kei­nes­falls sollten Sie Text­ver­ar­bei­tungs­soft­ware wie Word, Open­Of­fice oder Libre­Of­fice 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])
Zum Hauptmenü