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”, „JAX” und „PyTorch”. 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 install --cask anaconda
bash

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
bash

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

python --version
bash

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"
bash

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"
bash

Die .bash_profile-Datei laden

source "$HOME/.bash_profile"
bash
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
bash

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

python --version
bash

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
bash

Anaconda-Updates in­stal­lie­ren

conda update anaconda
bash

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
bash

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
bash

Keras in­stal­lie­ren

pip install keras
bash

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__)"
bash

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
bash

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
bash

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/"
bash

Um ein leeres Python-Skript anzulegen

touch keras-test.py
bash

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
bash

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])
python

Reviewer

Zum Hauptmenü