Neuronale Netze mit Keras: Überblick

TensorFlow und Keras

TensorFlow

TensorFlow:

  • Library für neuronale Netze, die von Google entwickelt wird
  • basiert auf Tensoren (multidimensionalen Arrays) und Array-Multiplikation

Keras

Keras: Python API für TensorFlow, wurde mittlerweile in TensorFlow integriert

TensorFlow and Keras

äquivalente Imports (seit TensorFlow 2.4):

import keras

from tensorflow import keras

Beispiel: Iris-Klassifizierung in Keras

Überwachtes Lernen in Keras

Schritte:

  • Erstellen eines Input-Arrays x und eines Ziel-Arrays y
  • Erstellen eines Modells aus verschiedenen Layern (z.B. Preprocessing-Layer, Neuronen-Layer, ...)
  • Kompilieren via model.compile() und "Lernen" via model.fit(x, y)
  • Vorhersagen weiterer Ergebnisse via model.predict(...)

Beispiel

Laden von Daten:

from sklearn import datasets

iris = datasets.load_iris()

x = iris.data
y = iris.target

Beispiel

Trainieren des Netzwerks:

from tensorflow import keras

model = keras.Sequential([
    keras.layers.Dense(8),
    keras.layers.Activation("relu"),
    keras.layers.Dense(3),
    keras.layers.Activation("softmax")
])
model.compile(
    loss="sparse_categorical_crossentropy",
    metrics=["accuracy"]
)
model.fit(x, y, epochs=300, validation_split=0.1)

Beispiel

Anwenden der Klassifikation auf neue Daten:

test_data = [
    [5.3, 3.4, 1.9, 0.6],
    [6.0, 3.0, 4.7, 1.5],
    [6.5, 3.1, 5.0, 1.7]
]

y_pred = model.predict(test_data)
# [[0.9 0.1 0. ]
#  [0.  0.8 0.2]
#  [0.  0.7 0.3]]

Neuronale Netzwerke

Neuronale Netzwerke

Machine Learning Verfahren, das in etwa die Interaktion von Neuronen im Gehirn nachahmt

Neuronale Netzwerke

image/svg+xml
Diagrammm eines neuronalen Netzwerks mit zwei Inputs, fünf Neuronen in der Zwischenschicht und einem Output (Quelle: Dake, Mysid via Wikimedia Commons / CC BY)

Neuronen

Modell eines einzelnen Neurons mit mehreren Inputs und einem Output

Aktivierungsfunktionen

  • ReLU (Rectified Linear Unit)
  • Softmax - oft im letzen Layer für Klassifikation verwendet
  • Sigmoid - oft im letzen Layer für "Tagging" verwendet (Tags können sich überlappen)

Ressource

Layer

Arten von Layern

  • Aktivierungslayer (Outputs: einzelnes Anwenden einer Aktivierungsfunktion auf jeden Input)
  • Dense Layer (Outputs: individuelle gewichtete Summe aller Inputs)
  • Convolution Layer (Outputs: gewichtete Summe benachbarter Inputs)
  • Pooling Layer (Outputs: z.B. Maximum oder Durchschnitt benachbarter Inputs)
  • Dropout Layer (für individuelle Outputs: entweder gleich dem Input oder 0)
  • Normalisierungslayer (z.B. um das Mittel nahe bei 0 und die Standardabweichung nahe bei 1 zu behalten)

manche Layer (z.B. Dense, Convolution) können optional eine eingebaute (nachgeschaltete) Aktivierungsfunktion haben

Layer in Keras

  • Activation
  • Dense
  • Conv1D, Conv2D, Conv3D
  • MaxPooling1D, MaxPooling2D, MaxPooling3D
  • Dropout
  • BatchNormalization

Sequenzielles und funktionales API

Sequenzielles API

sequenzielles API (erlaubt nur lineare Verarbeitung - jeder Layer hat einen Input und einen Output):

model = keras.models.Sequential([
    keras.layers.Dense(256, activation="relu"),
    keras.layers.Dense(128, activation="relu"),
    keras.layers.Dense(10, activation="softmax"),
])

oder

model = keras.models.Sequential()
model.add(keras.layers.Dense(256, activation="relu"))
model.add(keras.layers.Dense(128, activation="relu"))
model.add(keras.layers.Dense(10, activation="softmax"))

Funktionales API

Funktionales API (erlaubt komplexere Verarbeitung):

inputs = keras.layers.Input(shape=[28, 28])
x = keras.layers.Dense(256, activation="relu")(inputs)
x = keras.layers.Dense(128, activation="relu")(x)
outputs = keras.layers.Dense(10, activation="softmax")(x)
model = keras.Model(inputs, outputs)

Beispiel: MNIST Ziffernklassifikation

Daten laden

Daten laden:

(
    (x_train, y_train),
    (x_test, y_test),
) = keras.datasets.mnist.load_data()

Erstellen eines Modells

sequenzielles API:

model = keras.Sequential([
    keras.layers.Flatten(input_shape=(28, 28)),
    keras.layers.Dense(128, activation="relu"),
    keras.layers.Dense(10, activation="softmax"),
])

funktionales API:

inputs = keras.layers.Input(shape=(28, 28))
x = keras.layers.Flatten()(inputs)
x = keras.layers.Dense(128, activation="relu")(x)
outputs = keras.layers.Dense(10, activation="softmax")(x)
model = keras.Model(inputs, outputs)

Kompilierung und Training

model.compile(
    loss="sparse_categorical_crossentropy",
    metrics=["accuracy"],
)
model.fit(x_train, y_train, epochs=15, validation_split=0.1)

Verbesserungen

Hinzufügen eines Rescaling-Layers:

keras.layers.Rescaling(1/255)

Speichern und Laden

Speichern eines trainierten Modells:

model.save("path/to/folder")

Laden eines Modells:

model = keras.models.load_model("path/to/folder")

Inspizieren des Iris-Klassifikationsnetzes

Erstellen und Trainieren des Netzes

from sklearn import datasets
from sklearn import model_selection

iris = datasets.load_iris()

x = iris.data
y = iris.target

from tensorflow import keras

model = keras.Sequential([
    keras.layers.Dense(8),
    keras.layers.Activation("relu"),
    keras.layers.Dense(3),
    keras.layers.Activation("softmax")
])
model.compile(
    loss="sparse_categorical_crossentropy",
    metrics=["accuracy"]
)
model.fit(x, y, epochs=300, validation_split=0.1, verbose=False)

Inspizieren des Netzes

layer_0 = model.get_layer(index=0)
layer_1 = model.get_layer(index=1)
layer_2 = model.get_layer(index=2)
layer_3 = model.get_layer(index=3)

Inspizieren des Netzes

# input values for an iris setosa flower
values_0 = np.array([[5.1, 3.5, 1.4, 0.2]])

Inspizieren des Netzes

Werte nach layer_0 (dense Layer):

values_1 = layer_0(values_0)

was im Hintergrund geschieht (mögliche Implementierung in numpy):

values_1 = values_0 @ layer_0.kernel + layer_0.bias

(Matrix-Multiplikation und Addition)

Inspizieren des Netzes

Werte nach layer_1 (RELU Aktivierungslayer):

values_2 = layer_1(values_1)

was im Hintergrund geschieht (mögliche Implementierung in numpy):

values_2 = np.maximum(values_1, 0)

(Ersetzen von negativen Werten durch 0)

Inspizieren des Netzes

Werte nach layer_2 (dense Layer):

values_3 = layer_2(values_2)

was im Hintergrund geschieht (mögliche Implementierung in numpy):

values_3 = values_2 @ layer_2.kernel + layer_2.bias

Inspizieren des Netzes

Werte nach layer_3 (Softmax Aktivierungslayer):

values_4 = layer_3(values_3)

was im Hintergrund geschieht (mögliche Implementierung in Python):

from scipy.special import softmax
# from sklearn.utils.extmath import softmax

values_4 = softmax(values_3)

Inspizieren des Netzes

Funktion, die Werte voraussagt und Zwischenwerte ausgibt:

def predict_and_log(values_0):
    print(values_0, end="\n\n")
    values_1 = layer_0(values_0)
    print(values_1, end="\n\n")
    values_2 = layer_1(values_1)
    print(values_2, end="\n\n")
    values_3 = layer_2(values_2)
    print(values_3, end="\n\n")
    values_4 = layer_3(values_3)
    print(values_4, end="\n\n")

Inspizieren des Netzes

predict_and_log(np.array([[5.1, 3.5, 1.4, 0.2]]))
predict_and_log(np.array([[7.0, 3.2, 4.7, 1.4]]))
predict_and_log(np.array([[6.3, 3.3, 6.0, 2.5]]))

Beispiel: Werte von Häusern in Kalifornien

Beispiel: Werte von Häusern in Kalifornien

zum Vergleich: Lineare Regression - http://www.clungu.com/scikit-learn/tutorial/Scikit-learn/

Beispiel: Werte von Häusern in Kalifornien

Laden und Vorbereiten des Datensatzes:

from sklearn import datasets
from sklearn import utils
from sklearn import model_selection
from sklearn import preprocessing

housing = datasets.fetch_california_housing()

scaler = preprocessing.StandardScaler().fit(housing.data)

x = scaler.transform(housing.data)
y = housing.target

Beispiel: Werte von Häusern in Kalifornien

Modell erstellen und trainieren:

from keras.models import Sequential
from tensorflow.keras import layers

model = Sequential([
    layers.Dense(16, activation="relu"),
    layers.Dropout(0.1),
    layers.Dense(16, activation="relu"),
    layers.Dropout(0.1),
    layers.Dense(1, activation="linear"),
])
model.compile(loss="mean_squared_error")

model.fit(x, y, epochs=100, validation_split=0.25, verbose=1)

Beispiel: Werte von Häusern in Kalifornien

Evaluieren:

model.evaluate(x, y)

Beispiel: Bild-Klassifizierung: Katze oder Hund

Beispiel: Bild-Klassifizierung: Katze oder Hund

see https://keras.io/examples/vision/image_classification_from_scratch/