Machine Learning for Engineers I - Introduction to Methods and Tools - Exam

Aufgabe 1)

In dieser Aufgabe wirst Du verschiedene Methoden des überwachten und unüberwachten Lernens analysieren und anwenden. Du hast Zugang zu einem Datensatz, der sowohl gelabelte als auch ungelabelte Daten enthält. Der Datensatz enthält mehrere Merkmale und die Aufgabe ist es, sowohl Vorhersagen zu treffen als auch die zugrunde liegende Struktur in den Daten zu entdecken.

a)

Teilaufgabe 1: Überwachtes Lernen

Du wirst ein überwachtes Modell zur Vorhersage der Zielvariable Y trainieren. Verwende dafür einen Datensatz, der aus 70% Trainingsdaten und 30% Testdaten besteht. Du kannst hierfür einen Algorithmus Deiner Wahl verwenden. Zuerst werden wir eine lineare Regression implementieren. Dabei sind die folgenden Schritte erforderlich:

• Teile den Datensatz in Trainings- und Testdaten auf.
• Trainiere das Modell auf den Trainingsdaten.
• Evaluiere die Modellleistung auf den Testdaten mittels geeigneter Metriken (z.B. MSE, R^2).

Der Zielwert (Y) ist kontinuierlich. Verwende den folgenden Codeblock und vervollständige ihn:

import numpy as npimport pandas as pdfrom sklearn.model_selection import train_test_splitfrom sklearn.linear_model import LinearRegressionfrom sklearn.metrics import mean_squared_error, r2_score# Laden des Datensatzesdata = pd.read_csv('your_dataset.csv')# Aufteilen der Daten in Features (X) und Zielvariable (Y)X = data.drop('Zielvariable', axis=1)Y = data['Zielvariable']# Aufteilen der Daten in Trainings- und TestdatenX_train, X_test, Y_train, Y_test = train_test_split(X, Y, test_size=0.3, random_state=42)# Initialisieren und Trainieren des Modellsmodel = LinearRegression()model.fit(X_train, Y_train)# Vorhersagen auf den Testdateny_pred = model.predict(X_test)# Evaluation des Modellsmse = mean_squared_error(Y_test, y_pred)r2 = r2_score(Y_test, y_pred)print('Mean Squared Error: ', mse)print('R^2 Score: ', r2)

Lösung:

Teilaufgabe 1: Überwachtes Lernen

Du wirst ein überwachtes Modell zur Vorhersage der Zielvariable Y trainieren. Verwende dafür einen Datensatz, der aus 70% Trainingsdaten und 30% Testdaten besteht. Du kannst hierfür einen Algorithmus Deiner Wahl verwenden. Zuerst werden wir eine lineare Regression implementieren. Dabei sind die folgenden Schritte erforderlich:

• Teile den Datensatz in Trainings- und Testdaten auf.
• Trainiere das Modell auf den Trainingsdaten.
• Evaluiere die Modellleistung auf den Testdaten mittels geeigneter Metriken (z.B. MSE, R^2).

Der Zielwert (Y) ist kontinuierlich. Verwende den folgenden Codeblock und vervollständige ihn:

import numpy as npimport pandas as pdfrom sklearn.model_selection import train_test_splitfrom sklearn.linear_model import LinearRegressionfrom sklearn.metrics import mean_squared_error, r2_score# Laden des Datensatzesdata = pd.read_csv('your_dataset.csv')# Aufteilen der Daten in Features (X) und Zielvariable (Y)X = data.drop('Zielvariable', axis=1)Y = data['Zielvariable']# Aufteilen der Daten in Trainings- und TestdatenX_train, X_test, Y_train, Y_test = train_test_split(X, Y, test_size=0.3, random_state=42)# Initialisieren und Trainieren des Modellsmodel = LinearRegression()model.fit(X_train, Y_train)# Vorhersagen auf den Testdateny_pred = model.predict(X_test)# Evaluation des Modellsmse = mean_squared_error(Y_test, y_pred)r2 = r2_score(Y_test, y_pred)print('Mean Squared Error: ', mse)print('R^2 Score: ', r2)

b)

Teilaufgabe 2: Unüberwachtes Lernen

Nun wird ein unüberwachter Lernalgorithmus verwendet, um Muster in den Daten zu entdecken. Hierfür wirst Du den K-Means-Algorithmus zur Clusterbildung anwenden. Gehe dabei wie folgt vor:

• Wähle eine geeignete Anzahl an Clustern (k) und begründe Deine Wahl.
• Trainiere das K-Means-Modell auf den Daten.
• Evaluiere die Clusterbildung anhand passender Metriken (z.B. Silhouette-Score).
• Visualisiere die Cluster, indem Du die Daten auf zwei Hauptkomponenten reduzierst (z.B. mittels PCA) und darstellst.

Verwende den folgenden Codeblock und vervollständige ihn:

import numpy as npimport pandas as pdfrom sklearn.cluster import KMeansfrom sklearn.decomposition import PCAfrom sklearn.metrics import silhouette_scoreimport matplotlib.pyplot as plt# Laden des Datensatzesdata = pd.read_csv('your_dataset.csv')# Initialisieren und Trainieren des K-Means-Modellsk = 3  # Anzahl der Clusterdie_reason_dafür = 'bitte hier begründen'kmeans = KMeans(n_clusters=k, random_state=42)kmeans.fit(data)# Vorhersagen der Clusterclusters = kmeans.predict(data)# Evaluation des Modellssil_score = silhouette_score(data, clusters)print('Silhouette Score: ', sil_score)# Reduzierung der Daten auf 2 Hauptkomponentenpca = PCA(n_components=2)reduced_data = pca.fit_transform(data)# Visualisieren der Clusterplt.scatter(reduced_data[:, 0], reduced_data[:, 1], c=clusters)plt.xlabel('Hauptkomponente 1')plt.ylabel('Hauptkomponente 2')plt.title('K-Means Clusterbildung')plt.show()

Lösung:

Teilaufgabe 2: Unüberwachtes Lernen

Nun wird ein unüberwachter Lernalgorithmus verwendet, um Muster in den Daten zu entdecken. Hierfür wirst Du den K-Means-Algorithmus zur Clusterbildung anwenden. Gehe dabei wie folgt vor:

• Wähle eine geeignete Anzahl an Clustern (k) und begründe Deine Wahl.
• Trainiere das K-Means-Modell auf den Daten.
• Evaluiere die Clusterbildung anhand passender Metriken (z.B. Silhouette-Score).
• Visualisiere die Cluster, indem Du die Daten auf zwei Hauptkomponenten reduzierst (z.B. mittels PCA) und darstellst.

Hier ist der vollständige Codeblock:

import numpy as npimport pandas as pdfrom sklearn.cluster import KMeansfrom sklearn.decomposition import PCAfrom sklearn.metrics import silhouette_scoreimport matplotlib.pyplot as plt# Laden des Datensatzesdata = pd.read_csv('your_dataset.csv')# Anzahl der Cluster wählen und begründenk = 3  # Beispielsweise könnte diese Wahl auf Basis einer Elbow-Methode oder Vorwissen über den Datensatz getroffen werden.die_reason_dafür = 'Die Wahl der drei Cluster basiert auf der Analyse des Elbow-Diagramms, das einen deutlichen Knick bei k=3 zeigt. Dies deutet darauf hin, dass 3 Cluster eine gute Balance zwischen Einfachheit und Detailgenauigkeit bieten.'# Initialisieren und Trainieren des K-Means-Modellskmeans = KMeans(n_clusters=k, random_state=42)kmeans.fit(data)# Vorhersagen der Clusterclusters = kmeans.predict(data)# Evaluation des Modellssil_score = silhouette_score(data, clusters)print('Silhouette Score: ', sil_score)# Reduzierung der Daten auf 2 Hauptkomponentenpca = PCA(n_components=2)reduced_data = pca.fit_transform(data)# Visualisieren der Clusterplt.scatter(reduced_data[:, 0], reduced_data[:, 1], c=clusters)plt.xlabel('Hauptkomponente 1')plt.ylabel('Hauptkomponente 2')plt.title('K-Means Clusterbildung')plt.show()

Zu den einzelnen Schritten:

• Anzahl der Cluster wählen und begründen: Um die geeignete Anzahl an Clustern zu bestimmen, kannst Du die Elbow-Methode anwenden, bei der die Summe der quadratischen Abstände innerhalb der Cluster (Inertia) geplottet wird. Der Punkt, an dem eine signifikante Reduktion auftritt und danach nur noch geringe Verbesserungen erzielt werden, ist eine gute Wahl für k.
• Trainiere das K-Means-Modell: Das K-Means-Modell wird auf den gesamten Datensatz trainiert, da wir in diesem Fall keine vorher festgelegten Labels haben.
• Evaluation der Clusterbildung: Der Silhouette-Score misst, wie ähnlich ein Punkt zu den Punkten in seinem eigenen Cluster im Vergleich zu Punkten in anderen Clustern ist. Er gibt damit eine Vorstellung über die Qualität der Clusterbildung.
• Visualisierung der Cluster: Um die Clusterbildung anschaulicher darzustellen, reduzieren wir die Daten mit PCA (Principal Component Analysis) auf zwei Hauptkomponenten und plotten diese.

Aufgabe 2)

Stell Dir vor, Du arbeitest als Datenwissenschaftler in einem Forschungsprojekt, das sich mit der Gesundheitsüberwachung von Patienten befasst. Du hast Zugriff auf verschiedene Datensätze, die Patienteninformationen und medizinische Aufzeichnungen enthalten. Deine Aufgabe besteht darin, verschiedene Machine Learning Techniken anzuwenden, um wertvolle Erkenntnisse aus den Daten zu gewinnen.

a)

Du sollst ein Modell erstellen, das den Blutdruck eines Patienten basierend auf verschiedenen Merkmalen wie Alter, Gewicht, Cholesterinwerten und anderen Vitalparametern vorhersagt. Wähle den geeigneten Algorithmus für diese Aufgabe und erkläre, warum dieser Algorithmus geeignet ist. Implementiere eine einfache Version des Modells in Python.

 import numpy as np  from sklearn.model_selection import train_test_split  from sklearn.linear_model import LinearRegression  from sklearn.metrics import mean_squared_error   # Annahme: Daten sind bereits geladen und in Variablen X und y gespeichert  X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=42)  model = LinearRegression()  model.fit(X_train, y_train)  y_pred = model.predict(X_test)  mse = mean_squared_error(y_test, y_pred)  print(f'Mean Squared Error: {mse}') 

Lösung:

Hier ist eine detaillierte Lösung für die Aufgabe:

Algorithmus Auswahl:

• Linear Regression: Für diese Aufgabe wählen wir die lineare Regression. Dies liegt daran, dass die lineare Regression ein einfacher und interpretierbarer Algorithmus ist, der gut funktioniert, wenn ein linearer Zusammenhang zwischen den Eingabevariablen (Alter, Gewicht, Cholesterinwerte usw.) und der Zielvariablen (Blutdruck) besteht. In der medizinischen Forschung ist es oft wichtig, Modelle zu verwenden, die leicht interpretierbar sind, um die Beziehung zwischen verschiedenen Merkmalen zu verstehen.

Implementierung:

import numpy as np from sklearn.model_selection import train_test_split from sklearn.linear_model import LinearRegression from sklearn.metrics import mean_squared_error # Annahme: Daten sind bereits geladen und in Variablen X und y gespeichert X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=42) model = LinearRegression() model.fit(X_train, y_train) y_pred = model.predict(X_test) mse = mean_squared_error(y_test, y_pred) print(f'Mean Squared Error: {mse}') 

In diesem Python-Code führen wir die folgenden Schritte durch:

• Datenaufteilung: Wir teilen die Daten in Trainings- und Testdatensätze mit einem Verhältnis von 80:20 auf.
• Modelltraining: Wir erstellen ein lineares Regressionsmodell und trainieren es mit den Trainingsdaten.
• Vorhersage: Wir verwenden das trainierte Modell, um Vorhersagen auf dem Testdatensatz zu machen.
• Fehlermessung: Wir berechnen den mittleren quadratischen Fehler (Mean Squared Error, MSE), um die Genauigkeit des Modells zu bewerten.

Der Mean Squared Error (MSE) gibt uns eine Vorstellung davon, wie gut das Modell die Blutdruckwerte vorhersagen kann. Ein niedriger MSE-Wert deutet auf ein gutes Modell hin.

b)

Ein weiterer Teil des Projekts erfordert die Einteilung der Patienten in verschiedene Risikogruppen basierend auf ihren gesundheitlichen Daten. Bestimme den passenden Typ von Machine Learning Algorithmus und erkläre, warum dieser für die Aufgabe geeignet ist. Implementiere eine Beispiel-Klassifikation in Python.

 from sklearn.model_selection import train_test_split  from sklearn.neighbors import KNeighborsClassifier  from sklearn.metrics import accuracy_score   # Annahme: Daten sind bereits geladen und in Variablen X und y gespeichert  X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=42)  classifier = KNeighborsClassifier(n_neighbors=5)  classifier.fit(X_train, y_train)  y_pred = classifier.predict(X_test)  accuracy = accuracy_score(y_test, y_pred)  print(f'Accuracy: {accuracy}') 

Lösung:

Hier ist eine detaillierte Lösung für die Einteilung der Patienten in verschiedene Risikogruppen:

Algorithmus Auswahl:

• K-Nearest Neighbors (KNN): Für diese Klassifikationsaufgabe wählen wir den K-Nearest Neighbors (KNN)-Algorithmus. Der KNN-Algorithmus ist einfach zu implementieren und liefert oft gute Ergebnisse bei Klassifikationsaufgaben. Er basiert auf der Idee, dass ähnliche Datenpunkte (Patienten mit ähnlichen gesundheitlichen Parametern) wahrscheinlich der gleichen Klasse (Risikogruppe) angehören. KNN ist nicht linear, was bedeutet, dass es nicht auf Annahmen über die Verteilung der Daten angewiesen ist.

Implementierung:

from sklearn.model_selection import train_test_splitfrom sklearn.neighbors import KNeighborsClassifierfrom sklearn.metrics import accuracy_score# Annahme: Daten sind bereits geladen und in Variablen X und y gespeichertX_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=42)classifier = KNeighborsClassifier(n_neighbors=5)classifier.fit(X_train, y_train)y_pred = classifier.predict(X_test)accuracy = accuracy_score(y_test, y_pred)print(f'Accuracy: {accuracy}') 

In diesem Python-Code führen wir die folgenden Schritte durch:

• Datenaufteilung: Wir teilen die Daten in Trainings- und Testdatensätze mit einem Verhältnis von 80:20 auf.
• Modelltraining: Wir erstellen einen K-Nearest Neighbors-Klassifikator und trainieren ihn mit den Trainingsdaten.
• Vorhersage: Wir verwenden den trainierten Klassifikator, um Vorhersagen auf dem Testdatensatz zu machen.
• Genauigkeitsmessung: Wir berechnen die Genauigkeit des Modells, um zu bewerten, wie gut es die Risikogruppen der Patienten vorhersagen kann.

Die Genauigkeit gibt uns eine Vorstellung davon, wie oft das Modell die richtigen Risikogruppen vorhersagt. Ein hoher Genauigkeitswert deutet auf ein gutes Modell hin.

c)

Um die Daten weiter zu analysieren, möchtest Du Patienten mit ähnlichen medizinischen Profilen gruppieren. Welchen Algorithmus würdest Du verwenden und warum? Implementiere ein Beispiel in Python, um die Daten mit einem Clustering-Algorithmus zu gruppieren.

 import numpy as np  from sklearn.cluster import KMeans  import matplotlib.pyplot as plt   # Annahme: Daten sind bereits geladen und in Variable X gespeichert  kmeans = KMeans(n_clusters=3, random_state=42)  kmeans.fit(X)  clusters = kmeans.predict(X)   # Visualisierung der Cluster-Zuordnungen (falls Daten 2-dimensional)  plt.scatter(X[:, 0], X[:, 1], c=clusters, cmap='viridis')  plt.title('KMeans Clustering')  plt.show() 

Lösung:

Hier ist eine detaillierte Lösung für die Gruppierung von Patienten mit ähnlichen medizinischen Profilen:

Algorithmus Auswahl:

• KMeans Clustering: Für die Clusteranalyse wähle ich den KMeans-Algorithmus. KMeans ist ein weit verbreiteter und effizienter Clustering-Algorithmus, der Datenpunkte in eine vorgegebene Anzahl von Clustern (Gruppen) unterteilt. Der Algorithmus teilt die Daten so auf, dass die Datenpunkte innerhalb eines Clusters möglichst ähnlich und die Datenpunkte zwischen verschiedenen Clustern möglichst unähnlich sind. Dies ist besonders nützlich, um Patienten in Gruppen zu unterteilen, die auf ihren medizinischen Profilen basieren.

Implementierung:

import numpy as npfrom sklearn.cluster import KMeansimport matplotlib.pyplot as plt# Annahme: Daten sind bereits geladen und in Variable X gespeichertkmeans = KMeans(n_clusters=3, random_state=42)kmeans.fit(X)clusters = kmeans.predict(X)# Visualisierung der Cluster-Zuordnungen (falls Daten 2-dimensional)plt.scatter(X[:, 0], X[:, 1], c=clusters, cmap='viridis')plt.title('KMeans Clustering')plt.show()

In diesem Python-Code führen wir die folgenden Schritte durch:

• Daten laden: Wir gehen davon aus, dass die Daten bereits in der Variablen X gespeichert sind.
• Modellerstellung: Wir erstellen ein KMeans-Modell mit einer vorgegebenen Anzahl von Clustern (in diesem Fall 3) und einem zufälligen Startwert für die Reproduzierbarkeit.
• Modelltraining und Vorhersage: Wir passen das KMeans-Modell an die Daten an und erhalten die Cluster-Zuordnungen für jeden Datenpunkt.
• Visualisierung: Falls die Daten zweidimensional sind, erstellen wir eine Streuungsdiagramm, um die Cluster-Zuordnungen zu visualisieren.

Die Visualisierung hilft uns zu verstehen, wie die Patienten basierend auf ihren medizinischen Profilen in verschiedene Gruppen unterteilt werden. Dies kann wertvolle Einblicke in die Verteilung und Ähnlichkeiten der Patienten bieten.

d)

In einem letzten Schritt sollst Du Regeln identifizieren, die häufig zusammen vorkommende Erkrankungen bei den Patienten beschreiben. Welchen Algorithmus würdest Du verwenden und warum? Implementiere ein Beispiel in Python mit fiktiven Daten.

 from apyori import apriori   transactions = [['Diabetes', 'Bluthochdruck'],                  ['Krebs', 'Diabetes'],                  ['Bluthochdruck', 'Herzkrankheit'],                  ['Herzkrankheit']]   rules = apriori(transactions, min_support=0.5, min_confidence=0.7)  results = list(rules)  for result in results:      print(result) 

Lösung:

Hier ist eine detaillierte Lösung zur Identifizierung von Regeln, die häufig zusammen vorkommende Erkrankungen beschreiben:

Algorithmus Auswahl:

• Apriori-Algorithmus: Für diese Aufgabe wählen wir den Apriori-Algorithmus. Der Apriori-Algorithmus wird oft in der Assoziationsanalyse verwendet, um häufig auftretende Muster in großen Datenmengen zu identifizieren. In diesem Fall möchten wir häufig gemeinsam auftretende Erkrankungen unter den Patienten finden. Der Apriori-Algorithmus hilft dabei, Assoziationsregeln zu entdecken, die uns diese häufigen Zusammenhänge zeigen.

Implementierung:

from apyori import apriori# Fiktive Daten: Listen mit Erkrankungen für verschiedene Patiententransactions = [['Diabetes', 'Bluthochdruck'],                 ['Krebs', 'Diabetes'],                 ['Bluthochdruck', 'Herzkrankheit'],                 ['Herzkrankheit']]# Apriori-Algorithmus anwendenrules = apriori(transactions, min_support=0.5, min_confidence=0.7)results = list(rules)# Ergebnisse ausgebenfor result in results:    print(result)

In diesem Python-Code führen wir die folgenden Schritte durch:

• Daten vorbereiten: Wir definieren fiktive Daten als Listen von Erkrankungen für verschiedene Patienten.
• Apriori-Algorithmus anwenden: Wir verwenden die apriori-Funktion aus dem apyori-Paket, um auf diese Daten den Apriori-Algorithmus anzuwenden. Wir setzen min_support auf 0.5, um nur Regeln zu finden, die in mindestens 50% der Transaktionen auftreten, und min_confidence auf 0.7, um nur Regeln mit einer Vertrauenswürdigkeit von mindestens 70% zu berücksichtigen.
• Ergebnisse ausgeben: Wir konvertieren die Ergebnisse in eine Liste und geben jede gefundene Regel aus.

Die ausgegebenen Regeln zeigen uns häufig gemeinsam auftretende Erkrankungen, basierend auf den definierten Support- und Konfidenzschwellen. Diese Regeln können wichtige Einblicke in die Zusammenhänge zwischen verschiedenen Erkrankungen bieten und dabei helfen, präventive Maßnahmen oder personalisierte Behandlungsstrategien zu entwickeln.

Aufgabe 3)

In einem künstlichen neuronalen Netz (KNN) wird ein einfacher Feedforward-Netzwerk verwendet, das eine Eingabeschicht mit 3 Eingabe-Features, eine verborgene Schicht mit 4 Neuronen (unter Verwendung einer Sigmoid-Aktivierungsfunktion) und eine Ausgabeschicht mit einem Neuron (unter Verwendung der ReLU-Aktivierungsfunktion) hat. Die Zielvariable ist kontinuierlich und wir verwenden die Mean Squared Error (MSE) als Kostenfunktion. Das Netzwerk wird trainiert, um den Fehler zwischen den prognostizierten und den tatsächlichen Werten zu minimieren. Betrachte die Gewichtsmatrix W1 (3x4) für die Verbindungen von der Eingabeschicht zur versteckten Schicht und die Gewichtsmatrix W2 (4x1) für die Verbindungen von der versteckten Schicht zur Ausgabeschicht.

b)

Skizziere den Backpropagation-Prozess für dieses Netzwerk. Gehe dabei auf die Berechnung der Gradienten sowohl für W1 als auch für W2 ein. Verwende den Kettenregel, um die entsprechenden Ableitungen zu zeigen. Berücksichtige dabei die Kostenfunktion MSE. Zeige detailliert, wie die Gewichte aktualisiert werden, um den Fehler zu minimieren.

Lösung:

Backpropagation in einem Einfachen Feedforward-Netzwerk

Schritte des Backpropagation-Prozesses:

Im Backpropagation-Prozess wird der Gradient der Kostenfunktion in Bezug auf die Gewichte berechnet. Dieser Prozess hilft, die Gewichte zu aktualisieren, um den Fehler zu minimieren.

1. Berechnung der Fehler der Ausgabeschicht:

Zunächst definieren wir die Kostenfunktion MSE:

J = \frac{1}{2} (Y_{true} - Y_{pred})^2

Hierbei sind:

• Y_{true}

  die tatsächlichen Werte.

• Y_{pred}

  die prognostizierten Werte des Netzwerks.

Der Fehler der Ausgabeschicht wird berechnet als:

dL/dY = Y_{pred} - Y_{true}

2. Berechnung der Gradienten für die Ausgabeschicht:

Da die ReLU-Aktivierungsfunktion auf die Ausgabeschicht angewendet wird, ist ihre Ableitung:

ReLU'(Z2) = 1, wenn Z2 > 0; ansonsten 0

Der Gradient in Bezug auf Z2 berechnet sich somit als:

dL/dZ2 = dL/dY * ReLU'(Z2)

3. Berechnung der Gradienten für W2:

dL/dW2 = A1^T * dL/dZ2

Hierbei gilt:

• A1

  ist der Aktivierungsvektor der verborgenen Schicht.

• (^T)

  kennzeichnet die Transposition der Matrix.

4. Berechnung der Fehler der verborgenen Schicht:

dL/dA1 = dL/dZ2 * W2^T

5. Berechnung der Gradienten für die verborgene Schicht:

Da die Sigmoid-Aktivierungsfunktion auf die verborgene Schicht angewendet wird, ist ihre Ableitung:

Sigmoid'(Z1) = Sigmoid(Z1) * (1 - Sigmoid(Z1))

Die Gradienten in Bezug auf Z1 berechnen sich somit als:

dL/dZ1 = dL/dA1 * Sigmoid'(Z1)

6. Berechnung der Gradienten für W1:

dL/dW1 = X^T * dL/dZ1

Hierbei gilt:

• X

  ist der Eingabevektor.

7. Aktualisierung der Gewichte:

Die Gewichte werden mit einer Lernrate

\eta

• W2 = W2 - \eta * dL/dW2

• W1 = W1 - \eta * dL/dW1

Zusammenfassung:

Der Backpropagation-Prozess beinhaltet die Berechnung der Gradienten der Kostenfunktion in Bezug auf die Gewichte W1 und W2 durch Anwendung der Kettenregel. Durch die Aktualisierung der Gewichte mit diesen Gradienten und der Lernrate wird der Fehler minimiert und das Netzwerk verbessert seine Prognosefähigkeiten.

Aufgabe 4)

Aktivierungsfunktionen spielen eine entscheidende Rolle in der Funktionsweise von neuronalen Netzen, da sie die Einführung von Nicht-Linearität ermöglichen. Betrachte ein neuronales Netz, das zur Klassifikation von handgeschriebenen Ziffern (MNIST-Datensatz) verwendet wird. Die grundlegenden Aktivierungsfunktionen, die in diesem Netz verwendet werden, sind Sigmoid, ReLU, Tanh und Softmax. Du sollst den Einfluss dieser Aktivierungsfunktionen auf die Leistung des neuronalen Netzes sowohl theoretisch als auch praktisch analysieren.

a)

a) Wähle zwei der oben erwähnten Aktivierungsfunktionen und vergleiche ihre mathematischen Eigenschaften. Diskutiere, warum der eine Funktionssatz für die Aktivierungsschicht eines neuronalen Netzes besser geeignet sein könnte als der andere. Formuliere Deine Antwort unter Berücksichtigung der Probleme vanishing gradients und Rechenaufwand.

Lösung:

Die Auswahl einer geeigneten Aktivierungsfunktion ist entscheidend für die Leistung neuronaler Netze. Für diese Übung werden wir die Aktivierungsfunktionen Sigmoid und ReLU (Rectified Linear Unit) vergleichen.

• Sigmoid: Die Sigmoid-Funktion ist definiert als:

   \(\text{sigmoid}(x) = \frac{1}{1 + e^{-x}}\) 

  Mathematische Eigenschaften:
  • Die Ausgabewerte liegen zwischen 0 und 1.
  • Sie ist differenzierbar.
  • Die Ableitung ist definiert als:

     \(\text{sigmoid}'(x) = \text{sigmoid}(x) * (1 - \text{sigmoid}(x))\) 

  • Glättet die Werte und führt sie in einen bestimmten Bereich.
  • Probleme: Der vanishing gradient, da die Ableitungen für extreme Eingabewerte gegen 0 gehen und dadurch das Training erschwert wird.
• ReLU: Die ReLU-Funktion ist definiert als:

   \(\text{ReLU}(x) = \max(0, x)\) 

  Mathematische Eigenschaften:
  • Die Ausgabewerte liegen zwischen 0 und unendlich.
  • Sie ist nicht differenzierbar bei 0, aber differenzierbar für alle anderen Werte.
  • Die Ableitung ist definiert als:

     \(\frac{d}{dx} \text{ReLU}(x) = \begin{cases} 0 & \text{für } x < 0 \ 1 & \text{für } x > 0 \end{cases}\) 

  • Effizient in der Berechnung.
  • Probleme: Der vanishing gradient ist weniger problematisch als bei Sigmoid, allerdings kann es zum dead neuron problem kommen, wenn viele Neuronen bei negativen Eingabewerten dauerhaft 0 ausgeben.

Vergleich der Aktivierungsfunktionen

• Vanishing Gradient Problem: Die Sigmoid-Funktion neigt dazu, bei extrem positiven oder negativen Eingabewerten sehr geringe Gradienten zu produzieren, was das vanishing gradient problem verursacht. Dies erschwert das Training tiefer neuronaler Netze, da die Gewichte nur langsam oder gar nicht aktualisiert werden. Die ReLU-Funktion hat dieses Problem weniger, da ihre Ableitung konstant 1 für positive Eingabewerte ist. Allerdings kann ReLU das dead neuron Problem verursachen.
• Rechenaufwand: Die Sigmoid-Funktion erfordert die Berechnung einer Exponentialfunktion, was relativ rechenintensiv ist. Die ReLU-Funktion hingegen ist sehr effizient in der Berechnung, da lediglich eine Maximalberechnung durchgeführt wird.

Schlussfolgerung

Die Wahl der Aktivierungsfunktion hängt stark von der spezifischen Anwendung und der Architektur des neuronalen Netzes ab. ReLU ist oft bevorzugt aufgrund seiner Effizienz und der besseren Handhabung des vanishing gradient problems. Sigmoid kann in bestimmten Fällen nützlich sein, insbesondere wenn die Ausgabe in einem begrenzten Bereich liegen muss. In vielen modernen Anwendungen hat sich jedoch ReLU aufgrund seiner Vorteile durchgesetzt.

b)

b) Implementiere ein einfaches neuronales Netz in Python zur Klassifikation des MNIST-Datensatzes. Verwende hierbei die ReLU-Aktivierungsfunktion in den verborgenen Schichten und die Softmax-Aktivierungsfunktion in der Ausgangsschicht. Trainiere das Netz und bewerte seine Leistung unter Verwendung geeigneter Metriken. Nutze hierzu die Bibliothek TensorFlow oder PyTorch. Trage gegebenenfalls den Python-Code sowie die wichtigsten Ergebnisse Deiner Analyse bei.

Lösung:

Implementierung eines neuronalen Netzes zur Klassifikation des MNIST-Datensatzes

In diesem Abschnitt werden wir ein einfaches neuronales Netz in Python implementieren, das die handgeschriebenen Ziffern des MNIST-Datensatzes klassifiziert. Wir verwenden die TensorFlow-Bibliothek, wobei die ReLU-Aktivierungsfunktion in den verborgenen Schichten und die Softmax-Aktivierungsfunktion in der Ausgangsschicht verwendet wird. Anschließend wird das Netz trainiert und seine Leistung bewertet.

Python-Code

import tensorflow as tffrom tensorflow.keras.models import Sequentialfrom tensorflow.keras.layers import Dense, Flattenfrom tensorflow.keras.utils import to_categoricalfrom tensorflow.keras.datasets import mnist# MNIST-Datensatz laden(x_train, y_train), (x_test, y_test) = mnist.load_data()# Normalisierung der Eingabedatenx_train, x_test = x_train / 255.0, x_test / 255.0# Labels in One-Hot-Encoding umwandelny_train, y_test = to_categorical(y_train), to_categorical(y_test)# Modell erstellenmodel = Sequential([    Flatten(input_shape=(28, 28)),    Dense(128, activation='relu'),    Dense(64, activation='relu'),    Dense(10, activation='softmax')])# Modell kompilierenmodel.compile(optimizer='adam',              loss='categorical_crossentropy',              metrics=['accuracy'])# Modell trainierenmodel.fit(x_train, y_train, epochs=10, batch_size=32, validation_split=0.2)# Modell bewertenloss, accuracy = model.evaluate(x_test, y_test)print(f'Loss: {loss}, Accuracy: {accuracy}')

Ergebnisse der Analyse

Nach dem Training des neuronalen Netzes über 10 Epochen wurde das Modell mit den Testdaten bewertet. Die wichtigsten Metriken zur Bewertung des Modells sind Verlust (Loss) und Genauigkeit (Accuracy).

• Loss: Ein Maß für den Fehler des Modells bei den Testbeispielen. Ein niedriger Loss-Wert bedeutet, dass das Modell die Daten gut gelernt hat.
• Accuracy: Der Anteil der richtig klassifizierten Testbeispiele. Eine höhere Genauigkeit zeigt, dass das Modell eine gute Leistung in der Klassifikation der handgeschriebenen Ziffern erbringt.

Für dieses Beispiel könnte die Ausgabe wie folgt aussehen (die tatsächlichen Werte können variieren):

Loss: 0.073, Accuracy: 0.978

Dieser Ergebnis zeigt, dass das neuronale Netz eine hohe Genauigkeit von etwa 97.8% bei der Klassifikation der handgeschriebenen Ziffern erreicht. Dies deutet auf eine effektive Lernkapazität des Modells hin.

Insgesamt zeigt dieses Beispiel, wie die Verwendung von ReLU in den verborgenen Schichten und Softmax in der Ausgangsschicht zu einer effektiven Klassifikation führen kann.