Keras

aus Wikipedia, der freien Enzyklopädie
Zur Navigation springen Zur Suche springen
Keras

Keras Logo.jpg
Basisdaten

Maintainer Community-Projekt, initiiert durch François Chollet
Entwickler François Chollet
Aktuelle Version 2.3.1[1]
(7. Oktober 2019)
Betriebssystem Plattformunabhängigkeit
Programmiersprache Python
Kategorie neuronale Netze
Lizenz MIT-Lizenz
Keras.io

Keras ist eine Open Source Deep-Learning-Bibliothek, geschrieben in Python. Sie wurde von François Chollet initiiert und erstmals am 28. März 2015 veröffentlicht.[2] Keras bietet eine einheitliche Schnittstelle für verschiedene Backends, darunter TensorFlow, Microsoft Cognitive Toolkit (vormals CNTK) und Theano. Das Ziel von Keras ist es, die Anwendung dieser Bibliotheken so einsteiger- und nutzerfreundlich wie möglich zu machen.[3]

Seit dem Release von TensorFlow 1.4 ist Keras Teil der Tensorflow Core API, jedoch wird Keras als eigenständige Bibliothek weitergeführt, da es laut François Chollet nicht als Schnittstelle für Tensorflow, sondern als Schnittstelle für viele Bibliotheken gedacht ist.[4][5]

Beispiel[Bearbeiten | Quelltext bearbeiten]

Das folgende Beispiel soll die grundlegende Funktionsweise darstellen. Darin wird einem neuronalen Netzwerk mithilfe von Keras die Funktion eines Exklusiv-Oder-Gatters beigebracht:

 1 # Über TensorFlow laden
 2 #
 3 # from tensorflow.keras.layers import Dense
 4 # from tensorflow.keras.models import Sequential
 5 #
 6 # oder
 7 #
 8 # Aus Keras direkt laden
 9 from keras.layers import Dense
10 from keras.models import Sequential
11 
12 # Numpy laden und festlegen des Zufalls-Startwertes
13 import numpy as np
14 np.random.seed(1337)
15 
16 # Matplotlib zur grafischen Darstellung laden
17 import matplotlib.pyplot as plt
18 
19 # Daten in Arrays speichern
20 eingangswerte = np.array([[0, 0], [0, 1], [1, 0], [1, 1]])
21 ausgangswerte = np.array([[0], [1], [1], [0]])
22 
23 # Erstellt das Model mit 2 Eingangsnodes, 2 Mittelnodes und einer Ausgangsnode
24 num_inner = 2
25 
26 model = Sequential()
27 model.add(Dense(num_inner, input_dim=2, activation='sigmoid'))
28 model.add(Dense(1))
29 
30 # Kompiliert das Model, damit es spaeter verwendet werden kann
31 model.compile(loss='mean_squared_error',
32               optimizer='adam',
33               metrics=['accuracy'])
34 
35 # Trainiert das Model mit den Eingangs-
36 # und den entsprechenden Ausgangswerten fuer 10000 Epochen
37 model.fit(x=eingangswerte, y=ausgangswerte, epochs=10000, verbose=0)
38 
39 # Testet die Eingangsdaten und schreibt die Ergebnisse in die Konsole
40 print(model.predict(eingangswerte))

Als Ausgabe erhält man folgendes:

1 [[  8.34465027e-07]  # Eingang 0 und 0, zu erwartender Ausgang 0
2  [  9.99996364e-01]  # Eingang 0 und 1, zu erwartender Ausgang 1
3  [  9.99996185e-01]  # Eingang 1 und 0, zu erwartender Ausgang 1
4  [  5.48362732e-06]] # Eingang 1 und 1, zu erwartender Ausgang 0

Das Modell ist mit zwei Eingangsknoten, zwei Mittelknoten und einem Ausgangsknoten sehr einfach. Es braucht jedoch 10000 Epochen, um zu guten Ergebnissen zu kommen. Eine andere Aktivierungsfunktion, hier tanh kann die Anzahl der Epochen auf 1000 reduzieren:

1 # Erstellt das Model mit 2 Eingangsnodes, 32 Mittelnodes und einer Ausgangsnode
2 model = Sequential()
3 model.add(Dense(16, input_dim=2, activation='tanh'))
4 model.add(Dense(1, activation='tanh'))

Als Ausgabe erhält man folgendes:

1 [[0.00540294]
2  [0.94025123]
3  [0.93624824]
4  [0.00820918]]

Die Modellanalyse kann direkt mit numpy und matplotlib erfolgen. In diesem Fall werden dem Modell gerasterte Eingabedaten übergeben und die Ausgabe grafisch zweidimensional in einem Contourplot dargestellt. Ebenso werden die Grenzen der Klassifizierung als Linien und die diskreten Eingabewerte als Punkte dargestellt:

 1 # Bereitet die grafische Ausgabe mittels contourf vor
 2 # und rastert die Eingabewerte fuer das Modell
 3 x = np.linspace(-0.25, 1.25, 100)
 4 (X1_raster, X2_raster) = np.meshgrid(x, x)
 5 X1_vektor = X1_raster.flatten()
 6 X2_vektor = X2_raster.flatten()
 7 
 8 # Nutzt die gerasterten Eingabewerte und erzeugt Ausgabewerte
 9 eingangswerte_grafik = np.vstack((X1_vektor, X2_vektor)).T
10 ausgangswerte_grafik = model.predict(eingangswerte_grafik).reshape(X1_raster.shape)
11 
12 # Fragt die Gewichte der Verbindungen und die Bias-Daten ab
13 (gewichte, bias) = model.layers[0].get_weights()
14 
15 # Contourplot der gerasterten Ausgangswerte in leicht vergroessertem
16 # Bereich und Legende
17 plt.contourf(X1_raster, X2_raster, ausgangswerte_grafik, 100)
18 plt.xlim(-0.25, 1.25)
19 plt.ylim(-0.25, 1.25)
20 plt.xlabel("Eingabewert $x_1$")
21 plt.ylabel("Eingabewert $x_2$")
22 plt.colorbar()
23 
24 # Eintragen der Eingangsdaten in die Grafik
25 plt.scatter(np.array([0, 0, 1, 1]), np.array([0, 1, 0, 1]), color="red")
26 
27 # Plot der Klassifizierungs-"Begrenzungslinien" der Aktivierungsfunktionen
28 for i in range(num_inner):
29     plt.plot(x,
30              -gewichte[0, i]/gewichte[1, i]*x
31              - bias[i]/gewichte[1, i], color="black")
32 plt.show()

Die Darstellungen für beide Varianten des Modells sehen wie folgt aus (links erste Variante, 10000 Epochen; rechts zweite Variante, 500 Epochen):

Keras model inner2 epochs10000.svg Keras model inner32 epochs500.svg

Literatur[Bearbeiten | Quelltext bearbeiten]

  • François Chollet: Deep Learning mit Python und Keras: Das Praxis-Handbuch vom Entwickler der Keras-Bibliothek. mitp, 2018, ISBN 978-3-95845-838-3.

Weblinks[Bearbeiten | Quelltext bearbeiten]

Einzelnachweise[Bearbeiten | Quelltext bearbeiten]

  1. Release 2.3.1. 7. Oktober 2019 (abgerufen am 8. Oktober 2019).
  2. Add initial public version of Keras. 28. März 2015, abgerufen am 9. Juli 2018 (englisch).
  3. Keras backends. 4. Januar 2018, abgerufen am 9. Juli 2018 (englisch).
  4. Release TensorFlow 1.4.0. 2. November 2017, abgerufen am 9. Juli 2018 (englisch).
  5. Good news, Tensorflow chooses Keras! #5050. 16. Januar 2017, abgerufen am 9. Juli 2018 (englisch).