ML-Hilfsmittel und die Bauteile maschineller Intelligenz

Machine-Learning-Frameworks und -Dienste

< zurück

Seite: 2/3

TensorFlow

Verwaltete Dienste wie AWS SageMaker unterstützen die Bereitstellung von ML-Frameworks mit Cloud-nativer Skalierbarkeit. In der Abbildung: Zeitreihenvisualisierung in TensorBoard, einem beliebten Toolkit für PyTorch und TensorFlow, im Rahmen von SageMaker.(Bild:  AWS)
Verwaltete Dienste wie AWS SageMaker unterstützen die Bereitstellung von ML-Frameworks mit Cloud-nativer Skalierbarkeit. In der Abbildung: Zeitreihenvisualisierung in TensorBoard, einem beliebten Toolkit für PyTorch und TensorFlow, im Rahmen von SageMaker.
(Bild: AWS)

TensorFlow ist ein quelloffenes ML-Framework von Google mit einer beispiellosen Erweiterbarkeit. Es findet Anwendung in einem breiten Spektrum von maschinellen Lernmodellen in nahezu beliebigem Umfang. Es skaliert von einer einzelnen CPU oder GPU bis hin zu Infrastrukturen im Cloud-Maßstab.

Bibliotheken wie TF-Slim zum Aufbau von neuronalen Netzwerken oder TFX für Produktionsworkflows verleihen TensorFlow eine beachtliche Vielseitigkeit. Sie umfasst Aufgaben der Bild- und Spracherkennung bis hin zur prädiktiven Analytik für die Vorhersage von Ereignissen wie Maschinenausfallzeiten basierend z.B. auf Sensordaten.

Eine Zeitreihe von Sensordaten, die verschiedene Messwerte wie Temperatur, Druck oder Vibration umfasst, muss nach dem Einlesen die sogenannte Normalisierung durchlaufen, um das Training des Modells zu ermöglichen, zum Beispiel hier in Python:

# Daten einlesen
data = np.load('sensor_data.npy')
# Daten normalisieren
max_value = np.max(data)
min_value = np.min(data)
scaled_data = (data - min_value) / (max_value - min_value)

Für die Verarbeitung von Zeitreihendaten bietet sich ein neuronales Netzwerk mit LSTM-Schichten (kurz für Long Short-Term Memory) an, eine spezielle Art von rekurrenten neuronalen Netzwerken (RNNs). Diese Modelle sind darauf ausgelegt, langfristige Abhängigkeiten in sequenziellen Daten zu erfassen – also beispielsweise auch Zusammenhänge zwischen fortschreitender Materialermüdung (gemessen an Metriken wie Hitze- oder Lärmentwicklung oder Vibrationen) und der Qualitätsminderung der resultierenden Erzeugnisse. Am Beispiel einer Python-Implementierung:

model = Sequential([
   LSTM(50, return_sequences=True, input_shape=(scaled_data.shape[1], scaled_data.shape[2])),
   Dropout(0.2),
   LSTM(50, return_sequences=False),
   Dropout(0.2),
   Dense(1, activation='sigmoid')
])

Als Nächstes muss man das Modell kompilieren:

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

Erst dann kann man es trainieren. In dieser Phase müssen die Daten bereits in einem geeigneten Format vorliegen. Für die Eingabe in ein LSTM sollten sie in 3D-Numpy-Arrays organisiert sein (Samples, Time Steps, Features). Die Aufteilung der vorliegenden Daten in Trainings- und Testdaten ist in nur wenigen Zeilen Python erledigt:

train_samples = int(len(scaled_data) * 0.8)
train_data = scaled_data[:train_samples]
test_data = scaled_data[train_samples:]
model.fit(train_data, epochs=10, batch_size=64, validation_data=test_data)

Anhand der Validierungsdaten erfolgt anschließend die Prüfung des Modells, zum Beispiel so:

test_loss, test_accuracy = model.evaluate(test_data)
print("Testgenauigkeit:", test_accuracy)

Eine TensorBoard-Visualisierung eines TensorFlow-Graphen in AWS SageMaker.(Bild:  AWS)
Eine TensorBoard-Visualisierung eines TensorFlow-Graphen in AWS SageMaker.
(Bild: AWS)

Dem TensorFlow-Framework liegt eine graphenbasierte Architektur zugrunde. Die Knoten in einem TensorFlow-Berechnungsgraphen repräsentieren die Rechenoperationen (z. B. Matrixmultiplikation, Aktivierungsfunktionen usw.); die Kanten bilden die Datenflüsse nach. Dieser Ansatz erleichtert die visuelle Darstellung der funktionalen Bausteine und Abhängigkeiten. Die graphenbasierte Architektur erleichtert auch die Parallelisierung und Optimierung von Berechnungen. Allerdings kann sie in einigen Fällen die Ausführung verlangsamen, insbesondere wenn der Graph sehr groß ist.

In einem Betriebsmodus namens „Eager Execution“ führt TensorFlow die Berechnungen sofort aus, ohne einen statischen Berechnungsgraphen zu erstellen. Der Verzicht auf den Aufbau von Graphen erlaubt ein höheres Maß an Interaktion und ein verbessertes Debugging-Erlebnis. TensorFlow fühlt sich dann an wie leichtgewichtiger Python-Code, nicht wie ein massives ML-Framework.

TensorFlow unterstützt die Ausführung leistungsoptimierter, komprimierter Modelle auf mobilen und eingebetteten Plattformen mit TensorFlow Lite. Mit TensorFlow.js können Machine-Learning-Modelle direkt im Browser laufen.

Googles Plattform Kaggle.com ist eine beliebte Anlaufstelle für Machine-Learning-Developer und Data Scientists.(Bild:  Martins & Kobylinska / Google)
Googles Plattform Kaggle.com ist eine beliebte Anlaufstelle für Machine-Learning-Developer und Data Scientists.
(Bild: Martins & Kobylinska / Google)

TensorFlow Hub, das offizielle Repository für wiederverwendbare Module und vorab trainierte Lernmodelle, ging kürzlich in Kaggle auf. Diese Plattform bietet eine breitere Sammlung von Lernmodellen und ist nicht an ein bestimmtes Framework gebunden. Sowohl Unternehmen und Forschungseinrichtungen als auch Einzelpersonen können ihre Notebooks, Datasets, Lernmodelle und Kaggle-Wettbewerbe veröffentlichen.

Keras

Keras ist eine beliebte High-Level-API für neuronale Netzwerke, die auf TensorFlow aufbaut. Keras bietet einfachere Mechanismen, um mit Deep-Learning-Modellen zu experimentieren, und senkt dadurch die Einstiegshürden.

Die Klassifikation von Bildern mit Keras ließe sich zum Beispiel mit einem CNN (kurz für Convolutional Neural Network a.k.a ConvNet) umsetzen. Diese Deep-Learning-Architektur bewährt sich bei Aufgaben wie Bilderkennung, Objekterkennung und Segmentierung aufgrund ihrer Fähigkeit, hierarchische Merkmale in Rohpixeldaten wahrzunehmen.

Jetzt Newsletter abonnieren

Täglich die wichtigsten Infos zu RZ- und Server-Technik

Mit Klick auf „Newsletter abonnieren“ erkläre ich mich mit der Verarbeitung und Nutzung meiner Daten gemäß Einwilligungserklärung (bitte aufklappen für Details) einverstanden und akzeptiere die Nutzungsbedingungen. Weitere Informationen finde ich in unserer Datenschutzerklärung. Die Einwilligungserklärung bezieht sich u. a. auf die Zusendung von redaktionellen Newslettern per E-Mail und auf den Datenabgleich zu Marketingzwecken mit ausgewählten Werbepartnern (z. B. LinkedIn, Google, Meta).

Aufklappen für Details zu Ihrer Einwilligung

Ein neuronales Netz vom Typ CNN für Bildklassifikation.(Bild:  AIM India)
Ein neuronales Netz vom Typ CNN für Bildklassifikation.
(Bild: AIM India)

CNNs folgen einer hierarchischen Struktur. Ein einfaches CNN besteht aus einer Abfolge von Faltungs-Schichten (im Fachjargon CONV, kurz für Convolutional) und Pooling-Schichten (POOL), gefolgt von vollständig verbundenen Schichten (dense layer oder FC für fully connected) für die Klassifikation.

Die Faltung-Schichten extrahieren lokale Muster (Merkmale) aus dem Eingangsbild. Eine Pooling-Schicht reduziert die räumlichen Dimensionen nach jeder CONV-Schicht und somit die Anzahl der Parameter, um das Netzwerk robuster gegenüber Variationen zu machen. Zu guter Letzt nehmen vollständig verbundene („dichte“) Schichten die von den vorherigen Schichten gelernten Merkmale auf und kombinieren sie, um Vorhersagen zu treffen.

In Python entsteht das benötigte ML-Modell nach dem Importieren der erforderlichen Keras-Module mittels:

model = models.Sequential([
   layers.Conv2D(32, (3, 3), activation='relu', input_shape=(28, 28, 1)),
   layers.MaxPooling2D((2, 2)),
   layers.Conv2D(64, (3, 3), activation='relu'),
   layers.MaxPooling2D((2, 2)),
   layers.Conv2D(64, (3, 3), activation='relu'),
   layers.Flatten(),
   layers.Dense(64, activation='relu'),
   layers.Dense(10, activation='softmax')
])

Um das ML-Modell zu trainieren, können Entwickler zum Beispiel den Dataset Fashion MNIST verwenden, eine Sammlung von 60.000 Trainingsbildern und 10.000 Testbildern, die in 10 Kategorien klassifiziert sind.

Die Einspeisung und Aufbereitung der Daten erfolgt in Python mittels:

(train_images, train_labels), (test_images, test_labels) = fashion_mnist.load_data()# Skalieren der Bilder auf einen Wertebereich von 0 bis 1
train_images = train_images / 255.0
test_images = test_images / 255.0
# Erweitern der Bildmatrix für die Nutzung in einem CNN
train_images = train_images[..., tf.newaxis]
test_images = test_images[..., tf.newaxis]

Beim Kompilieren des Modells muss man den Optimierer, die Verlustfunktion und die Metriken festlegen, die während des Trainings und in der Validierungsphase des Modells bewertet werden sollen:

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

Um das Modell zu trainieren, genügt in Python:

model.fit(train_images, train_labels, epochs=10, validation_data=(test_images, test_labels))

Die anschließende Evaluierung des Modells gelingt mittels:

test_loss, test_acc = model.evaluate(test_images, test_labels, verbose=2)
print('\nTestgenauigkeit:', test_acc)

Die einfache und intuitive API von Keras erleichtert die schnelle Entwicklung von leistungsfähigen ML-Modellen.

(ID:50064368)