TensorFlow Erweiterte API - Keras

Keras ist eine in Python geschriebene High-Level-API für neuronale Netzwerke, die mit TensorFlow, CNTK oder Theano als Backends ausgeführt werden kann. Keras wurde entwickelt, um benutzerfreundlich, modular und leicht erweiterbar zu sein.

Hauptmerkmale von Keras

  1. Einfach und benutzerfreundlich: bietet eine intuitive und konsistente Schnittstelle, geeignet für schnelles Prototyping
  2. Modular: Neuronale Netzwerkschichten, Verlustfunktionen, Optimierer usw. sind alle als steckbare Module umgesetzt
  3. Leicht erweiterbar: neue Module lassen sich einfach hinzufügen, um neue Forschungsideen auszudrücken
  4. Multi-Backend-Unterstützung: kann nahtlos auf TensorFlow, CNTK oder Theano ausgeführt werden

Keras-Kernkonzepte

1. Modell

Die zentrale Datenstruktur von Keras ist das Modell, eine Möglichkeit, neuronale Netzwerkschichten zu organisieren. Keras bietet zwei Haupttypen von Modellen:

  • Sequential-Modell: linearer Stapel von Schichten
  • Funktionale API: ein gerichteter azyklischer Graph zum Erstellen komplexer Modelle

2. Schicht

Schichten sind die grundlegenden Bausteine von Keras. Jede Schicht empfängt Eingabedaten, führt eine Berechnung durch und gibt das Ergebnis aus. Keras bietet viele vordefinierte Schichten:

  • Kernschichten: Dense, Activation, Dropout usw.
  • Faltungsschichten: Conv2D, MaxPooling2D usw.
  • Rekurrente Schichten: LSTM, GRU usw.
  • Sonstige: Embedding, BatchNormalization usw.

3. Aktivierungsfunktion

Die Aktivierungsfunktion bestimmt die Ausgabe eines Neurons. Zu den häufig verwendeten gehören:

  • ReLU (Rectified Linear Unit)
  • Sigmoid
  • Tanh
  • Softmax (Mehrklassenklassifikation)

Grundlegender Keras-Workflow

1. Das Modell definieren

Beispiel

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

model = Sequential([
    Dense(64, activation='relu', input_shape=(784,)),
    Dense(64, activation='relu'),
    Dense(10, activation='softmax')
])

2. Das Modell kompilieren

Beispiel

model.compile(optimizer='adam',
              loss='categorical_crossentropy',
              metrics=['accuracy'])

3. Das Modell trainieren

Beispiel

model.fit(x_train, y_train,
          epochs=5,
          batch_size=32)

4. Das Modell evaluieren

Beispiel

loss_and_metrics = model.evaluate(x_test, y_test, batch_size=128)

5. Vorhersagen treffen

Beispiel

classes = model.predict(x_test, batch_size=128)

Detaillierte Erklärung gängiger Keras-Schichten

1. Dense vollständig verbundene Schicht

Beispiel

Dense(units,
      activation=None,
      use_bias=True,
      kernel_initializer='glorot_uniform',
      bias_initializer='zeros')
  • units: positive ganze Zahl, Dimension des Ausgaberaums
  • activation: Aktivierungsfunktion
  • use_bias: ob ein Bias-Vektor verwendet werden soll
  • kernel_initializer: Initialisierer für die Gewichtsmatrix
  • bias_initializer: Initialisierer für den Bias-Vektor

2. Conv2D 2D-Faltungsschicht

Beispiel

Conv2D(Filter,
       kernel_size,
       strides=(1, 1),
       padding='valid',
       activation=None)
  • filters: Anzahl der Faltungskerne
  • kernel_size: Größe des Faltungskerns
  • strides: Schrittweite der Faltung
  • padding: Padding-Modus ('valid' oder 'same')

3. LSTM-Schicht (Long Short-Term Memory)

Beispiel

LSTM(units,
     activation='tanh',
     recurrent_activation='hard_sigmoid',
     return_sequences=False)
  • units: positive ganze Zahl, Dimension des Ausgaberaums
  • activation: Aktivierungsfunktion
  • recurrent_activation: Aktivierungsfunktion für den rekurrenten Schritt
  • return_sequences: ob die vollständige Sequenz zurückgegeben werden soll

Keras Modell speichern und laden

1. Das gesamte Modell speichern

Beispiel

model.save('my_model.h5')  # Architektur, Gewichte und Trainingskonfiguration speichern

2. Nur die Architektur speichern

Beispiel

json_string = model.to_json()  # Als JSON speichern
yaml_string = model.to_yaml()  # Als YAML speichern

3. Nur die Gewichte speichern

Beispiel

model.save_weights('my_model_weights.h5')

4. Modell laden

Beispiel

from tensorflow.keras.models import load_model

model = load_model('my_model.h5')  # Das vollständige Modell laden

Keras-Callback-Funktionen

Callback-Funktionen sind Funktionen, die an bestimmten Punkten während des Trainings aufgerufen werden und für Folgendes verwendet werden:

  • Modell-Checkpointing
  • Early Stopping
  • Anpassung der Lernrate
  • Logging usw.

Gängige Callback-Funktionen

Beispiel

from tensorflow.keras.callbacks import ModelCheckpoint, EarlyStopping

callbacks = [
    ModelCheckpoint(filepath='best_model.h5', monitor='val_loss', save_best_only=True),
    EarlyStopping(monitor='val_loss', patience=3)
]

model.fit(x_train, y_train,
          epochs=10,
          callbacks=callbacks,
          validation_data=(x_val, y_val))

Praktisches Keras-Beispiel: MNIST-Erkennung handschriftlicher Ziffern

Beispiel

from tensorflow.keras.datasets import mnist
from tensorflow.keras.models import Sequential
from tensorflow.keras.layers import Dense, Dropout, Flatten
from tensorflow.keras.layers import Conv2D, MaxPooling2D
from tensorflow.keras.utils import to_categorical

# Daten laden
(x_train, y_train), (x_test, y_test) = mnist.load_data()

# Daten vorverarbeiten
x_train = x_train.reshape(60000, 28, 28, 1).astype('float32') / 255
x_test = x_test.reshape(10000, 28, 28, 1).astype('float32') / 255
y_train = to_categorical(y_train, 10)
y_test = to_categorical(y_test, 10)

# Modell erstellen
model = Sequential([
    Conv2D(32, kernel_size=(3, 3), activation='relu', input_shape=(28, 28, 1)),
    Conv2D(64, (3, 3), activation='relu'),
    MaxPooling2D(pool_size=(2, 2)),
    Dropout(0.25),
    Flatten(),
    Dense(128, activation='relu'),
    Dropout(0.5),
    Dense(10, activation='softmax')
])

# Modell kompilieren
model.compile(loss='categorical_crossentropy',
              optimizer='adam',
              metrics=['accuracy'])

# Modell trainieren
model.fit(x_train, y_train,
          batch_size=128,
          epochs=12,
          verbose=1,
          validation_data=(x_test, y_test))

# Modell bewerten
score = model.evaluate(x_test, y_test, verbose=0)
print('Testverlust:', score[0])
print('Testgenauigkeit:', score[1])

Keras Fortgeschrittene Tipps

1. Benutzerdefinierte Layer

Beispiel

from tensorflow.keras import backend as K
from tensorflow.keras.layers import Layer

class MyLayer(Layer):
    def __init__(self, output_dim, **kwargs):
        self.output_dim = output_dim
        super(MyLayer, self).__init__(**kwargs)
   
    def build(self, input_shape):
        self.kernel = self.add_weight(name='kernel',
                                     shape=(input_shape[1], self.output_dim),
                                     initializer='uniform',
                                     trainable=True)
        super(MyLayer, self).build(input_shape)
   
    def call(self, x):
        return K.dot(x, self.kernel)
   
    def compute_output_shape(self, input_shape):
        return (input_shape[0], self.output_dim)

2. Benutzerdefinierte Verlustfunktion

Beispiel

from tensorflow.keras import backend as K

def custom_loss(y_true, y_pred):
    return K.mean(K.square(y_pred - y_true), axis=-1)

model.compile(optimizer='adam', loss=custom_loss)

3. Lernratenplanung

Beispiel

from tensorflow.keras.callbacks import LearningRateScheduler

def scheduler(epoch, lr):
    if epoch < 10:
        return lr
    else:
        return lr * K.exp(-0.1)

callback = LearningRateScheduler(scheduler)
model.fit(x_train, y_train, epochs=15, callbacks=[callback])

Häufige Keras-Probleme und Lösungen

1. Overfitting-Problem

  • Dropout-Schichten hinzufügen
  • L1/L2-Regularisierung verwenden
  • Mehr Trainingsdaten hinzufügen
  • Datenaugmentation verwenden

2. Langsame Trainingsgeschwindigkeit

  • Batch-Größe erhöhen
  • Ein einfacheres Modell verwenden
  • Probieren Sie verschiedene Optimierer aus
  • GPU-Beschleunigung verwenden

3. Verschwindende/explodierende Gradienten

  • BatchNormalization verwenden
  • Geeignete Gewichtsinitialisierung verwenden
  • Nicht sättigende Aktivierungsfunktionen wie ReLU verwenden
  • Gradienten-Clipping verwenden

Zusammenfassung

Als High-Level-API von TensorFlow bietet Keras eine einfache und intuitive Schnittstelle zum Erstellen und Trainieren von Deep-Learning-Modellen. Nach der Lektüre dieses Artikels sollten Sie Folgendes beherrschen:

  1. Keras-Kernkonzepte und grundlegender Workflow
  2. Verwendung gängiger Layer
  3. Speichern und Laden von Modellen
  4. Verwendung von Callback-Funktionen
  5. Anwendungsbeispiele in realen Projekten
  6. Fortgeschrittene Tipps und Lösungen für häufige Probleme

Die Stärke von Keras liegt in seiner Flexibilität und Benutzerfreundlichkeit, wodurch die Entwicklung von Deep-Learning-Modellen effizienter wird. Mit zunehmender Praxis werden Sie komplexere neuronale Netzwerkmodelle erstellen können, um verschiedene reale Probleme zu lösen.

Weitere Erweiterungen