Machine Learning for Engineers II - Advanced Methods - Exam

Aufgabe 1)

Hyperparameter-Tuning und -Optimierung: Hyperparameter-Tuning und -Optimierung umfassen Prozesse zur Auswahl der besten Hyperparameter in ML-Modellen, um die Modellleistung zu maximieren. Hyperparameter sind Parameter, die vor dem Training festgelegt werden (z.B. Lernrate, Batch-Größe). Das Ziel ist das Minimieren der Fehlerrate oder das Maximieren der Genauigkeit. Es gibt verschiedene Methoden wie Grid Search, Random Search und Bayesian Optimization, die jeweils unterschiedliche Ansätze zur Optimierung verfolgen. Grid Search verwendet eine erschöpfende Suche über einen vorgegebenen Parameterraum, während Random Search zufällig Parameter aus einem definierten Raum auswählt. Bayesian Optimization verwendet probabilistische Modelle, um die Funktion zu modellieren und vielversprechende Hyperparameter auszuwählen. Kreuzvalidierung wird häufig verwendet, um die Modellleistung bei verschiedenen Hyperparametern zu bewerten.

a)

Teilaufgabe 1: Angenommen, Du hast ein neuronales Netz gegeben, dessen Hyperparameter die Lernrate (\textit{lr}), die Anzahl der versteckten Schichten (\textit{hidden_layers}) und die Größe der Batch (\textit{batch_size}) sind. Beschreibe einen vollständigen Grid Search-Prozess für dieses Setting. Erkläre auch, wie Du Kreuzvalidierung nutzen würdest, um die Modellleistung während des Grid Search zu bewerten.

Lösung:

Teilaufgabe 1:

• Definition des Grid Search-Prozesses:
  • Zunächst definiere ich einen Satz von möglichen Werten für jeden Hyperparameter. Zum Beispiel:
  • Lernrate (\textit{lr}): [0.001, 0.01, 0.1]
  • Anzahl der versteckten Schichten (\textit{hidden_layers}): [2, 3, 4]
  • Größe der Batch (\textit{batch_size}): [32, 64, 128]
  • Ein Grid Search durchsucht nun systematisch jede Kombination dieser Hyperparameter. Für die gegebenen Werte hätten wir insgesamt 3 (Lernrate) x 3 (versteckte Schichten) x 3 (Batch-Größe) = 27 Kombinationen.
  • Für jede Kombination werden die Parameter des neuronalen Netzwerks entsprechend gesetzt und das Modell wird trainiert.
  • Nach dem Training wird die Modellleistung bewertet, um die beste Kombination der Hyperparameter zu identifizieren.
• Verwendung von Kreuzvalidierung zur Bewertung der Modellleistung während des Grid Search:
  • Bei der Kreuzvalidierung wird der ursprüngliche Datensatz in k gleiche Teile (Folds) aufgeteilt.
  • Für jeden der k Teile wird das Modell k-mal trainiert, wobei jedes Mal ein anderer Teil als Validierungsdatensatz verwendet wird und der Rest als Trainingsdatensatz dient. Typischerweise ist k = 5 oder 10, was als 5-fache oder 10-fache Kreuzvalidierung bekannt ist.
  • Für jede Kombination der Hyperparameter wird dann die mittlere Leistung (z.B. Genauigkeit, Fehlerrate) über alle k Folds berechnet.
  • Durch den Einsatz von Kreuzvalidierung stellen wir sicher, dass die Bewertung robust und nicht von zufälligen Fluktuationen im Datensatz beeinflusst ist.
  • Nach der Durchführung des Grid Search und der Kreuzvalidierung wählst Du die Kombination der Hyperparameter, die die beste mittlere Leistung erzielt hat.

b)

Teilaufgabe 2: In einem zweiten Szenario möchtest Du anstelle von Grid Search die Bayesian Optimization verwenden. Definiere die wesentlichen Schritte dieses Prozesses, einschließlich der Modellierung der Zielfunktion und der Auswahl der Hyperparameter. Nutze eine fiktive Funktion zur Maximierung der Genauigkeit eines neuronalen Netzes und beschreibe mathematisch die Schritte, die erforderlich sind, um die optimalen Hyperparameter zu bestimmen. Veranschauliche dies durch konkrete Formeln und Verfahren.

Lösung:

Teilaufgabe 2:

• Wesentliche Schritte der Bayesian Optimization:
  • Initialisierung: Wähle eine anfängliche Menge von Hyperparameter-Kombinationen. Dies könnte zufällig oder auf Basis von Vorwissen geschehen, um eine erste Menge von Evaluierungen der Zielfunktion zu erhalten.
  • Modellierung der Zielfunktion: Verwende ein probabilistisches Modell (oft ein Gaussian Process, GP), um die Zielfunktion zu modellieren. Die Zielfunktion ist in diesem Beispiel die Genauigkeit des neuronalen Netzes, dargestellt durch eine Funktion wie \( f(x) \), wobei \( x \) die Hyperparameter sind.
  • Auswahl der Akquisitionsfunktion: Wähle eine Akquisitionsfunktion, um die nächsten vielversprechenden Hyperparameter zu bestimmen. Eine gebräuchliche Wahl ist Expected Improvement (EI).
  • Iterative Optimierung: Evaluiere die Zielfunktion an den von der Akquisitionsfunktion vorgeschlagenen Hyperparametern. Aktualisiere das probabilistische Modell basierend auf den neuen Datenpunkten.
  • Konvergenzprüfung: Wiederhole den Prozess, bis eine Stoppbedingung erfüllt ist (z.B. maximale Anzahl von Iterationen oder Konvergenz der Hyperparameter).
• Mathematische Beschreibung der Schritte:
  • Sei \( x = (x_1, x_2, ..., x_n) \) ein Vektor von Hyperparametern. Die Zielfunktion \( f(x) \) gibt die Modellgenauigkeit zurück.
  • Gaussian Process Modell: Ein GP modelliert die Zielfunktion als Verteilung über Funktionen. Der GP wird durch den Mittelwert \( m(x) \) und die Kovarianzfunktion \( k(x,x') \) definiert, wobei
  • \( m(x) = \frac{1}{N} \sum_{i=1}^{N} f(x^{(i)}) \)
  • \( k(x, x') = \exp\left( -\frac{|| x - x' ||^2}{2 l^2} \right) \)
  • Akquisitionsfunktion: Eine übliche Akquisitionsfunktion ist das Expected Improvement (EI), definiert als:
  • \( EI(x) = \mathbb{E}[\max(0, f(x) - f_{best})] \)
  • Maximierung der Akquisitionsfunktion: Wähle den nächsten Punkt \( x \) als:
  • \( x^* = \arg\max_{x} EI(x) \)
  • Berechne \( f(x^*) \) durch Training und Validierung des neuronalen Netzes und aktualisiere das GP-Modell mit diesem neuen Datenpunkt.
• Fazit:
  • Wiederhole diesen Zyklus (Modellierung der Zielfunktion, Maximierung der Akquisitionsfunktion und Aktualisierung des GP-Modells) bis zur Konvergenz, um die besten Hyperparameter zu finden. Bayesian Optimization nutzt die Vorhersagen des GP-Modells, um gezielt neue Hyperparameter auszuwählen und die Anzahl der erforderlichen Evaluierungen zu minimieren.

Aufgabe 2)

Architekturen tiefer neuronaler Netze (CNNs, RNNs)CNNs und RNNs sind Architekturen für tiefe neuronale Netze, die zur Verarbeitung von räumlichen (CNN) und sequentiellen Daten (RNN) entwickelt wurden. Diese Architekturen sind zentral für Anwendungen in der Bild- und Texterkennung.

• CNNs (Convolutional Neural Networks): Diese Netzwerke bestehen aus Faltungs-, Pooling- und vollverbundenen Schichten, die räumliche Hierarchien in Bildern erkennen können.
• Wichtige Konzepte beinhalten Filter, Stride, Padding, Pooling (max/average) und Aktivierungsfunktionen wie ReLU.
• Typische Anwendungen umfassen Bildklassifikation, Objekterkennung und Bildsegmentierung.
• RNNs (Recurrent Neural Networks): Diese Netzwerke sind speziell für die Verarbeitung sequentieller Daten konzipiert und nutzen interne Zustände (Speicher) für die Sequenzverarbeitung.
• Das Vanishing Gradient Problem ist ein bekanntes Problem bei RNNs, welches durch Architekturen wie LSTM (Long Short-Term Memory) und GRU (Gated Recurrent Unit) gelöst wird.
• RNNs finden Anwendungen in der Sprachverarbeitung, maschinellen Übersetzung und Zeitreihenanalyse.

a)

Erkläre die Hauptkomponenten eines CNNs und ihre jeweilige Funktion ausführlich. Wie tragen diese Komponenten zur Erkennung räumlicher Hierarchien in Bildern bei?

Lösung:

Hauptkomponenten eines CNNs und ihre FunktionenEin Convolutional Neural Network (CNN) besteht aus mehreren zentralen Komponenten, die zusammenarbeiten, um räumliche Hierarchien in Bildern zu erkennen. Diese Komponenten sind:

• Faltungsschicht (Convolutional Layer): Die Faltungsschicht ist die wichtigste Komponente eines CNNs. Sie besteht aus mehreren Filtern (auch Kernels genannt), die über das Eingabebild gleiten (der Prozess des Faltens). Jeder Filter extrahiert bestimmte Merkmale aus dem Bild, wie z.B. Kanten, Ecken oder Texturen. Diese Merkmale werden in den sogenannten Feature Maps gespeichert. Die Parameter, die die Bewegung der Filter regeln, sind der Stride (Schrittweite) und Padding (Auffüllen der Ränder).
• Pooling-Schicht (Pooling Layer): Die Pooling-Schicht reduziert die Dimension der Feature Maps, indem sie die räumliche Auflösung verringert. Dies kann durch Max-Pooling (nur der größte Wert innerhalb eines Fensters wird übernommen) oder Average-Pooling (der Durchschnittswert innerhalb eines Fensters wird übernommen) geschehen. Pooling hilft dabei, die Berechnungseffizienz zu steigern und die Möglichkeit der Überanpassung zu verringern.
• Aktivierungsfunktion: Eine Aktivierungsfunktion wie ReLU (Rectified Linear Unit) wird nach jeder Faltung und Pooling angewendet, um nichtlineare Beziehungen im Daten zu modellieren. ReLU setzt alle negativen Werte auf Null und lässt positive Werte unverändert, was die Netzwerkleistung verbessert, indem es nichtlineare Eigenschaften hinzufügt.
• Vollverbundene Schicht (Fully Connected Layer): Diese Schicht wird am Ende des CNNs verwendet, um die extrahierten Merkmale in Klassifikationen oder Vorhersagen umzuwandeln. Jede Neuron in dieser Schicht ist mit allen Neuronen der vorherigen Schicht verbunden, was eine umfangreiche Merkmalskombination ermöglicht.

Beitrag zur Erkennung räumlicher Hierarchien

• Schrittweise Merkmalsextraktion: Die Faltungsschichten extrahieren in den ersten Schichten grundlegende Merkmale wie Kanten und Ecken. In den nachfolgenden Schichten werden immer komplexere und abstrakte Merkmale erkannt.
• Dimensionalitätsreduktion: Die Pooling-Schichten reduzieren die Komplexität der Merkmale, indem sie die räumliche Auflösung der Feature Maps senken, aber die wichtigen Informationen beibehalten.
• Nichtlinearität: Die Aktivierungsfunktionen wie ReLU sorgen dafür, dass das Netzwerk nichtlineare Beziehungen lernen kann, was für die Erkennung komplexer Muster in Bildern wichtig ist.
• Klassifizierung: Die vollverbundenen Schichten am Ende des Netzwerks kombinieren die extrahierten Merkmale zu einer finalen Entscheidung (z.B. Klassenlabel für die Bildklassifikation).

c)

Beschreibe das Vanishing Gradient Problem bei RNNs. Wie lösen LSTM und GRU dieses Problem? Erläutere den grundlegenden Unterschied zwischen der Funktionalität von LSTM und GRU.

Lösung:

Das Vanishing Gradient Problem bei RNNsDas Vanishing Gradient Problem ist eine bekannte Herausforderung bei Recurrent Neural Networks (RNNs), die bei der Verarbeitung und dem Training von sequentiellen Daten auftreten kann. Hier sind die Details:

• Problem: Während des Backpropagation-Through-Time (BPTT)-Prozesses schrumpfen die Gradienten der Fehlerfunktion, die zurück durch das Netzwerk propagiert werden, exponentiell. Dies führt dazu, dass die Gewichtsaktualisierungen im Netzwerk sehr klein werden, besonders in frühen Schichten. Das heißt, das Netzwerk hat Schwierigkeiten, langfristige Abhängigkeiten zu erlernen und relevante Informationen aus der Vergangenheit zu behalten.

Wie LSTM und GRU das Problem lösenLong Short-Term Memory (LSTM) und Gated Recurrent Unit (GRU) sind spezielle Architekturen von RNNs, die entwickelt wurden, um das Vanishing Gradient Problem zu adressieren. Sie verwenden Mechanismen, die besser kontrollieren, wie Informationen durch das Netzwerk fließen.

• LSTM (Long Short-Term Memory):

• Die Hauptkomponente von LSTM ist die Zelle, die Informationen über längere Zeiträume speichern kann. In LSTM gibt es spezielle „Gates“ (Eingangstor, Vergesstor und Ausgangstor), die den Fluss von Informationen steuern:
• Eingangstor (Input Gate): Entscheidet, welche neuen Informationen in den Zellzustand geschrieben werden.
• Vergesstor (Forget Gate): Entscheidet, welche Informationen aus dem Zellzustand gelöscht werden.
• Ausgangstor (Output Gate): Bestimmt, welche Informationen aus dem Zellzustand als Ausgabe verwendet werden und in den nächsten Zeitschritt gehen.
• Diese Gates ermöglichen es dem LSTM, relevante Informationen über lange Zeiträume hinweg zu speichern und irrelevante Informationen zu vergessen, wodurch das Vanishing Gradient Problem reduziert wird.

GRU (Gated Recurrent Unit):

• GRUs sind eine vereinfachte Version von LSTMs und haben nur zwei Gates:
• Update-Gate: Kombiniert die Funktionen des Eingangs- und Vergesstors von LSTM und entscheidet, wie viele der neuen und alten Informationen beibehalten werden.
• Reset-Gate: Bestimmt, wieviel der bisherigen Informationen gespeichert bleiben.
• Der Reset-Gate steuert, wie viele der bisherigen Informationen bei der Berechnung des neuen Zellzustands berücksichtigt werden.

GRUs sind oft einfacher zu trainieren und benötigen weniger Rechenressourcen als LSTMs, während sie dennoch in der Lage sind, das Vanishing Gradient Problem effektiv zu handhaben.Grundlegender Unterschied zwischen LSTM und GRU

• Zahl der Gates: LSTM hat drei Gates (Input Gate, Forget Gate, Output Gate), während GRU nur zwei Gates hat (Update Gate und Reset Gate).
• Speicherstruktur: LSTM hat einen separaten Zellzustand, der unabhängig vom verborgenen Zustand aktualisiert wird. Im Gegensatz dazu kombiniert GRU den Zellzustand und den verborgenen Zustand zu einem gemeinsamen Zustand.
• Komplexität: Durch die geringere Anzahl an Gates und die vereinfachte Struktur sind GRUs weniger komplex und erfordern oft weniger Rechenressourcen als LSTMs.

Zusammenfassend lässt sich sagen, dass sowohl LSTM als auch GRU das Vanishing Gradient Problem durch ihre speziellen internen Mechanismen adressieren, allerdings unterscheiden sie sich in ihrer Struktur und Komplexität.

d)

Entwickle ein einfaches RNN-Modell in Python unter Verwendung von TensorFlow oder PyTorch, das eine Sequenz von Zahlen vorhersagt. Gehe kurz auf die Datenvorbereitung, das Modelltraining und die Bewertung des Modells ein. Achte darauf, die Notwendigkeit der Verwendung einer speziellen RNN-Architektur wie LSTM oder GRU zu begründen.

Lösung:

Entwicklung eines einfachen RNN-Modells zur Vorhersage einer ZahlensequenzIn diesem Beispiel verwenden wir TensorFlow, um ein einfaches RNN-Modell zu erstellen, das eine Sequenz von Zahlen vorhersagt. Wir werden Folgendes abdecken:

• Datenvorbereitung
• Modellarchitektur
• Modelltraining
• Modellbewertung

DatenvorbereitungZunächst bereiten wir eine einfache Sequenz von Zahlen vor und teilen sie in Features und Labels auf.

import numpy as npimport tensorflow as tffrom sklearn.model_selection import train_test_split# Generierung einer einfachen Sequenzsequence = np.arange(1, 101)# Vorbereitung der Datenn_steps = 5X, y = [], []for i in range(len(sequence) - n_steps):    X.append(sequence[i:i + n_steps])    y.append(sequence[i + n_steps])X = np.array(X)y = np.array(y)# Aufteilen der Daten in Trainings- und TestdatenX_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=42)# Reshape für das RNN EingabeformatX_train = X_train.reshape((X_train.shape[0], X_train.shape[1], 1))X_test = X_test.reshape((X_test.shape[0], X_test.shape[1], 1))

ModellarchitekturWir verwenden eine LSTM-Architektur, um das Vanishing Gradient Problem zu umgehen und eine bessere Modellleistung zu gewährleisten.

from tensorflow.keras.models import Sequentialfrom tensorflow.keras.layers import LSTM, Dense# Erstellen des Modellsmodel = Sequential()model.add(LSTM(50, activation='relu', input_shape=(n_steps, 1)))model.add(Dense(1))model.compile(optimizer='adam', loss='mse')

ModelltrainingWir trainieren das Modell mit den vorbereiteten Trainingsdaten.

# Training des Modellsmodel.fit(X_train, y_train, epochs=200, verbose=1)

ModellbewertungNach dem Training bewerten wir das Modell mit den Testdaten.

# Bewertung des Modellsloss = model.evaluate(X_test, y_test, verbose=1)print(f'Modellverlust: {loss}')# Beispielvorhersagex_input = np.array([96, 97, 98, 99, 100]).reshape((1, n_steps, 1))yhat = model.predict(x_input, verbose=1)print(f'Vorhergesagte Zahl: {yhat}')

Notwendigkeit der Verwendung einer speziellen RNN-Architektur wie LSTM oder GRUStandard-RNNs stoßen aufgrund des Vanishing Gradient Problems auf Schwierigkeiten bei der Verarbeitung langer Sequenzen. LSTM- und GRU-Architekturen verwenden spezielle Mechanismen wie Gates, um relevante Informationen über längere Zeiträume beizubehalten und irrelevante Informationen zu vergessen. Dadurch können sie langfristige Abhängigkeiten in Sequenzdaten besser erlernen und sorgen für stabileres und leistungsfähigeres Training. Dasselbe Modell könnte auch mit einer GRU-Schicht erstellt werden, indem die LSTM-Schicht durch eine GRU-Schicht ersetzt wird. Beide Architekturen verbessern das Training und die Leistung im Vergleich zu Standard-RNNs.

Aufgabe 3)

Du trainierst ein tiefes neuronales Netzwerk zur Klassifizierung von handgeschriebenen Zahlen auf dem MNIST-Datensatz. Um Überanpassung zu vermeiden, möchtest Du verschiedene Techniken einsetzen, darunter Dropout, Regularisierung, Cross-Validation, frühes Stoppen und Datenaugmentation.

a)

Implementiere Dropout in einem neuronalen Netzwerk, das auf dem MNIST-Datensatz trainiert wird. Erläutere die Funktionsweise von Dropout und wie es zur Vermeidung von Überanpassung beiträgt. Füge entsprechenden Python-Code ein, der das Konzept demonstriert.

Lösung:

Dropout Erklären und Implementieren

Dropout ist eine Regularisierungstechnik, die verwendet wird, um Überanpassung (Overfitting) in neuronalen Netzwerken zu vermindern. Die Grundidee von Dropout besteht darin, während des Trainings zufällig einige Neuronen in einem Netzwerk vorübergehend „auszuschalten“ (d.h. ihre Ausgänge auf 0 zu setzen). Dieses Verfahren zwingt das Netzwerk, seine Informationen auf verschiedene Neuronen zu verteilen und verhindert, dass es sich zu sehr an die Trainingsdaten anpasst.

Durch das „Ausschalten“ von Neuronen werden verschiedene Teilschritte des Netzwerks trainiert, was zu einem widerstandsfähigeren und generalisierbareren Modell führt. Während der Vorhersagephase (d.h. bei der Evaluation oder dem Testen des Modells) werden alle Neuronen verwendet, jedoch wird der Output der Neuronen, die während des Trainings „ausgeschaltet“ wurden, skaliert, um das Training zu emulieren.

Hier ist ein Beispiel für die Implementierung von Dropout in einem neuronalen Netzwerk, das auf dem MNIST-Datensatz trainiert wird, unter Verwendung von Keras:

import numpy as npimport kerasfrom keras.datasets import mnistfrom keras.models import Sequentialfrom keras.layers import Dense, Dropout, Flattenfrom keras.utils import np_utils# Laden und Vorbereiten der MNIST-Daten(x_train, y_train), (x_test, y_test) = mnist.load_data()num_classes = 10# Normierung der Eingabedatenx_train = x_train.astype('float32') / 255x_test = x_test.astype('float32') / 255# Umwandeln der Labels in One-Hot-Encodingy_train = np_utils.to_categorical(y_train, num_classes)y_test = np_utils.to_categorical(y_test, num_classes)# Erstellen des Modellsmodel = Sequential()model.add(Flatten(input_shape=(28, 28)))model.add(Dense(512, activation='relu'))model.add(Dropout(0.5)) # Dropout-Layer mit 50% Dropout-Ratemodel.add(Dense(512, activation='relu'))model.add(Dropout(0.5)) # Dropout-Layer mit 50% Dropout-Ratemodel.add(Dense(num_classes, activation='softmax'))# Kompilieren des Modellsmodel.compile(loss='categorical_crossentropy',              optimizer='adam',              metrics=['accuracy'])# Trainieren des Modellsmodel.fit(x_train, y_train,          batch_size=128,          epochs=20,          verbose=1,          validation_data=(x_test, y_test))# Evaluieren des Modellsscore = model.evaluate(x_test, y_test, verbose=0)print('Test loss:', score[0])print('Test accuracy:', score[1])

In diesem Beispiel wird Dropout nach den beiden Dense-Layers eingefügt. Die Dropout-Rate ist auf 0,5 gesetzt, was bedeutet, dass 50% der Neuronen zufällig „ausgeschaltet“ werden.

• Schritt 1: Importiere die notwendigen Bibliotheken und lade den MNIST-Datensatz.
• Schritt 2: Normalisiere die Eingabedaten und transformiere die Labels in One-Hot-Encoding.
• Schritt 3: Erstelle das neuronale Netzwerkmodell und füge Dropout-Layers nach den Dense-Layers hinzu.
• Schritt 4: Kompiliere das Modell mit einem Optimierungsalgorithmus und einem Verlustfenktionen.
• Schritt 5: Trainiere das Modell und validiere es mit den Testdaten.
• Schritt 6: Evaluiere das Modell mit den Testdaten und gib die Ergebnisse aus.

b)

Erkläre mathematisch die L2-Regularisierung und füge den Regularisierungsterm in die Verlustfunktion eines neuronalen Netzwerks ein. Sei \(\mathcal{L}(\theta)\) die ursprüngliche Verlustfunktion und \(\lambda\) der Regularisierungsfaktor. Schreibe die neue Verlustfunktion mit Latex-Notation auf und diskutiere, wie die Wahl von \(\lambda\) die Modellkomplexität beeinflusst.

Lösung:

L2-Regularisierung Erklären und Mathematisch Einfügen

Die L2-Regularisierung ist eine Technik, die verwendet wird, um Überanpassung (Overfitting) in maschinellen Lernmodellen zu verhindern, indem sie die Komplexität des Modells bestraft. Dies erfolgt durch Hinzufügen eines Regularisierungsterms zur Verlustfunktion, der die Summe der Quadrate aller Gewichte des Modells beinhaltet. Dieser Regularisierungsterm wird oft auch als Tikhonov-Regularisierung oder Ridge-Regression bezeichnet.

Mathematisch wird die L2-Regularisierung wie folgt dargestellt:

• Sei \(\theta\) der Vektor der Gewichtsparameter des Modells.
• Sei \(\mathcal{L}(\theta)\) die ursprüngliche Verlustfunktion ohne Regularisierung.
• Sei \(\lambda\) der Regularisierungsfaktor, der bestimmt, wie stark die Regularisierung ist.

Der Regularisierungsterm für L2-Regularisierung ist:

\[ \lambda \sum \theta_i^2 \]

Die neue Verlustfunktion mit L2-Regularisierung lautet dann:

\[ \tilde{\mathcal{L}}(\theta) = \mathcal{L}(\theta) + \frac{\lambda}{2} \sum \theta_i^2 \]

Hierbei ist der Regularisierungsfaktor \(\lambda\) ein hyperparametrischer Wert, der die Stärke der Regularisierung kontrolliert.

Diskussion über die Wahl von \(\lambda\) und Modellkomplexität:

• Ein kleiner Wert für \(\lambda\) lässt die ursprüngliche Verlustfunktion dominieren, was bedeutet, dass das Modell weniger bestraft wird und daher komplexer sein kann. Dies kann zu Überanpassung führen, wenn das Modell zu stark an die Trainingsdaten angepasst wird.
• Ein großer Wert für \(\lambda\) führt dazu, dass die Gewichtungen stärker bestraft werden, was zu einem einfacheren Modell mit kleineren Gewichten führt. Ein zu großer \(\lambda\)-Wert kann jedoch zu Unteranpassung führen, da das Modell nicht in der Lage sein könnte, die zugrunde liegenden Muster der Daten zu erfassen.

Die Wahl des optimalen \(\lambda\)-Wertes erfordert oft eine Hyperparameter-Suche, wie beispielsweise eine Kreuzvalidierung (Cross-Validation).

Implementierung der neuen Verlustfunktion mit L2-Regularisierung in einem Keras-Modell:

import numpy as npimport kerasfrom keras.datasets import mnistfrom keras.models import Sequentialfrom keras.layers import Dense, Flattenfrom keras.regularizers import l2from keras.utils import np_utils# Laden und Vorbereiten der MNIST-Daten(x_train, y_train), (x_test, y_test) = mnist.load_data()num_classes = 10# Normierung der Eingabedatenx_train = x_train.astype('float32') / 255x_test = x_test.astype('float32') / 255# Umwandeln der Labels in One-Hot-Encodingy_train = np_utils.to_categorical(y_train, num_classes)y_test = np_utils.to_categorical(y_test, num_classes)# Regularisierungsfaktorlambda_reg = 0.001# Erstellen des Modells und Hinzufügen der L2-Regularisierungmodel = Sequential()model.add(Flatten(input_shape=(28, 28)))model.add(Dense(512, activation='relu', kernel_regularizer=l2(lambda_reg)))model.add(Dense(512, activation='relu', kernel_regularizer=l2(lambda_reg)))model.add(Dense(num_classes, activation='softmax'))# Kompilieren des Modellsmodel.compile(loss='categorical_crossentropy',              optimizer='adam',              metrics=['accuracy'])# Trainieren des Modellsmodel.fit(x_train, y_train,          batch_size=128,          epochs=20,          verbose=1,          validation_data=(x_test, y_test))# Evaluieren des Modellsscore = model.evaluate(x_test, y_test, verbose=0)print('Test loss:', score[0])print('Test accuracy:', score[1])

In diesem Beispiel wurde der Regularisierungsfaktor \(\lambda = 0.001\) gewählt und der L2-Regularisierungsterm über den Parameter kernel_regularizer=l2(lambda_reg) zu den Dense-Layers des Modells hinzugefügt.

c)

Beschreibe den Prozess des frühen Stoppens und wie er implementiert wird. Diskutiere, wie Du die Hyperparameter (z.B. Anzahl der Epochen, Geduld) wählst. Füge ein Diagramm hinzu, das die Trainings- und Validierungsgenauigkeit im Verlauf des Trainings zeigt und erläutere, wie das Diagramm zur Entscheidung über das frühe Stoppen verwendet wird.

Lösung:

Frühes Stoppen (Early Stopping) erklären und umsetzen

Frühes Stoppen ist eine Technik im maschinellen Lernen, die verwendet wird, um Überanpassung (Overfitting) zu vermeiden. Der Kern des frühen Stoppens besteht darin, das Training eines Modells zu beenden, sobald die Leistung auf den Validierungsdaten nicht weiter verbessert wird. Dies verhindert, dass das Modell zu lange trainiert und dadurch anfängt, sich zu stark an die Trainingsdaten anzupassen.

Der Prozess des frühen Stoppens funktioniert in der Regel wie folgt:

• Überwachung einer Metrik: Eine Leistungsmetrik (z.B. Validierungsverlust oder -genauigkeit) wird während des Trainings überwacht.
• Geduld (Patience): Ein Geduldswert wird festgelegt, der angibt, wie viele Epochen das Training fortgesetzt wird, nachdem sich die überwachte Metrik nicht verbessert hat, bevor das Training abgebrochen wird.
• Bester Wert: Der beste erzielte Wert der überwachten Metrik wird gespeichert.
• Beenden des Trainings: Wenn die Metrik sich für eine bestimmte Anzahl von Epochen (Patience) nicht verbessert, wird das Training gestoppt.

Implementierung von frühem Stoppen in Keras:

import numpy as npimport kerasfrom keras.datasets import mnistfrom keras.models import Sequentialfrom keras.layers import Dense, Flattenfrom keras.callbacks import EarlyStoppingfrom keras.utils import np_utils# Laden und Vorbereiten der MNIST-Daten(x_train, y_train), (x_test, y_test) = mnist.load_data()num_classes = 10# Normierung der Eingabedatenx_train = x_train.astype('float32') / 255x_test = x_test.astype('float32') / 255# Umwandeln der Labels in One-Hot-Encodingy_train = np_utils.to_categorical(y_train, num_classes)y_test = np_utils.to_categorical(y_test, num_classes)# Erstellen des Modellsmodel = Sequential()model.add(Flatten(input_shape=(28, 28)))model.add(Dense(512, activation='relu'))model.add(Dense(512, activation='relu'))model.add(Dense(num_classes, activation='softmax'))# Kompilieren des Modellsmodel.compile(loss='categorical_crossentropy',              optimizer='adam',              metrics=['accuracy'])# Implementieren des frühen Stoppensearly_stopping = EarlyStopping(monitor='val_loss', patience=5, restore_best_weights=True)# Trainieren des Modellshistory = model.fit(x_train, y_train,                    batch_size=128,                    epochs=50,                    verbose=1,                    validation_data=(x_test, y_test),                    callbacks=[early_stopping])# Evaluieren des Modellsscore = model.evaluate(x_test, y_test, verbose=0)print('Test loss:', score[0])print('Test accuracy:', score[1])

In diesem Beispiel wird ein EarlyStopping-Callback verwendet, das bei einem Validierungsverlust (val_loss) überwacht. Wenn sich der Validierungsverlust für 5 aufeinanderfolgende Epochen nicht verbessert, wird das Training gestoppt und die besten Gewichtungen des Modells werden wiederhergestellt.

Wahl der Hyperparameter:

• Anzahl der Epochen: Beginne mit einer höheren Anzahl von Epochen, da das frühe Stoppen das Training automatisch beendet, wenn keine Verbesserung mehr festgestellt wird.
• Geduld (Patience): Der Geduldswert sollte so gewählt werden, dass das Modell genug Zeit hat, um mögliche Schwankungen zu überwinden und sich weiter zu verbessern. Typischerweise werden Werte zwischen 5 und 10 verwendet.

Diagramm der Trainings- und Validierungsgenauigkeit:

Ein Diagramm, das die Trainings- und Validierungsgenauigkeit im Verlauf des Trainings zeigt, kann verwendet werden, um den Zeitpunkt des frühen Stoppens zu bestimmen und festzustellen, ob das Modell überanpasst. Hier ist ein Beispiel:

import matplotlib.pyplot as plt# Zeichnen der Trainings- und Validierungsgenauigkeitplt.plot(history.history['accuracy'], label='Trainingsgenauigkeit')plt.plot(history.history['val_accuracy'], label='Validierungsgenauigkeit')plt.title('Modellgenauigkeit')plt.xlabel('Epoche')plt.ylabel('Genauigkeit')plt.legend(loc='upper left')plt.show()

Das Diagramm zeigt die Genauigkeit während des Trainings und der Validierung für jede Epoche. Wenn die Validierungsgenauigkeit nach einer bestimmten Epoche nicht weiter steigt oder sogar abfällt, ist dies ein Anzeichen von Überanpassung. Hier kann das frühe Stoppen eingesetzt werden, um das Training zu beenden.

Zusammenfassend ist frühes Stoppen eine wertvolle Technik zur Vermeidung von Überanpassung, indem es das Training stoppt, wenn die Leistung auf den Validierungsdaten nicht weiter verbessert wird. Die Wahl der Hyperparameter wie Geduld und Anzahl der Epochen ist entscheidend für die Effektivität dieser Methode.

Aufgabe 4)

Ein Ingenieur hat ein vortrainiertes Modell auf dem großen ImageNet-Datensatz, um Bilder zu klassifizieren. Jetzt möchte er dieses Modell für die Erkennung spezifischer Fahrzeugtypen auf einem kleineren, spezifizierten Dataset verwenden. Er hat die Möglichkeit, entweder Finetuning oder Feature Extraction zu verwenden. Das Ziel ist es, die Leistung auf dem kleineren Fahrzeug-Dataset zu maximieren und dabei effiziente Methoden zu nutzen.

a)

a) Erkläre, was unter Finetuning und Feature Extraction in diesem Kontext zu verstehen ist. Beschreibe detailliert den Prozess und die Unterschiede zwischen beiden Methoden.

Lösung:

• Finetuning:Beim Finetuning wird das vortrainierte Modell auf den neuen, spezifischen Datensatz angepasst, indem alle oder die meisten Schichten des neuronalen Netzes weiter trainiert werden. Dies bedeutet, dass die Netzwerkgewichte, die durch das Training auf dem großen ImageNet-Datensatz gelernt wurden, als Ausgangspunkt genutzt und dann durch Training auf dem kleineren Fahrzeug-Dataset weiter optimiert werden.
  • Prozess des Finetunings:
  • Das vortrainierte Modell wird geladen.
  • Die letzte Schicht (oftmals die Klassifizierungsschicht) wird durch eine neue Schicht ersetzt, die zur Anzahl der Klassen im neuen Datensatz passt.
  • Alle Schichten (oder ein Großteil) des Netzwerks werden weiter trainiert, jedoch mit einer kleineren Lernrate, um zu vermeiden, dass die bereits gelernten repräsentativen Merkmale verloren gehen.
  • Das Modell wird auf dem kleineren Fahrzeug-Dataset trainiert, bis es gute Ergebnisse liefert.
• Feature Extraction:Beim Feature Extraction wird das vortrainierte Modell verwendet, um Merkmale (Features) aus den Bildern des neuen Datensatzes zu extrahieren. Diese Merkmale werden dann eingefroren und nur die letzte Schicht, die für die spezifische Aufgabe zuständig ist, wird trainiert.
  • Prozess der Feature-Extraktion:
  • Das vortrainierte Modell wird geladen und alle Schichten außer der letzten Schicht werden eingefroren (ihre Gewichte werden nicht verändert).
  • Eine neue Klassifizierungsschicht wird hinzugefügt, die zur Anzahl der Klassen im neuen Datensatz passt.
  • Nur die neue Klassifizierungsschicht wird auf dem kleineren Fahrzeug-Dataset trainiert.
  • Das Modell wird verwendet, um die Fahrzeugbilder zu klassifizieren, wobei die extrahierten Merkmale aus den eingefrorenen Schichten genutzt werden.
• Unterschiede zwischen Finetuning und Feature Extraction:
  • Trainingsaufwand: Beim Finetuning werden meist alle (oder viele) Schichten des Modells weiter trainiert, was mehr Rechenressourcen und Zeit erfordert. Im Gegensatz dazu wird beim Feature Extraction nur die letzte Schicht trainiert, was weniger Aufwand bedeutet.
  • Anpassungsfähigkeit: Finetuning bietet eine höhere Flexibilität und die Möglichkeit, das Modell stärker an den neuen Datensatz anzupassen, da alle Schichten weiter optimiert werden können. Feature Extraction ist schneller, aber weniger flexibel, da die extrahierten Merkmale aus den eingefrorenen Schichten möglicherweise nicht optimal für die neue Aufgabe sind.
  • Komplexität des neuen Datensatzes: Wenn der neue Datensatz sehr unterschiedlich und komplex ist, kann Finetuning von Vorteil sein, da das Modell durch das weitere Training besser an die neuen Merkmale angepasst werden kann. Wenn der Datensatz jedoch relativ ähnlich zum ursprünglichen ist oder eine geringere Variation aufweist, kann Feature Extraction ausreichen.

b)

b) Angenommen, der Ingenieur entscheidet sich für das Finetuning des vortrainierten Modells. Gibt es bestimmte Schichten oder Bereiche des Modells, die bevorzugt feinjustiert werden sollten? Begründe deine Antwort unter Berücksichtigung der Transfer Learning-Prinzipien.

Lösung:

• Finetuning von spezifischen Schichten:Beim Finetuning eines vortrainierten Modells sollten bestimmte Schichten oder Bereiche bevorzugt feinjustiert werden, um die Vorteile des Transfer Learnings optimal zu nutzen. Hier sind einige Aspekte, die berücksichtigt werden sollten:
  • Feinjustierung der späteren Schichten:Spätere Schichten in einem neuronalen Netz sind normalerweise spezialisierter und an die konkrete Aufgabe des ursprünglichen Datensatzes (ImageNet) angepasst. Da der Ingenieur die Klassifikation spezifischer Fahrzeugtypen durchführen möchte, ist es sinnvoll, die späteren Schichten des Modells zu finetunen, um diese besser an die neuen Fahrzeugbilder anzupassen.
    • Diese Schichten enthalten hochspezifische Merkmale, die durch das Finetuning neu justiert werden können, um besser mit den Merkmalen der Fahrzeugtypen übereinzustimmen.
    • Dies ermöglicht eine effizientere Anpassung des Modells an den kleineren, spezifizierten Dataset.
  • Einfrieren der frühen Schichten:Die frühen Schichten eines vortrainierten Modells extrahieren oft allgemeine Merkmale wie Kanten, Ecken und Grundformen, die in vielen verschiedenen Domänen nützlich sind. Diese generalisierten Merkmale sind meist auch für die neue Aufgabe relevant.
    • Indem diese frühen Schichten eingefroren (nicht weiter trainiert) werden, kann Rechenaufwand gespart und gleichzeitig die Stabilität der ursprünglich gelernten Merkmale beibehalten werden.
    • Das Einfrieren dieser Schichten hilft auch, das Risiko von Überanpassung an den neuen, kleineren Datensatz zu minimieren.
  • Feinjustierung der mittleren Schichten:Obwohl die spätere Schichten oft die erste Priorität beim Finetuning sind, können mittlere Schichten ebenfalls angepasst werden, falls der neue Datensatz stark von dem ursprünglichen Datensatz abweicht.
    • Wenn die Merkmale des neuen Fahrzeug-Datasets besonders komplex oder unterschiedlich zu denen des ImageNet-Datensatzes sind, kann eine Anpassung der mittleren Schichten helfen, besser repräsentative Merkmale zu lernen.
• Transfer Learning-Prinzipien:
  • Transfer Learning basiert auf der Wiederverwendung von bereits gelernten Merkmalen aus einem großen, allgemeinen Datensatz für eine spezifische, oft kleinere Aufgabe.
  • Durch die Kombination von Einfrieren allgemeiner Schichten und Anpassung spezialisierter Schichten kann der Ingenieur das Modell effizient verbessern, ohne die Vorteile des vortrainierten Netzwerks zu verlieren.
  • Das Übertragen von allgemeinem Wissen auf eine spezifische Aufgabe ermöglicht es, mit weniger anzupassenden Parametern und einer geringeren Menge an neuen Trainingsdaten eine gute Leistung zu erzielen.

c)

c) Der Ingenieur hat folgende Leistungsmessungen für das Fahrzeug-Dataset erhalten: Mit Feature Extraction beträgt die Genauigkeit 85%, während mit Finetuning die Genauigkeit 90% beträgt. Berechne den relativen Leistungszuwachs, den das Finetuning gegenüber Feature Extraction bietet. Gib deine Berechnungen und das Endergebnis in Prozent an.

Lösung:

• Berechnung des relativen Leistungszuwachses:Um den relativen Leistungszuwachs zu berechnen, der durch das Finetuning gegenüber der Feature Extraction erreicht wird, verwenden wir die folgende Formel:\[\text{Relativer Zuwachs in %} = \frac{\text{Genauigkeit (Finetuning) - Genauigkeit (Feature Extraction)}}{\text{Genauigkeit (Feature Extraction)}} \times 100\]Ersetze die Werte durch die gegebenen Genauigkeiten:\[\text{Relativer Zuwachs in %} = \frac{90\% - 85\%}{85\%} \times 100\] Führe die Berechnungen Schritt für Schritt durch:
  • Berechne die Differenz der Genauigkeiten:
  \[90\% - 85\% = 5\%\]
  • Teile die Differenz durch die Genauigkeit der Feature Extraction:
  \[\frac{5\%}{85\%} = \frac{5}{85} \approx 0{,}0588\]
  • Multipliziere das Ergebnis mit 100, um den Prozentsatz zu erhalten:
  \[0{,}0588 \times 100 = 5{,}88\%\]
  • Endergebnis:Der relative Leistungszuwachs, den das Finetuning gegenüber der Feature Extraction bietet, beträgt etwa 5{,}88\%.