Machine-Learning-Funktionen mit TensorFlow integrieren

TensorFlow und Keras: Architektur und Funktionsweise

TensorFlow arbeitet mit Datenflussgraphen (Data Flow Graphs), die mathematische Operationen in Form von Knoten und Kanten darstellen. Diese Graphen bestimmen, wie Daten verarbeitet und durch das Netzwerk geleitet werden. Die Grundeinheit von TensorFlow ist der Tensor, ein multidimensionales Array, das große Datenmengen verarbeiten kann. Keras ist eine High-Level-API, die auf TensorFlow aufbaut und neuronale Netze erstellen kann. Es ermöglicht die Modellierung über drei Hauptmethoden:

• Sequential API: Geeignet für einfache Modelle, die Schicht für Schicht aufgebaut werden.
• Funktionale API: Ermöglicht komplexere Architekturen mit mehreren Ein- und Ausgängen.
• Model Subclassing: Erlaubt volle Flexibilität für individuelle Modellarchitekturen.

Keras wurde ursprünglich als hochgradig abstrahierte API konzipiert, die mit verschiedenen Backend-Engines wie TensorFlow, Theano oder CNTK arbeiten kann. Heute ist Keras vollständig in TensorFlow integriert und bildet eine benutzerfreundliche Schnittstelle für das maschinelle Lernen. Durch seine einfache Syntax erlaubt es schnelle Modellprototypisierung und experimentelle Anpassungen mit wenigen Codezeilen.

Ein wichtiger Bestandteil des Deep Learnings ist die Organisation und Vorverarbeitung der Daten. Dabei werden Eingabedaten häufig in Form von NumPy-Arrays oder TensorFlow-Tensoren strukturiert. Eine bewährte Technik zur Verbesserung der Modelleffizienz ist die Normalisierung der Daten auf Werte zwischen 0 und 1. Hier ein Beispiel:

from sklearn.preprocessing import MinMaxScaler
import numpy as np
scaler = MinMaxScaler(feature_range=(0, 1))
data = np.array([13, 100, 50, 75]).reshape(-1, 1)
norm_data = scaler.fit_transform(data)

Dabei kommen drei Bereiche zum Einsatz:

• Data Preprocessing. Hier werden die Daten aufbereitet, um sie dem Modell zur Verfügung zu stellen. Dazu gehören das Entfernen von Duplikaten, Feature-Skalierung, Standardisierung und andere Vorverarbeitungsschritte.
• Modellerstellung. In diesem Schritt wird das Modell mit verschiedenen Algorithmen entwickelt und konfiguriert.
• Modelltraining und Evaluierung. Das erstellte Modell wird trainiert und anschließend evaluiert, um seine Genauigkeit zu überprüfen und Optimierungen vorzunehmen.

Bevor TensorFlow und Keras in ein Softwareprojekt integriert werden können, müssen sie installiert und die Umgebung entsprechend vorbereitet werden.

TensorFlow lässt sich unter anderem mit pip, einem Package Installer und Paketverwaltungsprogramm für Python-Pakete installieren:

pip install tensorflow

Falls GPU-Unterstützung gewünscht ist, muss TensorFlow CUDA- und cuDNN-kompatibel sein. Die GPU-Verfügbarkeit kann mit folgendem Kommando überprüft werden:

import tensorflow as tf
print("GPU verfügbar:" tf.config.list_physical_devices('GPU'))

Da Keras vollständig in TensorFlow integriert ist, wird die Installation automatisch mit TensorFlow durchgeführt.

Verwendung vortrainierter Modelle mit Keras

Ein einfaches neuronales Netzwerk in Keras wird mit wenigen Codezeilen definiert:

from tensorflow.keras.models import Sequential
from tensorflow.keras.layers import Dense
model = Sequential([
    Dense(16, activation='relu', input_shape=(1,)),
    Dense(32, activation='relu'),
    Dense(2, activation='softmax')
])

Dieses Modell besteht aus drei Schichten: zwei verdeckten Dense-Layern mit ReLU-Aktivierung und einer Ausgangsschicht mit Softmax-Funktion für Klassifikationsaufgaben. Die Verwendung vortrainierter Modelle spart Zeit und Ressourcen, da diese bereits optimiert wurden.

Wenn eine Feinabstimmung erforderlich ist, können einige Schichten eingefroren und andere Schichten trainiert werden. Um Bilddaten in einem Softwareprojekt verwenden zu können, müssen diese strukturiert und aufbereitet werden. Ein häufig verwendeter Ansatz ist die Organisation der Daten in Trainings-, Validierungs- und Testsets:

from tensorflow.keras.preprocessing.image import ImageDataGenerator
train_datagen = ImageDataGenerator(rescale=1./255)
train_generator = train_datagen.flow_from_directory('data/train', target_size=(224,224))

Ein einfaches neuronales Netz kann mit der Sequential API von Keras erstellt werden:

from tensorflow.keras.models import Sequential
from tensorflow.keras.layers import Dense
model = Sequential([.
    Dense(128, activation='relu', input_shape=(784,)),
    Dense(10, activation='softmax')
])
model.compile(optimizer='adam', loss='sparse_categorical_crossentropy', metrics=['accuracy'])

Training und Validierung

Nachdem das Modell definiert wurde, muss es kompiliert und trainiert werden. Dies geschieht mit der compile- und fit-Methode:

model.compile(optimizer='adam', loss='sparse_categorical_crossentropy', metrics=['accuracy'])
model.fit(train_samples, train_labels, batch_size=10, epochs=30, validation_split=0.1)

Die Methode validation_split=0.1 sorgt dafür, dass zehn Prozent der Trainingsdaten für die Validierung genutzt werden. So lässt sich überprüfen, ob das Modell übertrainiert oder generalisierungsfähig ist.

Ein weiteres Beispiel ist:

model.fit(x_train, y_train, epochs=10, validation_split=0.2, batch_size=32)

Um Overfitting zu vermeiden, werden 20 Prozent der Trainingsdaten für die Validierung verwendet. Nach dem Training kann das Modell auf unbekannte Daten angewendet werden:

import numpy as np
from tensorflow.keras.preprocessing import image
img = image.load_img('data/test/sample.jpg', target_size=(224, 224))
img_array = image.img_to_array(img)
img_array = np.expand_dims(img_array, axis=0)
img_array /= 255.

Das Modell gibt eine Vorhersage für das Bild aus:

predictions = model.predict(img_array)
print(predictions)

Nach dem Training kann das Modell zur Vorhersage genutzt werden:

predictions = model.predict(test_samples)

Um die Leistung zu bewerten, wird oft eine Konfusionsmatrix eingesetzt, die die tatsächlichen versus vorhergesagte Klassifikationen darstellt:

from sklearn.metrics import confusion_matrix
import matplotlib.pyplot as plt
cm = confusion_matrix(test_labels, np.argmax(predictions, axis=1))
plt.imshow(cm, cmap='Blues')
plt.xlabel('Predicted Labels')
plt.ylabel('True Labels')
plt.show()

Speichern und Laden von Modellen

Keras erlaubt es, trainierte Modelle zu speichern und später wieder zu laden:

model.save("my_model.h5")

Das Laden eines gespeicherten Modells erfolgt mit:

from tensorflow.keras.models import load_model
new_model = load_model("my_model.h5")

Alternativ kann nur die Modellarchitektur gespeichert werden:

json_string = model.to_json()

Ein späteres Laden erfolgt mit:

from tensorflow.keras.models import model_from_json
new_model = model_from_json(json_string)

Zusätzlich können auch nur die Gewichte eines Modells gespeichert und geladen werden:

model.save_weights("my_model_weights.h5")

Das Wiederherstellen erfolgt mit:

new_model.load_weights("my_model_weights.h5")

Nach dem Laden können die Gewichte des neuen Modells überprüft werden:

print(new_model.get_weights())