Projekt Maschinelles Lernen und Datenanalytik - Exam

Aufgabe 1)

Lineare Regression und KlassifikationDie lineare Regression ist eine Methode zur Modellierung der Beziehung zwischen einer abhängigen und einer unabhängigen Variable, erfasst durch eine lineare Gleichung. Im Gegensatz dazu ist die Klassifikation ein Verfahren zur Einordnung von Datenpunkten in vordefinierte Kategorien. Hier sind einige grundlegende Definitionen und Formeln:

• Lineare Regression:
  • Modell: \( y = \beta_0 + \beta_1 x + \epsilon \)
  • Koeffizienten \( \beta_0 \) und \( \beta_1 \) werden durch die Minimierung des Mittleren Quadratischen Fehlers (MSE) geschätzt.
  • MSE: \( \frac{1}{n} \sum_{i=1}^n (y_i - \hat{y}_i)^2 \)
• Klassifikation:
  • Ziel: Vorhersage der Kategorie (Klasse) eines Datenpunktes anhand seiner Merkmale.
  • Beispielverfahren: k-Nächste-Nachbarn (k-NN), Support Vector Machines (SVM).
  • Qualität: Gemessen durch Genauigkeit (accuracy), Präzision (precision), und Recall.

a)

Gegeben sei ein Datensatz mit den Wertepaaren \((x_i, y_i)\) für \(i = 1, 2, ..., n\). Die Beziehung zwischen \(x\) und \(y\) soll durch eine einfache lineare Regression modelliert werden.

• (a) Leite die Gleichungen zur Schätzung der Koeffizienten \( \beta_0 \) und \( \beta_1 \) her, indem der Mittlere Quadratische Fehler (MSE) minimiert wird.

Lösung:

Lineare Regression und KlassifikationDie lineare Regression ist eine Methode zur Modellierung der Beziehung zwischen einer abhängigen und einer unabhängigen Variable, erfasst durch eine lineare Gleichung. Im Gegensatz dazu ist die Klassifikation ein Verfahren zur Einordnung von Datenpunkten in vordefinierte Kategorien. Hier sind einige grundlegende Definitionen und Formeln:

• Lineare Regression:
  • Modell: \( y = \beta_0 + \beta_1 x + \epsilon \)
  • Koeffizienten \( \beta_0 \) und \( \beta_1 \) werden durch die Minimierung des Mittleren Quadratischen Fehlers (MSE) geschätzt.
  • MSE: \( \frac{1}{n} \, \sum_{i=1}^n (y_i - \hat{y}_i)^2 \)
• Klassifikation:
  • Ziel: Vorhersage der Kategorie (Klasse) eines Datenpunktes anhand seiner Merkmale.
  • Beispielverfahren: k-Nächste-Nachbarn (k-NN), Support Vector Machines (SVM).
  • Qualität: Gemessen durch Genauigkeit (accuracy), Präzision (precision), und Recall.

Lösung der Teilaufgabe:

• (a) Leite die Gleichungen zur Schätzung der Koeffizienten \( \beta_0 \) und \( \beta_1 \) her, indem der Mittlere Quadratische Fehler (MSE) minimiert wird.

Um die Koeffizienten \( \beta_0 \) und \( \beta_1 \) zu schätzen, minimieren wir den Mittleren Quadratischen Fehler (MSE). Der MSE ist definiert als:

• \( MSE = \frac{1}{n} \, \sum_{i=1}^n (y_i - \hat{y}_i)^2 \)

Hierbei ist \( \hat{y}_i \) die vorhergesagte Abhängige Variable, also:

• \( \hat{y}_i = \beta_0 + \beta_1 x_i \)

Unser Ziel ist es nun, die Werte für \( \beta_0 \) und \( \beta_1 \) zu finden, die den MSE minimieren. Dafür leiten wir den MSE nach \( \beta_0 \) und \( \beta_1 \) ab und setzen diese Ableitungen gleich null (notwendige Bedingung für ein Minimum):

• \( \frac{\partial MSE}{\partial \beta_0} = 0 \)
• \( \frac{\partial MSE}{\partial \beta_1} = 0 \)

Starten wir mit der Ableitung von MSE nach \( \beta_0 \):

• \( \frac{\partial MSE}{\partial \beta_0} = \frac{1}{n} \, \sum_{i=1}^n -2 (y_i - (\beta_0 + \beta_1 x_i)) \)
• \( 0 = \sum_{i=1}^n -2 (y_i - \beta_0 - \beta_1 x_i) \)
• \( 0 = -2 \sum_{i=1}^n (y_i - \beta_0 - \beta_1 x_i) \)
• \( 0 = \sum_{i=1}^n y_i - n \beta_0 - \beta_1 \sum_{i=1}^n x_i \)
• \( \beta_0 = \frac{\sum_{i=1}^n y_i - \beta_1 \sum_{i=1}^n x_i}{n} \)
• \( \beta_0 = \bar{y} - \beta_1 \bar{x} \)

Hierbei sind \( \bar{x} \) und \( \bar{y} \) die Mittelwerte von \( x \) bzw. \( y \).Als nächstes leiten wir den MSE nach \( \beta_1 \) ab und setzen die Ableitung gleich null:

• \( \frac{\partial MSE}{\partial \beta_1} = \frac{1}{n} \, \sum_{i=1}^n -2 x_i (y_i - (\beta_0 + \beta_1 x_i)) \)
• \( 0 = -2 \sum_{i=1}^n x_i (y_i - \beta_0 - \beta_1 x_i) \)
• \( 0 = \sum_{i=1}^n x_i y_i - \beta_0 \sum_{i=1}^n x_i - \beta_1 \sum_{i=1}^n x_i^2 \)

Ersetze \( \beta_0 \) aus obiger Gleichung:

• \( \beta_0 = \bar{y} - \beta_1 \bar{x} \)

Dann haben wir:

• \( 0 = \sum_{i=1}^n x_i y_i - (\bar{y} - \beta_1 \bar{x}) \sum_{i=1}^n x_i - \beta_1 \sum_{i=1}^n x_i^2 \)
• \( 0 = \sum_{i=1}^n x_i y_i - \bar{y} \sum_{i=1}^n x_i + \beta_1 \bar{x} \sum_{i=1}^n x_i - \beta_1 \sum_{i=1}^n x_i^2 \)
• \( 0 = \sum_{i=1}^n x_i y_i - n \bar{y} \bar{x} + \beta_1 n \bar{x}^2 - \beta_1 \sum_{i=1}^n x_i^2 \)
• \( 0 = \sum_{i=1}^n x_i y_i - n \bar{y} \bar{x} - \beta_1 \left( \sum_{i=1}^n x_i^2 - n \bar{x}^2\right) \)
• \( \beta_1 = \frac{\sum_{i=1}^n x_i y_i - n \bar{x} \bar{y}}{\sum_{i=1}^n x_i^2 - n \bar{x}^2} \)

Daher sind die Schätzungen für die Koeffizienten \( \beta_0 \) und \( \beta_1 \)

• \( \beta_1 = \frac{\sum_{i=1}^n (x_i - \bar{x})(y_i - \bar{y})}{\sum_{i=1}^n (x_i - \bar{x})^2} \)
• \( \beta_0 = \bar{y} - \beta_1 \bar{x} \)

Dies sind die Gleichungen zur Schätzung der Koeffizienten in einer einfachen linearen Regression.

b)

Simuliere einen linearen Datensatz in Python mit 100 Datenpunkten, wobei \(x\) Zufallszahlen sind und \(y\) nach dem Modell \( y = 3 + 2x + \epsilon \) generiert wird, wobei \( \epsilon \) ein normalverteilter Zufallsfehler ist.

• (b) Schreibe den Python-Code, um die Daten zu generieren und die lineare Regression durchzuführen. Stelle sicher, dass auch die berechneten Koeffizienten ausgegeben werden.

Lösung:

Lineare Regression und KlassifikationDie lineare Regression ist eine Methode zur Modellierung der Beziehung zwischen einer abhängigen und einer unabhängigen Variable, erfasst durch eine lineare Gleichung. Im Gegensatz dazu ist die Klassifikation ein Verfahren zur Einordnung von Datenpunkten in vordefinierte Kategorien. Hier sind einige grundlegende Definitionen und Formeln:

• Lineare Regression:
  • Modell: \( y = \beta_0 + \beta_1 x + \epsilon \)
  • Koeffizienten \( \beta_0 \) und \( \beta_1 \) werden durch die Minimierung des Mittleren Quadratischen Fehlers (MSE) geschätzt.
  • MSE: \( \frac{1}{n} \sum_{i=1}^n (y_i - \hat{y}_i)^2 \)
• Klassifikation:
  • Ziel: Vorhersage der Kategorie (Klasse) eines Datenpunktes anhand seiner Merkmale.
  • Beispielverfahren: k-Nächste-Nachbarn (k-NN), Support Vector Machines (SVM).
  • Qualität: Gemessen durch Genauigkeit (accuracy), Präzision (precision), und Recall.

Lösung der Teilaufgabe:

• (b) Simuliere einen linearen Datensatz in Python mit 100 Datenpunkten, wobei \(x\) Zufallszahlen sind und \(y\) nach dem Modell \( y = 3 + 2x + \epsilon \) generiert wird, wobei \( \epsilon \) ein normalverteilter Zufallsfehler ist. Schreibe den Python-Code, um die Daten zu generieren und die lineare Regression durchzuführen. Stelle sicher, dass auch die berechneten Koeffizienten ausgegeben werden.

Hier ist der Python-Code zur Simulation des Datensatzes und zur Durchführung der linearen Regression:

import numpy as npimport matplotlib.pyplot as pltfrom sklearn.linear_model import LinearRegression# Zufallszahlen generierennp.random.seed(0)  # Für Reproduzierbarkeitx = np.random.rand(100, 1)  # 100 Zufallszahlen zwischen 0 und 1epsilon = np.random.normal(0, 1, (100, 1))  # Normalverteilte Zufallsfehler# y nach dem Modell generierenbeta_0 = 3beta_1 = 2y = beta_0 + beta_1 * x + epsilon# Lineare Regression durchführenmodel = LinearRegression()model.fit(x, y)# Koeffizienten berechnenbeta_0_hat = model.intercept_[0]beta_1_hat = model.coef_[0][0]# Ergebnisse ausgebenprint(f'Geschätzter Koeffizient beta_0: {beta_0_hat}')print(f'Geschätzter Koeffizient beta_1: {beta_1_hat}')# Plot der Daten und das Regressionsmodellplt.scatter(x, y, color='blue', label='Datenpunkte')plt.plot(x, model.predict(x), color='red', label='Regression Linie')plt.xlabel('x')plt.ylabel('y')plt.title('Lineare Regression')plt.legend()plt.show()

Der Code erzeugt 100 Zufallszahlen für \(x\), generiert \(y\) nach dem Modell \( y = 3 + 2x + \epsilon \) und verwendet die LinearRegression-Klasse aus sklearn, um die lineare Regression durchzuführen. Anschließend werden die geschätzten Koeffizienten \( \beta_0 \) und \( \beta_1 \) ausgegeben und die Daten sowie die Regressionslinie geplottet.

c)

Angenommen, Du hast einen Klassifikationsdatensatz, der drei Klassen mit den Merkmalen \( (x_1, x_2) \) umfasst.

• (c) Erkläre das k-Nächste-Nachbarn (k-NN) Verfahren und wie die vorhersagende Klasse für einen neuen Datenpunkt bestimmt wird. Implementiere das k-NN Verfahren in Python.

Lösung:

Lineare Regression und KlassifikationDie lineare Regression ist eine Methode zur Modellierung der Beziehung zwischen einer abhängigen und einer unabhängigen Variable, erfasst durch eine lineare Gleichung. Im Gegensatz dazu ist die Klassifikation ein Verfahren zur Einordnung von Datenpunkten in vordefinierte Kategorien. Hier sind einige grundlegende Definitionen und Formeln:

• Lineare Regression:
  • Modell: \( y = \beta_0 + \beta_1 x + \epsilon \)
  • Koeffizienten \( \beta_0 \) und \( \beta_1 \) werden durch die Minimierung des Mittleren Quadratischen Fehlers (MSE) geschätzt.
  • MSE: \( \frac{1}{n} \sum_{i=1}^n (y_i - \hat{y}_i)^2 \)
• Klassifikation:
  • Ziel: Vorhersage der Kategorie (Klasse) eines Datenpunktes anhand seiner Merkmale.
  • Beispielverfahren: k-Nächste-Nachbarn (k-NN), Support Vector Machines (SVM).
  • Qualität: Gemessen durch Genauigkeit (accuracy), Präzision (precision), und Recall.

Lösung der Teilaufgabe:

• (c) Erkläre das k-Nächste-Nachbarn (k-NN) Verfahren und wie die vorhersagende Klasse für einen neuen Datenpunkt bestimmt wird. Implementiere das k-NN Verfahren in Python.

Erklärung des k-Nächste-Nachbarn (k-NN) Verfahrens:

• Das k-Nächste-Nachbarn (k-NN) Verfahren ist ein einfaches, nicht-parametrisches Klassifikationsverfahren. Es kategorisiert einen neuen Datenpunkt basierend auf den Klassen der k nächstgelegenen Datenpunkte in einem Merkmalsraum.
• Um die vorhersagende Klasse für einen neuen Datenpunkt zu bestimmen, folgen diese Schritte:
• Berechne die Abstände vom neuen Datenpunkt zu allen anderen Datenpunkten im Datensatz.
• Wähle die k Datenpunkte aus, die die kürzesten Abstände zum neuen Datenpunkt haben.
• Bestimme die häufigste Klasse unter diesen k nächsten Nachbarn.
• Wähle die häufigste Klasse als die vorhersagende Klasse für den neuen Datenpunkt.

Python-Implementierung des k-NN Verfahrens:

import numpy as npfrom sklearn.datasets import make_classificationfrom collections import Counter# Funktion zur Berechnung der euklidischen Distanzdef euclidean_distance(point1, point2):    return np.sqrt(np.sum((point1 - point2) ** 2))# k-NN Algorithmusdef k_nearest_neighbors(X_train, y_train, X_test, k):    predictions = []    for test_point in X_test:        distances = []        for i, train_point in enumerate(X_train):            distance = euclidean_distance(test_point, train_point)            distances.append((distance, y_train[i]))        # Sortiere nach Abstand        distances.sort(key=lambda x: x[0])        # Wähle die k nächsten Nachbarn        k_nearest = distances[:k]        # Bestimme die am häufigsten vorkommende Klasse        k_nearest_classes = [neighbor[1] for neighbor in k_nearest]        predicted_class = Counter(k_nearest_classes).most_common(1)[0][0]        predictions.append(predicted_class)    return predictions# Beispiel-Datensatz erzeugenX, y = make_classification(n_samples=100, n_features=2, n_informative=2, n_redundant=0, n_classes=3, random_state=42)# Trainings- und Testdaten aufteilennp.random.seed(42)indices = np.random.permutation(len(X))train_size = int(0.8 * len(X))X_train, X_test = X[indices[:train_size]], X[indices[train_size:]]y_train, y_test = y[indices[:train_size]], y[indices[train_size:]]# k-NN anwendenk = 3predictions = k_nearest_neighbors(X_train, y_train, X_test, k)# Ergebnisse ausgebenprint('Vorhersagen:', predictions)print('Tatsächliche Klassen:', y_test)

In diesem Code werden:

• make_classification aus sklearn.datasets verwendet, um einen Beispieldatensatz mit drei Klassen zu erzeugen.
• Die euklidische Distanz zwischen Punkten wird mittels euclidean_distance Funktion berechnet.
• Das k-NN Verfahren in der k_nearest_neighbors Funktion implementiert, wobei die k nächsten Nachbarn für einen neuen Datenpunkt gesucht werden.
• Die häufigste Klasse unter den k nächsten Nachbarn als Vorhersage verwendet.
• Schließlich werden die Vorhersagen und tatsächlichen Klassen der Testdaten ausgegeben.

d)

Die Performance eines Klassifikationsmodells wird oft durch Genauigkeit, Präzision und Recall gemessen.

• (d) Definiere diese Metriken mathematisch und erkläre, wie Du sie in einem konkreten Beispiel mit einem gegebenen Satz von Vorhersagen und tatsächlichen Klassenwerten berechnest. Berechne die Metriken für das folgende Beispiel: 20 tatsächliche positive Klassen, 5 falsch positive Vorhersagen und 3 falsch negative Vorhersagen.

Lösung:

Lineare Regression und KlassifikationDie lineare Regression ist eine Methode zur Modellierung der Beziehung zwischen einer abhängigen und einer unabhängigen Variable, erfasst durch eine lineare Gleichung. Im Gegensatz dazu ist die Klassifikation ein Verfahren zur Einordnung von Datenpunkten in vordefinierte Kategorien. Hier sind einige grundlegende Definitionen und Formeln:

• Lineare Regression:
  • Modell: \( y = \beta_0 + \beta_1 x + \epsilon \)
  • Koeffizienten \( \beta_0 \) und \( \beta_1 \) werden durch die Minimierung des Mittleren Quadratischen Fehlers (MSE) geschätzt.
  • MSE: \( \frac{1}{n} \sum_{i=1}^n (y_i - \hat{y}_i)^2 \)
• Klassifikation:
  • Ziel: Vorhersage der Kategorie (Klasse) eines Datenpunktes anhand seiner Merkmale.
  • Beispielverfahren: k-Nächste-Nachbarn (k-NN), Support Vector Machines (SVM).
  • Qualität: Gemessen durch Genauigkeit (accuracy), Präzision (precision), und Recall.

Lösung der Teilaufgabe:

• (d) Definiere diese Metriken mathematisch und erkläre, wie Du sie in einem konkreten Beispiel mit einem gegebenen Satz von Vorhersagen und tatsächlichen Klassenwerten berechnest. Berechne die Metriken für das folgende Beispiel: 20 tatsächliche positive Klassen, 5 falsch positive Vorhersagen und 3 falsch negative Vorhersagen.

Definition der Metriken:

• Genauigkeit (Accuracy): Der Anteil der korrekt vorhergesagten Datenpunkte an den gesamten Datenpunkten. Mathematisch ist dies definiert als:
  • \[ \text{Genauigkeit} = \frac{\text{Anzahl der richtigen Vorhersagen}}{\text{Gesamtzahl der Vorhersagen}} \]
• Präzision (Precision): Der Anteil der tatsächlich positiven Vorhersagen unter den als positiv vorhergesagten Datenpunkten. Mathematisch ist dies definiert als:
  • \[ \text{Präzision} = \frac{\text{Anzahl der echten Positiven}}{\text{Anzahl der echten Positiven} + \text{Anzahl der falschen Positiven}} \]
• Recall: Der Anteil der korrekt identifizierten positiven Datenpunkte unter allen tatsächlichen positiven Datenpunkten. Mathematisch ist dies definiert als:
  • \[ \text{Recall} = \frac{\text{Anzahl der echten Positiven}}{\text{Anzahl der echten Positiven} + \text{Anzahl der falschen Negativen}} \]

Berechnung der Metriken für das gegebene Beispiel:

• Gegeben:
• 20 tatsächliche positive Klassen (denken wir an sie als echte positive Einträge, TP)
• 5 falsch positive Vorhersagen (FP)
• 3 falsch negative Vorhersagen (FN)
• Die Anzahl der echten negativen Klassen (TN) ist unbekannt, aber wir können dennoch Präzision und Recall berechnen. Um die Genauigkeit zu berechnen, nehmen wir an, dass die Gesamtzahl der Vorhersagen bekannt ist.

Präzision:

• \[ \text{Präzision} = \frac{\text{TP}}{\text{TP} + \text{FP}} = \frac{20}{20 + 5} = \frac{20}{25} = 0{,}8 \]

Recall:

• \[ \text{Recall} = \frac{\text{TP}}{\text{TP} + \text{FN}} = \frac{20}{20 + 3} = \frac{20}{23} \approx 0{,}8696 \]

Genauigkeit:

• Um die Genauigkeit zu berechnen, benötigen wir die Gesamtzahl der Vorhersagen (N). Angenommen, wir kennen N, dann ist:\[ \text{Genauigkeit} = \frac{\text{TP} + \text{TN}}{N} \]Da die Anzahl der tatsächlichen positiven und negativen Klassen unbekannt ist, kann die Genauigkeit anhand der verfügbaren Informationen nicht direkt berechnet werden.

Aufgabe 2)

Clustering und DimensionalitätsreduktionDu arbeitest an einem Projekt zur Analyse eines großen Datensatzes mit mehreren hochdimensionalen Merkmalen. Um den Datensatz besser zu verstehen und zu verarbeiten, hast du dich entschieden, sowohl Clustering als auch Dimensionalitätsreduktionstechniken anzuwenden. Im Rahmen dieser Aufgabe wirst du verschiedene Algorithmen für Clustering und Dimensionalitätsreduktion anwenden und die Ergebnisse interpretieren.

a)

Du entscheidest dich, K-Means Clustering auf deinem Datensatz anzuwenden. Erkläre den K-Means Algorithmus und die mathematische Grundlage der Minimierung der Quadratsumme der Distanzen innerhalb der Cluster.

import numpy as npfrom sklearn.cluster import KMeans# Beispiel-DatensatzX = np.array([[1, 2], [1, 4], [1, 0], [10, 2], [10, 4], [10, 0]])# K-Means Clusteringkmeans = KMeans(n_clusters=2, random_state=0).fit(X)print(kmeans.labels_)print(kmeans.cluster_centers_)

Lösung:

K-Means AlgorithmusDer K-Means Algorithmus ist ein verbreitetes Verfahren zur Durchführung von Clustering-Analysen. Ziel des Algorithmus ist es, eine Menge von Datenpunkten in K Cluster zu unterteilen, sodass die Punkte innerhalb eines Clusters möglichst nah beieinander liegen. Dies wird erreicht, indem die Quadratsumme der Distanzen der Datenpunkte zu ihren jeweiligen Clusterzentren minimiert wird. Hier ist eine detaillierte Erklärung des K-Means Algorithmus und der mathematischen Grundlagen:Schritte des K-Means Algorithmus

• Initialisierung: Wähle initial K Zentroiden (oft zufällig oder basierend auf bestimmten Heuristiken).
• Zuweisung: Weise jeden Datenpunkt dem nächstgelegenen Zentroiden zu. Dies definiert die aktuellen Cluster.
• Update: Berechne die neuen Zentroiden als Mittelwert der Datenpunkte, die jedem Cluster zugewiesen wurden.
• Wiederholung: Wiederhole die Schritte der Zuweisung und des Updates, bis die Zentroiden sich nicht mehr signifikant ändern (Konvergenz) oder eine maximale Anzahl von Iterationen erreicht ist.

Mathematische GrundlageDer K-Means Algorithmus minimiert die folgende Zielfunktion, bekannt als die Summe der quadratischen Fehler (Sum of Squared Errors, SSE):

• Ziel: Minimiere die folgende Funktion:
• \[ J = \sum_{i=1}^{K} \sum_{x \in C_i} \left\| x - \mu_i \right\|^2 \]

• Woher die Variablen:
• i steht für das k-te Cluster
• x steht für einen Datenpunkt
• C_i steht für das Cluster i
• \(\mu_i\) steht für das Zentrum des Clusters i

The function calculates the sum of the squared Euclidean distances between each data point \(x\) and its corresponding cluster center \(\mu_i\).

Beispielimplementation in PythonVerwende die folgende Python-Implementierung, um K-Means Clustering auf einem Beispiel-Datensatz anzuwenden:

import numpy as npfrom sklearn.cluster import KMeans# Beispiel-DatensatzX = np.array([[1, 2], [1, 4], [1, 0], [10, 2], [10, 4], [10, 0]])# K-Means Clusteringkmeans = KMeans(n_clusters=2, random_state=0).fit(X)print(kmeans.labels_)print(kmeans.cluster_centers_)

• Erklärung des Codes:
  • Wir importieren nötige Bibliotheken und Funktionen.
  • Wir erstellen einen Beispiel-Datensatz X.
  • Wir führen K-Means Clustering mit 2 Clustern durch.
  • Wir drucken die resultierenden Cluster-Labels (also die Zuordnung jedes Datenpunkts zu einem Cluster) und die Zentroiden der Cluster.

• Erwartete Ausgabe:
  • [0 0 0 1 1 1] # Cluster-Zuweisungen
  • [[ 1. 2.] [10. 2.]] # Cluster-Zentroiden

• In diesem Beispiel werden die Datenpunkte in zwei Cluster unterteilt, wobei die Clusterzentren ungefähr bei (1, 2) und (10, 2) liegen.

b)

Nach erfolgreicher Anwendung von K-Means möchtest du zur besseren Visualisierung deines hochdimensionalen Datensatzes die PCA (Principal Component Analysis) einsetzen. Beschreibe die PCA Technik und erkläre, wie diese die Daten in neue Achsen transformiert. Führe die PCA auf den folgenden Datensatz durch und interpretiere die Ergebnisse:

from sklearn.decomposition import PCA# Beispiel-DatensatzX = np.array([[2.5, 2.4], [0.5, 0.7], [2.2, 2.9], [1.9, 2.2], [3.1, 3.0], [2.3, 2.7], [2, 1.6], [1, 1.1], [1.5, 1.6], [1.1, 0.9]])# PCApca = PCA(n_components=2)X_pca = pca.fit_transform(X)print(X_pca)print(pca.explained_variance_ratio_)

Lösung:

Principal Component Analysis (PCA)Die Principal Component Analysis (PCA) ist eine weit verbreitete Technik zur Dimensionalitätsreduktion. Sie wird verwendet, um die Daten zu transformieren und ihre Grundstruktur klarer zu machen, indem sie die wichtigsten Variationsrichtungen in den Daten identifiziert. Hier sind die Kernelemente und der Prozess der PCA erklärt:Schritte der PCA

• Standardisierung: Da PCA empfindlich gegenüber der Skalierung ist, werden die Daten zuerst standardisiert, damit jede Dimension derselben Skalierung folgt.
• Kovarianzmatrix: Berechne die Kovarianzmatrix der standardisierten Daten, um zu verstehen, wie die verschiedenen Dimensionen miteinander variieren.
• Eigenwerte und Eigenvektoren: Berechne die Eigenwerte und Eigenvektoren der Kovarianzmatrix. Die Eigenvektoren repräsentieren die Richtungen (oder Hauptkomponenten), in denen die Daten am meisten variieren, und die Eigenwerte geben die Größe dieser Variationen an.
• Sortieren und Auswählen der Hauptkomponenten: Sortiere die Eigenwerte in absteigender Reihenfolge und wähle die ersten k Eigenvektoren aus (die Hauptkomponenten), die die meiste Varianz im Datensatz erklären.
• Transformation: Transformiere die Originaldaten durch die Projektion auf die Hauptkomponentenachsen, um das neue, niedrigdimensionale Datenset zu erhalten.

Mathematische Grundlage

• Sei X der Originaldatensatz, bestehend aus n Datenpunkten mit d Dimensionen.
• Kovarianzmatrix: Die Kovarianzmatrix C ist definiert als: \[C = \frac{1}{n} X^T X \]
• Eigenwerte und Eigenvektoren: Löse das Eigenwertproblem für die Kovarianzmatrix: \[C \cdot v = \lambda \cdot v\]
• Hier ist \(\lambda\) ein Eigenwert und \(v\) ein Eigenvektor der Kovarianzmatrix.
• Wähle die k größten Eigenwerte und die dazugehörigen Eigenvektoren aus, um die Hauptkomponenten zu bilden.

Beispielimplementierung in Python

from sklearn.decomposition import PCAimport numpy as np# Beispiel-DatensatzX = np.array([[2.5, 2.4], [0.5, 0.7], [2.2, 2.9], [1.9, 2.2], [3.1, 3.0], [2.3, 2.7], [2, 1.6], [1, 1.1], [1.5, 1.6], [1.1, 0.9]])# PCApca = PCA(n_components=2)X_pca = pca.fit_transform(X)print(X_pca)print(pca.explained_variance_ratio_)

• Erklärung des Codes:
  • Wir importieren notwendige Bibliotheken und Funktionen.
  • Ein Beispiel-Datensatz X wird definiert.
  • Wir führen PCA durch, wobei wir die Daten auf 2 Hauptkomponenten reduzieren.
  • Wir drucken die transformierten Daten (X_pca) und den Prozentsatz der erklärten Varianz jeder Hauptkomponente (explained_variance_ratio_).

• Erwartete Ausgabe:
  • Die transformierten Daten könnten wie folgt aussehen:
  • [[-0.82797019 -0.17511531][ 1.77758033 0.14285723][ 0.99219749 0.38437499][ 0.27421042 0.13041721][ 1.67580142 -0.20949846][ 0.9129491 0.17528244][ 0.09910944 0.3498247 ][ 1.14457216 0.04641726][ 0.43804614 0.01776463][ 1.22382056 0.16267529]]
  • Die erklärten Varianzanteile könnten wie folgt aussehen:
  • [0.95350943 0.04649057]

• In diesem Beispiel erklären die ersten beiden Hauptkomponenten etwa 95.35% der Gesamtvarianz im Datensatz. Das bedeutet, dass die meisten Informationen des Datensatzes durch diese beiden neuen Achsen erfasst werden.

Interpretation der Ergebnisse:

• Die transformierten Daten (\

  c)

  Neben PCA möchtest du auch t-SNE anwenden, um deine Daten in eine 2D-Darstellung zu überführen. Erkläre die Funktionsweise von t-SNE und führe den folgenden Python-Code aus, um die t-SNE-Transformation auf einem größeren Datensatz zu visualisieren.

  from sklearn.datasets import load_digitsfrom sklearn.manifold import TSNEimport matplotlib.pyplot as plt# Beispiel-Datensatzdigits = load_digits()X = digits.data# t-SNEtsne = TSNE(n_components=2)X_tsne = tsne.fit_transform(X)# Visualisierungplt.scatter(X_tsne[:, 0], X_tsne[:, 1], c=digits.target)plt.colorbar()plt.show()

  Lösung:

  t-Distributed Stochastic Neighbor Embedding (t-SNE)t-SNE ist eine Technik zur Dimensionalitätsreduktion, die besonders für die Visualisierung hochdimensionaler Daten geeignet ist. Es transformiert die Daten so, dass ähnliche Punkte in der hohen Dimension auch in der niedrigen Dimension nahe beieinander liegen und unähnliche Punkte weiter voneinander entfernt sind.Funktionsweise von t-SNE

  • Ähnlichkeiten in hoher Dimension: Berechne die Ähnlichkeiten zwischen allen Paaren von Datenpunkten in der hohen Dimension. Dies geschieht durch die Berechnung von bedingten Wahrscheinlichkeiten, die ausdrücken, wie wahrscheinlich es ist, dass ein Punkt ein Nachbar eines anderen ist.
  • Ähnlichkeiten in niedriger Dimension: Berechne ähnliche bedingte Wahrscheinlichkeiten für den niedrigen Dimensionalitätsraum. Diese Wahrscheinlichkeiten werden durch einen Student-t-Verteilung-ähnlichen Verteilung definiert.
  • Kostenfunktion: Minimiere die Kullback-Leibler-Divergenz zwischen den Verteilungen der hohen und niedrigen Dimensionen. Diese Kostenfunktion misst, wie gut die Verteilung der Punkte in der niedrigen Dimension die Verteilung der Punkte in der hohen Dimension nachahmt.
  • Gradientenabstieg: Verwende ein optimierungsverfahren wie den Gradientenabstieg, um die Punktkoordinaten in der niedrigen Dimension zu iterativ zu aktualisieren, sodass die Kostenfunktion minimiert wird.
  Beispielimplementation in Python

  from sklearn.datasets import load_digitsfrom sklearn.manifold import TSNEimport matplotlib.pyplot as plt# Beispiel-Datensatzdigits = load_digits()X = digits.data# t-SNEtsne = TSNE(n_components=2)X_tsne = tsne.fit_transform(X)# Visualisierungplt.scatter(X_tsne[:, 0], X_tsne[:, 1], c=digits.target)plt.colorbar()plt.show()

  Erklärung des Codes
  • Wir importieren notwendige Bibliotheken und Funktionen.
  • Wir laden den Digits-Datensatz von sklearn, der 8x8 pixel große handschriftliche Zifferbilder enthält.
  • Wir extrahieren die Datenpunkte (X) aus dem Datensatz.
  • Wir wenden t-SNE an, um die Daten von 64 Dimensionen auf 2 Dimensionen zu reduzieren.
  • Wir visualisieren die resultierenden 2D-Datenpunkte und färben sie nach ihren Zielklassen (Ziffern).
  • Erwartete Visualisierung:Das resultierende Plot sollte zeigen, wie die handschriftlichen Ziffern in einem zweidimensionalen Raum verteilt sind. Punkte, die ähnliche Ziffern darstellen, sollten gruppiert sein, während unähnliche Ziffern weiter auseinander liegen.

  d)

  Zum Abschluss möchtest du deine Cluster-Ergebnisse validieren. Eine typische Metrik hierfür ist die Silhouette-Analyse. Beschreibe die Silhouette-Metrik und berechne die durchschnittliche Silhouette für die K-Means Cluster des folgenden Datensatzes:

  from sklearn.metrics import silhouette_scoreX = np.array([[1, 2], [1, 4], [1, 0], [10, 2], [10, 4], [10, 0]])kmeans = KMeans(n_clusters=2, random_state=0).fit(X)labels = kmeans.labels_silhouette_avg = silhouette_score(X, labels)print(f'Durchschnittliche Silhouette: {silhouette_avg}')

  Lösung:

  Silhouette-AnalyseDie Silhouette-Analyse ist eine Methode zur Bewertung der Konsistenz innerhalb von Clustern. Sie bewertet, wie ähnlich ein Punkt zu seinen eigenen Clusterpunkten im Vergleich zu Punkten in anderen Clustern ist. Die Silhouette-Metrik hilft zu bestimmen, ob die Objekte gut zu ihrem eigenen Cluster passen und ob sie besser in andere Cluster integriert werden sollten.Berechnung der Silhouette-WerteFür einen gegebenen Punkt i im Datensatz:

  • a(i): Der durchschnittliche Abstand von i zu allen anderen Punkten in seinem Cluster. Dies misst die interne Konsistenz des Clusters.
  • b(i): Der durchschnittliche Abstand von i zu allen Punkten im nächstgelegenen Cluster, zu dem i nicht gehört. Dies misst, wie gut der Punkt in den nächstgelegenen Cluster passt.
  Der Silhouette-Wert s(i) für den Punkt i wird berechnet durch:
  • Silhouettenwert: \[ s(i) = \frac{b(i) - a(i)}{\max(a(i), b(i))} \]
  • Die Silhouette-Werte liegen im Bereich von -1 bis 1:
  • Ein Wert nahe 1 bedeutet, dass der Punkt gut in seinem Cluster liegt und weit von den anderen Clustern entfernt ist.
  • Ein Wert nahe 0 bedeutet, dass der Punkt an der Grenze zweier Cluster liegt.
  • Ein Wert nahe -1 bedeutet, dass der Punkt möglicherweise falsch zugewiesen wurde und in einem anderen Cluster besser aufgehoben wäre.
  Beispielimplementierung in Python

  from sklearn.metrics import silhouette_scorefrom sklearn.cluster import KMeansimport numpy as np# Beispiel-DatensatzX = np.array([[1, 2], [1, 4], [1, 0], [10, 2], [10, 4], [10, 0]])# K-Means Clusteringkmeans = KMeans(n_clusters=2, random_state=0).fit(X)labels = kmeans.labels_# Berechnung der Silhouette-Scoresilhouette_avg = silhouette_score(X, labels)print(f'Durchschnittliche Silhouette: {silhouette_avg}')

  Erklärung des Codes
  • Wir importieren notwendige Bibliotheken und Funktionen.
  • Ein Beispiel-Datensatz X wird definiert.
  • Wir führen K-Means Clustering mit 2 Clustern durch.
  • Wir extrahieren die Cluster-Labels, die jedem Datenpunkt zugewiesen wurden.
  • Wir berechnen den durchschnittlichen Silhouette-Score für den Datensatz basierend auf den Cluster-Labels.
  • Wir drucken den durchschnittlichen Silhouette-Score.
  • Erwartete Ausgabe:Die durchschnittliche Silhouette könnte zum Beispiel etwa 0.6 oder höher sein, was auf eine gute Cluster-Struktur hinweist. Ein Wert näher bei 1 bedeutet eine bessere Cluster-Qualität.

  Aufgabe 3)

  Backpropagation-MethodeBackpropagation ist eine Methode des überwachten Lernens in neuronalen Netzen zur Anpassung der Gewichte mittels des Gradientenabstiegsalgorithmus.

  • Ziel: Minimierung der Kostenfunktion
  • Besteht aus Vorwärts- und Rückwärtsdurchlauf
  • Fehlerberechnung: \( \text{Fehlersignal} = \text{Sollwert} - \text{Istwert} \)
  • Gewichtsanpassung: \( w_{ij} \rightarrow w_{ij} - \beta \frac{\text{dJ}}{\text{d}w_{ij}} \)
  • \( \beta \) ist die Lernrate
  • Kettenregel zur Berechnung des Gradienten
  • Notwendig für das Training tiefer neuronaler Netze

  a)

  Teilaufgabe 1: Beschreibe den vollständigen Vorwärtsdurchlauf eines neuronalen Netzes. Angenommen, Du hast ein einfaches Netzwerk mit einer versteckten Schicht und einer Ausgabeschicht. Definiere die Aktivierungen und die Kostenfunktion.

  Lösung:

  Teilaufgabe 1:

  Um den vollständigen Vorwärtsdurchlauf eines neuronalen Netzes zu beschreiben, nehmen wir ein einfaches Netzwerk mit einer versteckten Schicht und einer Ausgabeschicht an. Wir definieren die Aktivierungen und die Kostenfunktion wie folgt:

  • 1. Eingabeschicht: Gegeben seien die Eingaben \( \textbf{X} \) (ein Vektor von Eingabegrößen).
  • 2. Verborgene Schicht:
    • Gewichtsmatrix: \( \textbf{W}^{(1)} \), welche die Verbindungen zwischen der Eingabeschicht und der verborgenen Schicht darstellt.
    • Biasvektor: \( \textbf{b}^{(1)} \), der den Bias der versteckten Schicht darstellt.
    • Nettoeingang: Der Nettoeingang zur versteckten Schicht ist gegeben durch \[ \textbf{Z}^{(1)} = \textbf{W}^{(1)} \textbf{X} + \textbf{b}^{(1)} \]
    • Aktivierungsfunktion: Um die Aktivierungen der verborgenen Schicht zu berechnen, verwenden wir eine Aktivierungsfunktion \( g \) wie die Sigmoid- oder ReLU-Funktion. Dann sind die Aktivierungen der verborgenen Schicht: \[ \textbf{A}^{(1)} = g(\textbf{Z}^{(1)}) \]
  • 3. Ausgabeschicht:
    • Gewichtsmatrix: \( \textbf{W}^{(2)} \), welche die Verbindungen zwischen der verborgenen Schicht und der Ausgabeschicht darstellt.
    • Biasvektor: \( \textbf{b}^{(2)} \), der den Bias der Ausgabeschicht darstellt.
    • Nettoeingang: Der Nettoeingang zur Ausgabeschicht ist gegeben durch \[ \textbf{Z}^{(2)} = \textbf{W}^{(2)} \textbf{A}^{(1)} + \textbf{b}^{(2)} \]
    • Aktivierungsfunktion: Um die Aktivierungen der Ausgabeschicht zu berechnen, verwenden wir eine Aktivierungsfunktion \( h \), die für Klassifikationsaufgaben oft die Softmax-Funktion ist. Dann sind die Aktivierungen der Ausgabeschicht: \[ \textbf{A}^{(2)} = h(\textbf{Z}^{(2)}) \]
  • 4. Kostenfunktion: Um die Differenz zwischen der vorhergesagten Ausgabe \( \textbf{A}^{(2)} \) und dem Sollwert \( \textbf{Y} \) zu quantifizieren, definieren wir eine Kostenfunktion (auch Verlustfunktion genannt). Bei Klassifikationsproblemen wird oft die Kreuzentropie verwendet: \[ J(\textbf{W}^{(1)}, \textbf{W}^{(2)}, \textbf{b}^{(1)}, \textbf{b}^{(2)}) = -\frac{1}{m} \bigg[ \textbf{Y} \times \text{log}(\textbf{A}^{(2)}) + (1 - \textbf{Y}) \times \text{log}(1 - \textbf{A}^{(2)}) \bigg] \] wobei \( m \) die Anzahl der Trainingsbeispiele ist.

  Dies beschreibt den vollständigen Vorwärtsdurchlauf eines einfachen neuronalen Netzes mit einer versteckten Schicht und einer Ausgabeschicht, einschließlich der Berechnung der Aktivierungen und der Kostenfunktion.

  b)

  Teilaufgabe 2: Erkläre die Rolle der Kettenregel bei der Backpropagation. Beschreibe, wie die Kettenregel verwendet wird, um die Gradienten für die Gewichtsanpassungen zu berechnen. Nutze dabei die Fehlerberechnung und zeige mathematische Details.

  Lösung:

  Teilaufgabe 2:

  Die Kettenregel spielt eine zentrale Rolle bei der Backpropagation, um die Gradienten für die Gewichtsanpassungen in einem neuronalen Netz zu berechnen. Backpropagation benutzt die Kettenregel, um die Ableitung der Kostenfunktion nach jeder Gewichtung zu ermitteln. Dies ist entscheidend dafür, wie die Gewichte angepasst werden, um den Gesamtfehler zu minimieren.

  • 1. Fehlerberechnung: Der Fehler eines Neurons in der Ausgabeschicht wird durch die Differenz zwischen dem Sollwert (dem tatsächlichen Wert) und dem Istwert (dem vorhergesagten Wert) berechnet: \( \text{Fehlersignal} = \text{Sollwert} - \text{Istwert} \)
  • 2. Ableitung der Kostenfunktion: Für jede Schicht im Netz berechnen wir den Gradienten der Kostenfunktion bezüglich der Gewichtungen. Dies wird mit der Kettenregel durchgeführt. Nehmen wir an, die Kostenfunktion ist \( J \) und \( w_{ij} \) ist das Gewicht zwischen Neuron \( i \) der Schicht \( l \) und Neuron \( j \) der Schicht \( l+1 \). Dann wollen wir \( \frac{\text{d}J}{\text{d}w_{ij}} \) bestimmen.
  • 3. Vorwärtsdurchlauf: In einem Vorwärtsdurchlauf werden die Nettoeingänge und Aktivierungen basierend auf den aktuellen Gewichtungen und Eingaben berechnet: \( \textbf{Z}^{(l+1)} = \textbf{W}^{(l+1)} \textbf{A}^{(l)} + \textbf{b}^{(l+1)} \) \( \textbf{A}^{(l+1)} = g(\textbf{Z}^{(l+1)}) \)
  • 4. Rückwärtsdurchlauf: Im Rückwärtsdurchlauf verwenden wir die Kettenregel, um die Ableitungen schichtweise zu berechnen:
    • Berechnung des Fehlers in der Ausgabeschicht: \( \textbf{\textdelta}^{(L)} = \textbf{A}^{(L)} - \textbf{Y} \) wobei \( \textbf{Y} \) der Sollwert und \( \textbf{A}^{(L)} \) die Aktivierungen der Ausgabeschicht (\( L \)) sind.
    • Rückwärtsweiterleitung des Fehlers: Für jede Schicht \( l \) berechnet sich der Fehler \( \textbf{\textdelta}^{(l)} \): \[ \textbf{\textdelta}^{(l)} = (\textbf{W}^{(l+1)})^T \textbf{\textdelta}^{(l+1)} * g'(\textbf{Z}^{(l)}) \] Hierbei ist \( g' \) die Ableitung der Aktivierungsfunktion.
    • Berechnung der Gradienten: Der Gradientenabstieg erfordert die Berechnung von \( \frac{\text{d}J}{\text{d}w_{ij}} \), was mit Hilfe der Kettenregel durchgeführt wird: \[ \frac{\text{d}J}{\text{d}w_{ij}} = \textbf{\textdelta}^{(l+1)} (\textbf{A}^{(l)})^T \]
  • 5. Gewichtsanpassung: Schließlich werden die Gewichte wie folgt angepasst: \[ w_{ij} \rightarrow w_{ij} - \beta \frac{\text{d}J}{\text{d}w_{ij}} \] Dabei ist \( \beta \) die Lernrate.

  Zusammengefasst wird die Kettenregel in der Backpropagation verwendet, um den Gradienten der Kostenfunktion bezüglich der Gewichtungen zu berechnen. Dies erlaubt es, die Gewichtungen so anzupassen, dass die Kostenfunktion minimiert wird, indem der Fehler in jeder Schicht des neuronalen Netzes schrittweise rückwärts weitergegeben wird.

  c)

  Teilaufgabe 3: Gegeben sei ein einfaches neuronales Netz mit zwei Eingaben, eine versteckte Schicht mit zwei Neuronen und eine Ausgabeschicht mit einem Neuron. Sei der Sollwert 1 und der Istwert 0,6. Setze die Lernrate \( \beta \) auf 0,1. Berechne die Anpassung für das Gewicht \( w_{1,2} \).

  Lösung:

  Teilaufgabe 3:

  Um die Anpassung für das Gewicht \( w_{1,2} \) in einem einfachen neuronalen Netz zu berechnen, müssen wir mehrere Schritte durchlaufen, die sowohl den Vorwärts- als auch den Rückwärtsdurchlauf umfassen. Angenommen, das Netzwerk hat zwei Eingaben, eine versteckte Schicht mit zwei Neuronen und eine Ausgabeschicht mit einem Neuron. Der Sollwert ist 1 und der Istwert ist 0,6. Die Lernrate \( \beta \) ist 0,1.

  • 1. Fehlerberechnung: Zunächst berechnen wir das Fehlersignal: \[ \text{Fehlersignal} = \text{Sollwert} - \text{Istwert} = 1 - 0,6 = 0,4 \]
  • 2. Gradientenberechnung: Wir verwenden das Fehlersignal, um die Gradienten für die Gewichtsanpassung zu berechnen. Nehmen wir an, \( w_{1,2} \) ist das Gewicht zwischen dem ersten Neuron der Eingabeschicht und dem zweiten Neuron der versteckten Schicht.
  • Ausgabeschicht-Fehler: Der Fehler in der Ausgabeschicht ist das Fehlersignal: \[ \textbf{\textdelta}_\text{output} = 0,4 \]
  • Rückwärtsweiterleitung des Fehlers zur versteckten Schicht: Nehmen wir eine einfache Sigmoid-Aktivierungsfunktion \( \sigma \), deren Ableitung ist: \( \sigma'(z) = \sigma(z)(1 - \sigma(z)) \). Für das zweite Neuron in der versteckten Schicht sei der Aktivierungswert \( a^{(2)} \). Dann ist der Fehler im zweiten Neuron der versteckten Schicht: \[ \textbf{\textdelta}^{(2)} = \textbf{\textdelta}_\text{output} * \sigma'(z^{(2)}) \approx 0,4 * a^{(2)}(1 - a^{(2)}) \]
  • Gradientenberechnung für \( w_{1,2} \): Die Gewichtsanpassung für \( w_{1,2} \) hängt vom Eingangswert \( x_1 \) in die versteckte Schicht und dem berechneten Fehler \( \textbf{\textdelta}^{(2)} \) ab: \[ \frac{\text{d}J}{\text{d}w_{1,2}} = \textbf{\textdelta}^{(2)} * x_1 \] wobei \( x_1 \) der Eingangswert ist.
  • 3. Gewichtsanpassung: Schließlich passen wir das Gewicht wie folgt an: \[ w_{1,2} \rightarrow w_{1,2} - \beta \frac{\text{d}J}{\text{d}w_{1,2}} \] Setzen wir die Lernrate \( \beta \) auf 0,1: \[ w_{1,2, \text{neu}} = w_{1,2, \text{alt}} - 0,1 * \frac{\text{d}J}{\text{d}w_{1,2}} \]

  Zusammengefasst: Um den spezifischen Wert für \( \frac{\text{d}J}{\text{d}w_{1,2}} \) zu berechnen, benötigen wir genaue Aktivierungs- und Eingabewerte des Netzwerks. Wenn beispielsweise \( x_1 = 0,5 \) und \( a^{(2)} \) der Aktivierungswert des zweiten Neurons der versteckten Schicht ist, kannst Du den oben beschriebenen Prozess anwenden, um die exakten Anpassungen für \( w_{1,2} \) zu berechnen.

  d)

  Teilaufgabe 4: Diskutiere die Herausforderungen und Lösungen beim Training tiefer neuronaler Netze mit der Backpropagation. Gehe dabei auf Probleme wie den verschwindenden Gradienten und mögliche Lösungsansätze ein.

  Lösung:

  Teilaufgabe 4:

  Beim Training tiefer neuronaler Netze mit der Backpropagation gibt es mehrere Herausforderungen, von denen einige hier beschrieben werden, zusammen mit möglichen Lösungsansätzen.

  • 1. Problem des verschwindenden Gradienten: Bei tiefen Netzen neigen die Gradienten dazu, während der Rückwärtsdurchlaufphasen sehr klein zu werden, insbesondere bei der Verwendung von Sigmoid- oder Tanh-Aktivierungsfunktionen. Dies führt dazu, dass die Gewichte in den unteren Schichten kaum aktualisiert werden, was das Training extrem verlangsamt und die Leistung beeinträchtigt.
  • Lösungsansatz 1: Verwendung von ReLU-Aktivierungsfunktionen: Die ReLU (Rectified Linear Unit)-Aktivierungsfunktion behebt dieses Problem teilweise, da ihre Ableitung entweder 0 (wenn der Eingang negativ ist) oder 1 (wenn der Eingang positiv ist) ist. Dies hilft dabei, das Problem des verschwindenden Gradienten zu mildern.
  • Lösungsansatz 2: Batch-Normalisierung: Die Batch-Normalisierung hilft dabei, die Verteilung der Eingaben zu standardisieren, was die Probleme des verschwindenden Gradienten und des explodierenden Gradienten ausgleicht. Sie hilft auch, die Konvergenz zu beschleunigen.
  • Lösungsansatz 3: Residuale Netze: Residual Networks (ResNets) verwenden Sprungverbindungen, die tiefere Netze ermöglichen, ohne übermäßige Gradientenprobleme zu erleiden. Diese Verbindungen tragen dazu bei, Informationen direkt an spätere Schichten weiterzuleiten, was das Verschwinden der Gradienten verhindert.
  • 2. Problem des explodierenden Gradienten: Bei tiefen Netzen können die Gradienten in den unteren Schichten sehr groß werden. Dies führt zu riesigen Gewichtsanpassungen und dadurch zu Instabilität im Lernprozess.
  • Lösungsansatz 1: Gradient Clipping: Dabei werden Gradienten, die einen bestimmten Schwellenwert überschreiten, abgeschnitten (geclippt). Dies verhindert, dass Gradienten exponentiell anwachsen und sorgt für einen stabilen Trainingsprozess.
  • 3. Problem der Überanpassung: Tiefe neuronale Netze haben eine große Anzahl von Parametern, was das Risiko der Überanpassung an die Trainingsdaten erhöht. Überanpassung bedeutet, dass das Modell auf den Trainingsdaten sehr gut abschneidet, aber auf neuen, unsichtbaren Daten schlecht generalisiert.
  • Lösungsansatz 1: Dropout: Dropout ist eine Technik, bei der während des Trainings zufällig einige Neuronen deaktiviert werden. Dies zwingt das Netzwerk, Redundanzen zu entwickeln und verhindert das Überanpassen.
  • Lösungsansatz 2: Datenaugmentation: Datenaugmentation umfasst Techniken zur künstlichen Vergrößerung des Trainingsdatensatzes durch Anwendung von Transformationen wie Rotationen, Skalierungen und Spiegelungen auf die vorhandenen Daten. Dies hilft, die Generalisierungsfähigkeiten des Modells zu verbessern.
  • Lösungsansatz 3: Regularisierung: Regularisierungstechniken wie L2-Regularisierung (Gewichtszerfall) oder L1-Regularisierung können angewendet werden, um die Modellkomplexität zu kontrollieren und Überanpassung zu reduzieren.
  • 4. Computational Load: Tiefe neuronale Netze erfordern erhebliche Rechenressourcen und Speicherplatz, was sowohl die Trainingszeit als auch die Kosten erhöht.
  • Lösungsansatz 1: Nutzung von GPUs und TPUs: Grafikprozessoren (GPUs) und Tensor-Prozessoren (TPUs) sind speziell für parallele Verarbeitung und sind viel schneller als herkömmliche CPUs beim Training von tiefen neuronalen Netzen.
  • Lösungsansatz 2: Verteiltes Lernen: Verteiltes Lernen ermöglicht die Verteilung des Trainingsprozesses über mehrere Maschinen oder Prozessoren, was die Trainingszeit erheblich reduziert.

  Zusammengefasst gibt es mehrere Herausforderungen beim Training tiefer neuronaler Netze mit Backpropagation, wie das Problem des verschwindenden Gradienten, des explodierenden Gradienten, der Überanpassung und des hohen Rechenaufwands. Mit geeigneten Techniken und Anpassungen wie der Verwendung von ReLU, Batch-Normalisierung, Residual Networks, Gradient Clipping, Dropout und anderen Methoden können diese Herausforderungen bewältigt werden, um effektive und effiziente Trainingsprozesse zu gewährleisten.

  Aufgabe 4)

  Angenommen, Du hast ein Convolutional Neural Network (CNN) zur Bildklassifikation implementiert. Dein Netzwerk besteht aus mehreren Convolutional Layers gefolgt von Pooling Layers und schließlich Fully Connected Layers. Du verwendest ReLU als Aktivierungsfunktion nach jedem Convolutional Layer.

  a)

  Erkläre detailliert den Prozess der Faltung in einem Convolutional Layer. Beschreibe, wie ein 3x3 Filter auf einen 5x5 Eingabedatenbereich angewendet wird und wie daraus eine Merkmalskarte entsteht. Verwende die Formel für die Faltung: \[ (I * K)(i, j) = \sum_m \sum_n I(m, n) \, K(i-m, j-n) \] und gib ein konkretes Beispiel an.

  Lösung:

  Der Prozess der Faltung in einem Convolutional Layer ist ein essenzieller Schritt in Convolutional Neural Networks (CNNs). Dabei wird ein Filter (oder Kernel) über das Eingabebild geschoben, um eine Merkmalskarte (Feature Map) zu erstellen. Diese Merkmalskarte enthält Informationen über verschiedene Merkmale des Bildes wie Kanten, Ecken und Texturen.

  Lass uns den konkreten Prozess anhand eines 3x3 Filters und eines 5x5 Eingabedatenbereichs (z. B. eines Bildausschnitts) näher betrachten.

  • 1. Eingabe: Angenommen, wir haben eine Eingabematrix (I) der Größe 5x5:

  1 2 3 0 24 6 5 1 37 8 9 4 53 2 1 5 04 3 2 1 3

  • 2. Filter (Kernel): Der 3x3-Filter (K) sei:

   1  0 -1 0  1  0-1  0  1

  • 3. Faltung: Um die Faltung durchzuführen, positionieren wir den Filter oben links auf die Eingabematrix und berechnen das Punktprodukt (dot product) für jede Position des Filters. Dies bedeutet, dass wir den Filter über das Eingabebild schieben und an jeder Position das Punktprodukt berechnen. Die Formel für die Faltung lautet:

  \[(I * K)(i, j) = \sum_m \sum_n I(m, n) \cdot K(i-m, j-n)\]

  • Schritt für Schritt:
  • (a) Initiale Position: Die obere linke Ecke des Filters wird auf die obere linke Ecke der Eingabematrix gesetzt.

     1 2 3 0 2   4 6 5 1 3   7 8 9 4 5   3 2 1 5 0   4 3 2 1 3 (3x3-Bereich) 1 2 3 4 6 5 7 8 9(Punktprodukt)1*1 + 2*0 + 3*(-1) + 4*0 + 6*1 + 5*0 + 7*(-1) + 8*0 + 9*1= 1 + 0 - 3 + 0 + 6 + 0 - 7 + 0 + 9= 6

  • (b) Den Filter um 1 Position nach rechts verschieben:

    2 3 0 2    6 5 1 3    8 9 4 5    2 1 5 0    3 2 1 3  (3x3-Bereich) 2 3 0 6 5 1 8 9 4(Punktprodukt)2*1 + 3*0 + 0*(-1) + 6*0 + 5*1 + 1*0 + 8*(-1) + 9*0 + 4*1= 2 + 0 + 0 + 0 + 5 + 0 - 8 + 0 + 4= 3

  • (c) Diesen Prozess wiederholen, bis der gesamte Eingabebereich durchlaufen ist.
  • 4. Merkmalskarte: Nach Anwendung des Filters auf alle möglichen Positionen innerhalb der Eingabematrix erhalten wir die Merkmalskarte. Für unser Beispiel könnte die resultierende Merkmalskarte der Größe 3x3 so aussehen:

  6  3  25  1 -1-1  8  7

  • Dies ist im Wesentlichen die neue Darstellung des Eingabebildes nach der Faltung, wobei jedes Element der Merkmalskarte angibt, wie stark das entsprechende Merkmal (Kante, Ecke) an dieser Position erkannt wurde.

  b)

  Beschreibe den Unterschied zwischen Max-Pooling und Average-Pooling in einem Pooling Layer. Verwende hierzu je ein Beispiel, bei dem ein 2x2 Pooling-Fenster auf die folgende Merkmalskarte angewendet wird:

  • 4, 2, 5, 7
  • 8, 3, 1, 6
  • 9, 0, 2, 4
  • 3, 5, 7, 8

  Lösung:

  Pooling Layer sind ein wichtiger Bestandteil von Convolutional Neural Networks (CNNs). Sie reduzieren die räumlichen Abmessungen der Merkmalskarten und tragen dazu bei, die Rechenkomplexität zu verringern sowie die Netzwerkrobustheit gegenüber Positions- und Skalierungsveränderungen zu erhöhen. Es gibt zwei gängige Arten von Pooling: Max-Pooling und Average-Pooling.

  Im Folgenden werden wir den Unterschied zwischen diesen beiden Arten anhand eines Beispiels erläutern, bei dem ein 2x2 Pooling-Fenster auf die gegebene Merkmalskarte angewendet wird.

  • Gegebene Merkmalskarte:

   4, 2, 5, 7  8, 3, 1, 6  9, 0, 2, 4  3, 5, 7, 8 

  1. Max-Pooling

  Beim Max-Pooling wird aus jedem Pooling-Fenster der maximale Wert ausgewählt.

  • Schritt-für-Schritt-Anwendung des 2x2 Max-Pooling-Fensters:
  • (a) Erster Pooling-Bereich:

   4, 2  8, 3 Max = 8 

  • (b) Zweiter Pooling-Bereich:

   5, 7  1, 6 Max = 7 

  • (c) Dritter Pooling-Bereich:

   9, 0  3, 5 Max = 9 

  • (d) Vierter Pooling-Bereich:

   2, 4  7, 8 Max = 8 

  • Ergebnis nach Max-Pooling:

   8, 7  9, 8 

  2. Average-Pooling

  Beim Average-Pooling wird aus jedem Pooling-Fenster der Durchschnittswert (arithmetisches Mittel) berechnet.

  • Schritt-für-Schritt-Anwendung des 2x2 Average-Pooling-Fensters:
  • (a) Erster Pooling-Bereich:

   4, 2  8, 3 Durchschnitt = (4+2+8+3)/4 = 4.25 

  • (b) Zweiter Pooling-Bereich:

   5, 7  1, 6 Durchschnitt = (5+7+1+6)/4 = 4.75 

  • (c) Dritter Pooling-Bereich:

   9, 0  3, 5 Durchschnitt = (9+0+3+5)/4 = 4.25 

  • (d) Vierter Pooling-Bereich:

   2, 4  7, 8 Durchschnitt = (2+4+7+8)/4 = 5.25 

  • Ergebnis nach Average-Pooling:

   4.25, 4.75  4.25, 5.25 

  Zusammenfassend:

  • Max-Pooling: Wählt den maximalen Wert aus jedem Pooling-Fenster aus.
  • Average-Pooling: Berechnet den Durchschnittswert aus jedem Pooling-Fenster.
  • Beide Methoden haben den Effekt, die Abmessungen der Merkmalskarte zu reduzieren, allerdings betonen sie unterschiedliche Aspekte der Merkmale. Während Max-Pooling vor allem signifikante Merkmale extrahiert, bietet Average-Pooling einen gemittelten Überblick der Merkmale.

  c)

  Implementiere eine Funktion in Python, die die ReLU-Aktivierungsfunktion anwendet. Diese Funktion sollte eine Liste von Eingabewerten annehmen und die entsprechende Ausgabe zurückgeben. Die ReLU-Aktivierungsfunktion ist definiert als: \[ f(x) = \max(0, x) \].

  Lösung:

  Die ReLU-Aktivierungsfunktion (Rectified Linear Unit) ist eine der am häufigsten verwendeten Aktivierungsfunktionen in Convolutional Neural Networks (CNNs). Sie ist definiert als: \( f(x) = \max(0, x)\). Diese Funktion gibt den Eingangswert zurück, falls er größer als 0 ist, andernfalls wird 0 zurückgegeben.

  Im Folgenden findest Du eine Python-Implementierung der ReLU-Aktivierungsfunktion, die eine Liste von Eingabewerten annimmt und die entsprechenden Ausgabewerte zurückgibt:

   def relu_activation(input_list):     return [max(0, x) for x in input_list] # Beispielverwendung input_values = [-2, -1, 0, 1, 2, 3, -3] output_values = relu_activation(input_values) print(output_values) # Ausgabe: [0, 0, 0, 1, 2, 3, 0] 

  Hier erklärt:

  • Die Funktion relu_activation nimmt eine Liste von Eingabewerten (input_list) als Argument.
  • Innerhalb der Funktion wird eine List Comprehension verwendet, um jeden Wert aus der Eingabeliste durch die ReLU-Funktion (max(0, x)) zu verarbeiten.
  • Die verarbeiteten Werte werden in einer neuen Liste gespeichert, die als Ausgabe der Funktion zurückgegeben wird.

  Das Beispiel zeigt, wie die Funktion auf eine Liste von Eingabewerten angewendet werden kann. Die resultierenden Ausgabewerte entsprechen der Anwendung der ReLU-Aktivierungsfunktion auf jeden Eingabewert.

  d)

  Erkläre, wie ein CNN für die Bildklassifikation trainiert wird. Beschreibe die einzelnen Schritte im Trainingsprozess einschließlich der Vorwärts- und Rückwärtspropagation. Gehe zudem auf die Bedeutung des Loss-Funktion und der Gradientenabstiegsverfahren in diesem Kontext ein.

  Lösung:

  Das Training eines Convolutional Neural Networks (CNN) für die Bildklassifikation umfasst mehrere Schritte, die dazu beitragen, die Netzwerkgewichte zu optimieren und die Klassifikationsgenauigkeit zu erhöhen. Die wichtigsten Schritte im Trainingsprozess sind die Vorwärts- und Rückwärtspropagation sowie die Optimierung des Modells durch den Gradientenabstieg. Im Folgenden wird der gesamte Prozess im Detail beschrieben:

  1. Vorverarbeitung der Daten:
  • Bevor das Training des CNN beginnt, müssen die Bilddaten vorverarbeitet werden. Diese Schritte können die Größenanpassung der Bilder, die Normalisierung der Pixelwerte und die Datenaugmentation (wie Rotationen und Spiegelungen) umfassen, um die Trainingsdaten zu erweitern.
  2. Initialisierung des Netzwerks:
  • Die Gewichte und Biases des CNN werden zufällig initialisiert. Diese Parameter werden während des Trainings optimiert.
  3. Vorwärtspropagation:
  • In der Vorwärtspropagation wird ein Eingangsbild durch das Netzwerk geleitet. Dabei durchläuft es die verschiedenen Schichten des Netzwerks und es werden Zwischenergebnisse (Aktivierungen) berechnet.
  • Convolutional Layer: Filter werden auf das Eingangsbild angewendet, um Merkmalskarten zu erzeugen.
  • ReLU-Aktivierung: Nichtlineare Transformation der Merkmalskarten.
  • Pooling Layer: Reduktion der räumlichen Dimensionen der Merkmalskarten durch Max-Pooling oder Average-Pooling.
  • Fully Connected Layer: Transformation der Merkmalskarten in eine flache Struktur und Klassifikation in die entsprechenden Klassen.
  4. Berechnung der Loss-Funktion:
  • Die Loss-Funktion, auch Kostenfunktion genannt, misst die Differenz zwischen den vorhergesagten Ausgaben des Netzwerks und den echten Labeln. Beispiele für Loss-Funktionen sind