Machine Learning for Engineers II and Advanced Methods - Exam

Aufgabe 1)

Random Forests und Gradient BoostingRandom Forests sind Ensembles aus Entscheidungsbäumen, die durch Mehrheitsabstimmung kombiniert werden. Im Gegensatz dazu wird bei Gradient Boosting ein Entscheidungsbaum nach dem anderen sequenziell trainiert, um einen Fehler zu minimieren.

• Random Forests: Viele Entscheidungsbäume werden auf zufälligen Teilmengen der Daten trainiert.
  • Reduziert Überanpassung (Overfitting).
  • Weniger sensitiv gegenüber einzelnen Ausreißern.
• Gradient Boosting: Adaptive Methode, die Modelle nacheinander trainiert.
  • Verwendet Verlustfunktion zur Optimierung.
  • Typischerweise effizienter, aber anfälliger für Overfitting.
  • Beliebte Implementationen: XGBoost, LightGBM, CatBoost.

a)

Vergleiche die Konzepte von Random Forests und Gradient Boosting. Welche Methoden würden besser in einem Szenario funktionieren, in dem die Daten viele Ausreißer enthalten? Begründe Deine Antwort.

Lösung:

Vergleich der Konzepte von Random Forests und Gradient Boosting:

• Random Forests:
  • Bestehen aus vielen Entscheidungsbäumen, die auf zufälligen Teilmengen der Daten trainiert werden.
  • Die finale Vorhersage erfolgt durch Mehrheitsabstimmung der Bäume.
  • Reduziert Überanpassung (Overfitting), da die zufällige Auswahl der Daten Teilmengen unabhängige Modelle erzeugt.
  • Weniger sensitiv gegenüber einzelnen Ausreißern, da die Auswirkung eines Ausreißers in einem einzelnen Baum durch den Mehrheitsentscheid der anderen Bäume abgeschwächt wird.
• Gradient Boosting:
  • Ensemble Methode, die Modelle (meist Entscheidungsbäume) nacheinander trainiert, wobei jedes neue Modell darauf abzielt, die Fehler des vorherigen Modells zu korrigieren.
  • Verwendet eine Verlustfunktion zur Optimierung, die bestimmt, wie gut das Modell die Fehler korrigiert.
  • Typischerweise effizienter in der Modellbildung und kann starke Vorhersagen liefern.
  • Kann jedoch anfälliger für Overfitting sein, da jedes Modell auf den Fehlern des vorherigen Modells aufbaut, wodurch Ausreißer stark berücksichtigt werden können.
  • Beliebte Implementationen: XGBoost, LightGBM, CatBoost.

Welche Methode funktioniert besser in einem Szenario mit vielen Ausreißern?

Random Forests: Random Forests sind in einem Szenario mit vielen Ausreißern besser geeignet. Einzelne Ausreißer haben eine geringere Auswirkung auf die Gesamtvorhersage, da jedes Modell auf einer unterschiedlichen zufälligen Teilmenge der Daten trainiert wird. Auch wenn ein Entscheidungsbaum stark von den Ausreißern beeinflusst wird, können die anderen Bäume diesen Einfluss durch Mehrheitsabstimmung ausgleichen, was zu einer robusteren und stabileren Vorhersage führt. Daher ist Random Forest weniger sensitiv gegenüber einzelnen Ausreißern und kann diese besser handhaben als Gradient Boosting.

b)

Implementiere einen Random Forest-Klassifikator in Python und nutze diesen, um ein skaliertes Datenset zu klassifizieren. Erläutere den gesamten Prozess und evaluiere die Genauigkeit des Modells.

from sklearn.ensemble import RandomForestClassifierfrom sklearn.datasets import load_irisfrom sklearn.model_selection import train_test_splitfrom sklearn.preprocessing import StandardScalerfrom sklearn.metrics import accuracy_score# Daten ladeniris = load_iris()X, y = iris.data, iris.target# Train/Test SplitX_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=42)# Daten skalierenscaler = StandardScaler()X_train = scaler.fit_transform(X_train)X_test = scaler.transform(X_test)# Random Forest Klassifikator trainierenclf = RandomForestClassifier(n_estimators=100, random_state=42)clf.fit(X_train, y_train)# Vorhersagen treffeny_pred = clf.predict(X_test)# Genauigkeit bewertenaccuracy = accuracy_score(y_test, y_pred)print(f'Accuracy: {accuracy}')

Lösung:

Implementierung eines Random Forest-Klassifikators in Python:

from sklearn.ensemble import RandomForestClassifierfrom sklearn.datasets import load_irisfrom sklearn.model_selection import train_test_splitfrom sklearn.preprocessing import StandardScalerfrom sklearn.metrics import accuracy_score# Daten ladeniris = load_iris()X, y = iris.data, iris.target# Train/Test SplitX_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=42)# Daten skalierenscaler = StandardScaler()X_train = scaler.fit_transform(X_train)X_test = scaler.transform(X_test)# Random Forest Klassifikator trainierenclf = RandomForestClassifier(n_estimators=100, random_state=42)clf.fit(X_train, y_train)# Vorhersagen treffeny_pred = clf.predict(X_test)# Genauigkeit bewertenaccuracy = accuracy_score(y_test, y_pred)print(f'Accuracy: {accuracy}')

Der gesamte Prozess im Detail:

• Daten laden: Zunächst laden wir den Iris-Datensatz, welcher häufig für Klassifikationsprobleme genutzt wird.
• Train/Test Split: Danach teilen wir die Daten in Trainings- und Testdatensätze auf, um die Modellleistung später zu evaluieren.
• Daten skalieren: Da die Merkmalswerte unterschiedliche Skalen haben können, skalieren wir die Daten mit StandardScaler, um die Modellkonvergenz und Stabilität zu verbessern.
• Random Forest Klassifikator trainieren: Wir initialisieren und trainieren den RandomForestClassifier mit 100 Entscheidungsbäumen.
• Vorhersagen treffen: Nach dem Training nutzen wir das Modell, um Vorhersagen auf dem Testdatensatz zu machen.
• Genauigkeit bewerten: Schließlich evaluieren wir die Genauigkeit des Modells anhand der Vorhersagen und drucken das Ergebnis aus.

In diesem Szenario haben wir einen Random Forest-Klassifikator erfolgreich implementiert und die Genauigkeit des Modells mit dem Iris-Datensatz berechnet.

Aufgabe 2)

Hyperparameteroptimierung und Cross-Validation: Im Rahmen dieser Aufgabe wirst Du ein maschinelles Lernmodell unter Verwendung von Hyperparameteroptimierungstechniken und Cross-Validation evaluieren. Du wirst einen fiktiven Datensatz erhalten, auf dem Du verschiedene Methoden der Hyperparameteroptimierung anwenden sollst, um die beste Modellperformance zu erreichen. Es ist wichtig, dass Du die Generalisierbarkeit des endgültigen Modells sicherstellst.

a)

Gegeben sei ein Datensatz zur Klassifikation mit 1000 Beispielen und 20 Merkmalen. Wende K-Fold Cross-Validation mit k = 5 an, um die Modellleistung durch die mittlere Genauigkeit über die Folds zu berechnen. Verwende hierzu ein beliebiges Klassifikationsmodell und beschreibe die Vorgehensweise in mathematischer Form.

Lösung:

Lösung des Unterexercise:

Um K-Fold Cross-Validation mit k = 5 anzuwenden und die Modellleistung zu berechnen, folge diesen Schritten:

• Schritt 1: Teile den Datensatz in 5 gleich große Folds (Teilmengen) auf.
• Schritt 2: Wähle ein beliebiges Klassifikationsmodell, z.B. einen Entscheidungsbaum.
• Schritt 3: Für jeden Fold von 1 bis 5:
• Verwende den aktuellen Fold als Validierungsdatensatz.
• Verwende die verbleibenden 4 Folds als Trainingsdatensatz.
• Trainiere das gewählte Modell auf dem Trainingsdatensatz.
• Bewerte die Genauigkeit des Modells auf dem Validierungsdatensatz.
• Schritt 4: Berechne den Durchschnitt der Modellgenauigkeit über alle 5 Folds.

In mathematischer Form ergibt sich die mittlere Genauigkeit wie folgt:

• Sei \(\mathbf{D}\) der gesamte Datensatz mit 1000 Beispielen und 20 Merkmalen.
• Unterteile \(\mathbf{D}\) in 5 Folds: \(\mathbf{D} = \mathbf{D}_1, \mathbf{D}_2, \mathbf{D}_3, \mathbf{D}_4, \mathbf{D}_5\).
• Für jeden Fold, trainiere und evaluiere wie folgt:
• Verwende \(\mathbf{D}_i\) (i-ter Fold) als Validierungsdatensatz.
• Verwende die übrigen Daten \(\mathbf{D} - \mathbf{D}_i\) als Trainingsdatensatz.
• Trainiere das Modell auf \(\mathbf{D} - \mathbf{D}_i\).
• Berechne die Genauigkeit \(\mathbf{A}_i\) des Modells auf \(\mathbf{D}_i\).
• Berechne die mittlere Genauigkeit \(\mathbf{A}_{\text{mittel}}\):

\(\mathbf{A}_{\text{mittel}} = \frac{1}{5} \bigg(\mathbf{A}_1 + \mathbf{A}_2 + \mathbf{A}_3 + \mathbf{A}_4 + \mathbf{A}_5\bigg)\)

Der Durchschnitt der Genauigkeit über alle 5 Folds gibt die allgemeine Leistung des Modells an.

b)

Erkläre den Unterschied zwischen Grid Search und Random Search zur Hyperparameteroptimierung und diskutiere die Vor- und Nachteile beider Methoden. Führe dabei eine exemplarische Grid Search für ein Support Vector Machine-Modell mit den Hyperparametern C (Kostenparameter) und Gamma (Kernkoeffizient) durch und zeige, wie Du die besten Hyperparameter findest.

Lösung:

Grid Search vs. Random Search zur Hyperparameteroptimierung:

• Grid Search:

Grid Search ist eine exhaustive Suchmethode, bei der ein bestimmter Hyperparameterraum durch festgelegte Werte systematisch durchsucht wird. Man erstellt ein Raster (Grid) aller möglichen Kombinationen von Hyperparametern und evaluiert das Modell für jede Kombination, um die beste Performance zu finden.

• Vorteile:
• Findet garantiert die beste Kombination im angegebenen Hyperparameterraum.
• Einfach zu implementieren und zu verstehen.
• Nachteile:
• Kann sehr rechenintensiv und zeitaufwendig sein, vor allem bei großen Hyperparameter-Räumen.
• Ineffizient bei hohen Dimensionen, da viele Kombinationen evaluiert werden müssen.
• Random Search:

Bei der Random Search werden Hyperparameterwerte zufällig aus einem bestimmten Bereich gewählt und das Modell wird mit diesen Werten evaluiert. Man führt eine bestimmte Anzahl von Tests durch und wählt die Kombination aus, die die beste Leistung erbringt.

• Vorteile:
• Effizientere und schnellere Suche in großen und hochdimensionalen Hyperparameterräumen.
• Höhere Wahrscheinlichkeit, gute Kombinationen zu finden, die von einer Grid Search möglicherweise übersehen werden.
• Nachteile:
• Keine Garantie, die beste Kombination zu finden.
• Ergebnisse können variieren, da sie von der Zufallsauswahl abhängen.

Exemplarische Grid Search für ein Support Vector Machine (SVM)-Modell:

Angenommen, wir möchten die besten Hyperparameter für ein SVM-Modell finden, indem wir Grid Search verwenden. Wir wollen die Hyperparameter C (Kostenparameter) und Gamma (Kernkoeffizient) optimieren.

• Angenommene Wertebereiche:
• C = [0.1, 1, 10, 100]
• Gamma = [0.01, 0.1, 1, 10]

Erstelle ein Raster der Hyperparameterkombinationen:

• Werden alle Kombinationen von C und Gamma evaluiert:
• (C, Gamma): (0.1, 0.01), (0.1, 0.1), (0.1, 1), (0.1, 10)
• (C, Gamma): (1, 0.01), (1, 0.1), (1, 1), (1, 10)
• (C, Gamma): (10, 0.01), (10, 0.1), (10, 1), (10, 10)
• (C, Gamma): (100, 0.01), (100, 0.1), (100, 1), (100, 10)

Für jede Kombination wird das Modell trainiert und validiert:

• Führe beispielsweise K-Fold Cross-Validation durch, um die Leistung jeder Kombination zu bewerten.
• Miss die Genauigkeit des Modells für jede Kombination.

Wähle die Kombination mit der höchsten Genauigkeit:

• Angenommen, die beste Performance wurde bei (C=10, Gamma=0.1) erzielt.
• Diese Kombination wird als die besten Hyperparameter für das Modell gewählt.

Der Ansatz kann mit folgendem Pseudocode veranschaulicht werden:

 grid = {'C': [0.1, 1, 10, 100], 'Gamma': [0.01, 0.1, 1, 10]}  best_score = 0  for c in grid['C']:    for gamma in grid['Gamma']:      model = SVM(C=c, Gamma=gamma)      score = cross_val_score(model, data, labels, cv=5).mean()      if score > best_score:        best_score = score        best_parameters = {'C': c, 'Gamma': gamma}  print(best_parameters) 

c)

Implementiere eine Random Search für ein Random Forest-Modell in Python. Nutze dabei die Hyperparameter Anzahl der Bäume (n_estimators) und maximale Tiefe (max_depth). Erstelle mindestens 10 zufällige Kombinationen und berechne je Kombination die mittlere Genauigkeit via K-Fold Cross-Validation (k = 5). Zeige den Python-Code und die Ergebnisse.

Lösung:

Lösung des Unterexercise:

Im Folgenden wird eine Random Search für ein Random Forest-Modell implementiert, bei der mindestens 10 zufällige Hyperparameterkombinationen evaluiert werden. Die Hyperparameter, die untersucht werden, sind die Anzahl der Bäume (n_estimators) und die maximale Tiefe (max_depth). Die mittlere Genauigkeit wird mittels K-Fold Cross-Validation mit k = 5 berechnet.

import numpy as np  import pandas as pd  from sklearn.model_selection import RandomizedSearchCV, cross_val_score  from sklearn.ensemble import RandomForestClassifier  from sklearn.datasets import make_classification   # Erstelle einen fiktiven Datensatz zur Klassifikation  X, y = make_classification(n_samples=1000, n_features=20, random_state=42)   # Definiere den Random Forest Classifier  model = RandomForestClassifier(random_state=42)   # Definiere den Hyperparameter-Suchraum  param_distributions = {      'n_estimators': [10, 50, 100, 200, 500],      'max_depth': [None, 10, 20, 30, 40, 50]  }   # Erstelle RandomizedSearchCV-Objekt  random_search = RandomizedSearchCV(      estimator=model,      param_distributions=param_distributions,      n_iter=10,  # Anzahl der zufälligen Kombinationen      cv=5,  # K-Fold Cross-Validation      scoring='accuracy',      random_state=42  )   # Führe die Zufallssuche durch  random_search.fit(X, y)   # Zeige die besten Hyperparameter und das beste Score an  print('Beste Hyperparameter:', random_search.best_params_)  print('Beste mittlere Genauigkeit:', random_search.best_score_) 

Ergebnisse:

• Die besten Hyperparameter werden aus der zufälligen Suche ausgewählt und angezeigt. Die mittlere Genauigkeit über die 5 Folds wird ebenfalls berechnet und gezeigt.

 # Beispielausgabe (Die tatsächlichen Werte können bei jeder Ausführung variieren)  Beste Hyperparameter: {'n_estimators': 200, 'max_depth': 30}  Beste mittlere Genauigkeit: 0.865 

Die oben genannte Ausgabe zeigt ein Beispiel der besten gefundenen Hyperparameter und der dazugehörigen mittleren Genauigkeit. Durch die Random Search und K-Fold Cross-Validation erhalten wir eine belastbare Schätzung der Modellleistung bei verschiedenen Hyperparameterkombinationen.

d)

Diskutiere, warum Cross-Validation wichtig für die Generalisierbarkeit eines Modells ist. Was könnte passieren, wenn Du ausschließlich eine einfache Train-Test-Split-Validierung verwendest? Begründe Deine Antwort mit theoretischen Überlegungen und Beispielen.

Lösung:

Lösung des Unterexercise:

Die Anwendung von Cross-Validation ist entscheidend, um die Generalisierbarkeit eines Modells sicherzustellen. Hier sind die Hauptgründe, warum Cross-Validation wichtig ist:

• Robuste Leistungsschätzung: Cross-Validation ermöglicht es, die Modellleistung auf verschiedenen Teilmengen des Datensatzes zu bewerten. Durch das Aufteilen des Datensatzes in k Folds und das Iterieren über alle Folds als Validierungsset wird eine robustere und aussagekräftigere Schätzung der Modellperformance erreicht.
• Vermeidung von Overfitting: Wenn ein Modell nur auf einem Teil des Datensatzes trainiert und getestet wird, besteht die Gefahr, dass es spezifische Merkmale dieses Teilsets lernt und dadurch überangepasst wird (Overfitting). Cross-Validation hilft dabei, diese Gefahr zu minimieren, indem das Modell auf verschiedenen Teilmengen des Datensatzes trainiert und validiert wird.
• Stabilere Ergebnisse: Bei Verwendung einer einfachen Train-Test-Split-Validierung könnten zufällige Anomalien in den Trainings- oder Testdaten zu ungenauen Schätzungen der Modellperformance führen. Cross-Validation glättet diese Anomalien, indem sie die Modellleistung über mehrere Folds hinweg mittelt.

Probleme bei einfacher Train-Test-Split-Validierung:

Wenn ausschließlich eine einfache Train-Test-Split-Validierung verwendet wird, können folgende Probleme auftreten:

• Unzureichende Repräsentativität: Die Trainings- und Testdaten könnten die zugrunde liegende Datenverteilung nicht vollständig erfassen. Hierdurch könnte das Modell nicht in der Lage sein, auf neuen, unbekannten Daten gut zu generalisieren.
• Varianz in der Bewertung: Die Bewertung der Modellperformance hängt stark vom gewählten Split ab. Ein ungünstiger Split kann zu ungenauen Bewertungen und falschen Schlussfolgerungen über die Modellleistung führen.
• Risiko von Overfitting: Bei einem einfachen Split besteht ein höheres Risiko, dass das Modell Overfitting betreibt, da es spezifische Merkmale des Trainingssets lernen könnte, die im Testset nicht vorhanden sind.

Theoretische Überlegungen und Beispiele:

• Angenommen, ein Datensatz enthält 1000 Beispiele. Wenn wir einen 80-20 Split für Training und Testen anwenden, werden 800 Beispiele zum Training und 200 Beispiele zum Testen verwendet. Diese spezifische Aufteilung könnte zufällige Varianzen und Anomalien enthalten, die nicht repräsentativ für die gesamte Datenverteilung sind.
• Im Gegensatz dazu teilt eine k-Fold Cross-Validation den Datensatz in k gleiche Teile (z.B. k = 5). In jeder Iteration werden 800 Beispiele zum Training und 200 zum Validieren verwendet, aber jede Teilmenge wird genau einmal als Testset verwendet. Dadurch wird jede Beobachtung sowohl im Training als auch im Testen berücksichtigt, was zu einer robusteren und zuverlässigeren Schätzung der Modellleistung führt.

Insgesamt sorgt die Cross-Validation dafür, dass die Modellleistung allgemeiner und weniger von zufälligen Varianzen der Daten abhängig ist. Dies führt letztlich zu einem besser generalisierbaren Modell, das auch bei neuen, unbekannten Daten gut performt.

Aufgabe 3)

K-Means und hierarchisches Clustering sind zwei wichtige Methoden im Bereich des unüberwachten Lernens, die zur Clusteranalyse verwendet werden. K-Means partitioniert Daten in k Cluster und zielt darauf ab, die Varianz innerhalb der Cluster zu minimieren. Dieses Verfahren beinhaltet die Wahl von k, die zufällige Initialisierung der Clusterzentren, die Zuordnung der Datenpunkte zum nächstgelegenen Zentrum und die Aktualisierung der Zentren, bis zur Konvergenz. Auf der anderen Seite erstellt hierarchisches Clustering ein Dendrogramm und verbindet Datenpunkte zu hierarchischen Clustern; es kann entweder agglomerativ (bottom-up) oder divisiv (top-down) sein. Ein Dendrogramm visualisiert die Hierarchie der Cluster. Distanzmaße wie der euklidische Abstand und der Manhattan-Abstand können eingesetzt werden, um Ähnlichkeiten zwischen Datenpunkten zu messen. Kriterien wie der Silhouettenkoeffizient oder die Elbow-Methode helfen bei der Bestimmung der optimalen Anzahl von Clustern. Beide Methoden sind Teil des unüberwachten Lernens und erfordern keine vorab zugewiesenen Labels.

a)

Implementiere den K-Means-Algorithmus in Python und teste ihn an einem synthetischen Datensatz mit drei sichtbaren Clustern. Verwende den euklidischen Abstand als Distanzmaß. Visualisiere die Cluster am Ende als Scatterplot. Kommentiere in deinem Code die einzelnen Schritte des Algorithmus ausführlich.

import numpy as npimport matplotlib.pyplot as pltfrom sklearn.datasets import make_blobs# Erstellen eines synthetischen DatensatzesX, _ = make_blobs(n_samples=300, centers=3, cluster_std=0.60, random_state=0)# Implementiere hier den K-Means Algorithmusclass KMeans:    def __init__(self, k=3, max_iters=100):        self.k = k        self.max_iters = max_iters        self.centroids = None    def fit(self, X):        # Schritt 1: Initialisiere die Zentren zufällig        self.centroids = X[np.random.choice(X.shape[0], self.k, replace=False)]        for _ in range(self.max_iters):            # Schritt 2: Datenpunkte den nächstgelegenen Zentren zuweisen            labels = self._assign_clusters(X)            # Schritt 3: Zentren aktualisieren            old_centroids = self.centroids            self.centroids = self._update_centroids(X, labels)            # Schritt 4: Prüfen der Konvergenz            if np.all(old_centroids == self.centroids):                break        return self.centroids    def _assign_clusters(self, X):        distances = np.zeros((X.shape[0], self.k))        for k in range(self.k):            distances[:, k] = np.linalg.norm(X - self.centroids[k], axis=1)        return np.argmin(distances, axis=1)    def _update_centroids(self, X, labels):        centroids = np.zeros((self.k, X.shape[1]))        for k in range(self.k):            centroids[k] = X[labels == k].mean(axis=0)        return centroids# Programmtestkmeans = KMeans(k=3)centroids = kmeans.fit(X)labels = kmeans._assign_clusters(X)# Visualisierung der Ergebnisseplt.scatter(X[:, 0], X[:, 1], c=labels, s=50, cmap='viridis')plt.scatter(centroids[:, 0], centroids[:, 1], s=200, c='red', alpha=0.75)plt.show() 

Lösung:

• K-Means und hierarchisches Clustering sind zwei wichtige Methoden im Bereich des unüberwachten Lernens, die zur Clusteranalyse verwendet werden. K-Means partitioniert Daten in k Cluster und zielt darauf ab, die Varianz innerhalb der Cluster zu minimieren. Dieses Verfahren beinhaltet die Wahl von k, die zufällige Initialisierung der Clusterzentren, die Zuordnung der Datenpunkte zum nächstgelegenen Zentrum und die Aktualisierung der Zentren, bis zur Konvergenz. Auf der anderen Seite erstellt hierarchisches Clustering ein Dendrogramm und verbindet Datenpunkte zu hierarchischen Clustern; es kann entweder agglomerativ (bottom-up) oder divisiv (top-down) sein. Ein Dendrogramm visualisiert die Hierarchie der Cluster. Distanzmaße wie der euklidische Abstand und der Manhattan-Abstand können eingesetzt werden, um Ähnlichkeiten zwischen Datenpunkten zu messen. Kriterien wie der Silhouettenkoeffizient oder die Elbow-Methode helfen bei der Bestimmung der optimalen Anzahl von Clustern. Beide Methoden sind Teil des unüberwachten Lernens und erfordern keine vorab zugewiesenen Labels.

• Solve the following subexercise:
• Implementiere den K-Means-Algorithmus in Python und teste ihn an einem synthetischen Datensatz mit drei sichtbaren Clustern. Verwende den euklidischen Abstand als Distanzmaß. Visualisiere die Cluster am Ende als Scatterplot. Kommentiere in deinem Code die einzelnen Schritte des Algorithmus ausführlich.

import numpy as npimport matplotlib.pyplot as pltfrom sklearn.datasets import make_blobs# Erstellen eines synthetischen DatensatzesX, _ = make_blobs(n_samples=300, centers=3, cluster_std=0.60, random_state=0)# Implementiere hier den K-Means Algorithmusclass KMeans:    def __init__(self, k=3, max_iters=100):        self.k = k        self.max_iters = max_iters        self.centroids = None        def fit(self, X):        # Schritt 1: Initialisiere die Zentren zufällig        self.centroids = X[np.random.choice(X.shape[0], self.k, replace=False)]                for _ in range(self.max_iters):            # Schritt 2: Datenpunkte den nächstgelegenen Zentren zuweisen            labels = self._assign_clusters(X)                        # Schritt 3: Zentren aktualisieren            old_centroids = self.centroids            self.centroids = self._update_centroids(X, labels)                        # Schritt 4: Prüfen der Konvergenz            if np.all(old_centroids == self.centroids):                break        return self.centroids        def _assign_clusters(self, X):        distances = np.zeros((X.shape[0], self.k))        for k in range(self.k):            distances[:, k] = np.linalg.norm(X - self.centroids[k], axis=1)        return np.argmin(distances, axis=1)        def _update_centroids(self, X, labels):        centroids = np.zeros((self.k, X.shape[1]))        for k in range(self.k):            centroids[k] = X[labels == k].mean(axis=0)        return centroids# Programmtestkmeans = KMeans(k=3)centroids = kmeans.fit(X)labels = kmeans._assign_clusters(X)# Visualisierung der Ergebnisseplt.scatter(X[:, 0], X[:, 1], c=labels, s=50, cmap='viridis')plt.scatter(centroids[:, 0], centroids[:, 1], s=200, c='red', alpha=0.75)plt.show() 

b)

Beschreibe den Unterschied zwischen agglomerativen und divisiven Methoden des hierarchischen Clusterings. Verwende ein Beispiel für jeden Typ und erläutere, wie die Dendrogramme für diese Beispiele aussehen würden.

Lösung:

• K-Means und hierarchisches Clustering sind zwei wichtige Methoden im Bereich des unüberwachten Lernens, die zur Clusteranalyse verwendet werden. K-Means partitioniert Daten in k Cluster und zielt darauf ab, die Varianz innerhalb der Cluster zu minimieren. Dieses Verfahren beinhaltet die Wahl von k, die zufällige Initialisierung der Clusterzentren, die Zuordnung der Datenpunkte zum nächstgelegenen Zentrum und die Aktualisierung der Zentren, bis zur Konvergenz. Auf der anderen Seite erstellt hierarchisches Clustering ein Dendrogramm und verbindet Datenpunkte zu hierarchischen Clustern; es kann entweder agglomerativ (bottom-up) oder divisiv (top-down) sein. Ein Dendrogramm visualisiert die Hierarchie der Cluster. Distanzmaße wie der euklidische Abstand und der Manhattan-Abstand können eingesetzt werden, um Ähnlichkeiten zwischen Datenpunkten zu messen. Kriterien wie der Silhouettenkoeffizient oder die Elbow-Methode helfen bei der Bestimmung der optimalen Anzahl von Clustern. Beide Methoden sind Teil des unüberwachten Lernens und erfordern keine vorab zugewiesenen Labels.

• Solve the following subexercise:
• Beschreibe den Unterschied zwischen agglomerativen und divisiven Methoden des hierarchischen Clusterings. Verwende ein Beispiel für jeden Typ und erläutere, wie die Dendrogramme für diese Beispiele aussehen würden.

• Agglomerative Methoden:
  • Beschreibung: Beim agglomerativen hierarchischen Clustering beginnt man mit jedem Datenpunkt als eigenem Cluster und verbindet schrittweise die nächsten Paare von Clustern, bis alle Datenpunkte in einem einzigen Cluster zusammengefasst sind. Dieser Ansatz wird auch als „bottom-up“ bezeichnet, da man von den kleinsten Einheiten (einzelne Punkte) nach oben arbeitet.
  • Beispiel: Angenommen, Du hast die Punkte A, B, C und D. Beginnend mit jedem Punkt einzeln: (A), (B), (C), (D). Zuerst werden die zwei nächsten Punkte (hier A und B) zu einem Cluster zusammengefügt: (AB), (C), (D). Danach wird der nächste nächste Cluster hinzugefügt und so weiter: (ABC), (D). Schließlich: (ABCD).
  • Dendrogramm: Ein Dendrogramm für dieses Beispiel würde wie ein nach oben wachsender Baum aussehen, in dem sich die Cluster an der unteren Basis (die einzelnen Punkte) zu größeren Clustern auf höheren Ebenen verbinden. Zum Beispiel würden die Verbindungen AB, C und D an der niedrigsten Ebene liegen, dann ABC und D eine Ebene darüber, und schließlich ABCD auf der höchsten Ebene.
• Divisive Methoden:
  • Beschreibung: Beim divisiven hierarchischen Clustering beginnt man mit allen Datenpunkten in einem einzigen Cluster und teilt diesen schrittweise in kleinere Untergruppen, bis jede Gruppe nur noch einen einzelnen Datenpunkt enthält. Dieser Ansatz wird auch als „top-down“ bezeichnet, da man von der größten Einheit (alles zusammen) nach unten arbeitet.
  • Beispiel: Angenommen, Du hast die Punkte A, B, C und D. Beginnend mit allen Punkten zusammen: (ABCD). Dann teilt man den Cluster in zwei Untergruppen: (AB) und (CD). Danach teilt man weiter: (A) und (B), sowie (C) und (D). Schließlich hat man: (A), (B), (C) und (D).
  • Dendrogramm: Ein Dendrogramm für dieses Beispiel würde wie ein nach unten wachsender Baum aussehen, in dem der größte Cluster an der Spitze steht und sich in kleinere Cluster auf niedrigeren Ebenen aufspaltet. Zum Beispiel würde ABCD an der obersten Ebene stehen, dann die Aufspaltungen in AB und CD auf der nächsten Ebene darunter, und am Ende die einzelnen Punkte A, B, C und D auf den unteren Ebenen.

c)

Verwende die Elbow-Methode, um die optimale Anzahl von Clustern auf dem oben erstellten synthetischen Datensatz zu bestimmen. Visualisiere den Elbow-Plot und gib die geschätzte optimale Anzahl an Clustern an.

import numpy as npimport matplotlib.pyplot as pltfrom sklearn.datasets import make_blobsfrom sklearn.cluster import KMeans# Wiederholtes Generieren des synthetischen DatensatzesX, _ = make_blobs(n_samples=300, centers=3, cluster_std=0.60, random_state=0)# Elbow-Methodeinertia = []K = range(1, 10)for k in K:    kmeans = KMeans(n_clusters=k)    kmeans.fit(X)    inertia.append(kmeans.inertia_)plt.figure(figsize=(8, 5))plt.plot(K, inertia, 'bx-')plt.xlabel('Anzahl der Cluster')plt.ylabel('Trägheit')plt.title('Elbow-Methode zur Bestimmung der optimalen Clusteranzahl')plt.show() 

Lösung:

• K-Means und hierarchisches Clustering sind zwei wichtige Methoden im Bereich des unüberwachten Lernens, die zur Clusteranalyse verwendet werden. K-Means partitioniert Daten in k Cluster und zielt darauf ab, die Varianz innerhalb der Cluster zu minimieren. Dieses Verfahren beinhaltet die Wahl von k, die zufällige Initialisierung der Clusterzentren, die Zuordnung der Datenpunkte zum nächstgelegenen Zentrum und die Aktualisierung der Zentren, bis zur Konvergenz. Auf der anderen Seite erstellt hierarchisches Clustering ein Dendrogramm und verbindet Datenpunkte zu hierarchischen Clustern; es kann entweder agglomerativ (bottom-up) oder divisiv (top-down) sein. Ein Dendrogramm visualisiert die Hierarchie der Cluster. Distanzmaße wie der euklidische Abstand und der Manhattan-Abstand können eingesetzt werden, um Ähnlichkeiten zwischen Datenpunkten zu messen. Kriterien wie der Silhouettenkoeffizient oder die Elbow-Methode helfen bei der Bestimmung der optimalen Anzahl von Clustern. Beide Methoden sind Teil des unüberwachten Lernens und erfordern keine vorab zugewiesenen Labels.
• Solve the following subexercise:
• Verwende die Elbow-Methode, um die optimale Anzahl von Clustern auf dem oben erstellten synthetischen Datensatz zu bestimmen. Visualisiere den Elbow-Plot und gib die geschätzte optimale Anzahl an Clustern an.

import numpy as npimport matplotlib.pyplot as pltfrom sklearn.datasets import make_blobsfrom sklearn.cluster import KMeans# Wiederholtes Generieren des synthetischen DatensatzesX, _ = make_blobs(n_samples=300, centers=3, cluster_std=0.60, random_state=0)# Elbow-Methodeinertia = []K = range(1, 10)for k in K:     kmeans = KMeans(n_clusters=k)    kmeans.fit(X)    inertia.append(kmeans.inertia_)# Visualisieren des Elbow-Plotsplt.figure(figsize=(8, 5))plt.plot(K, inertia, 'bx-')plt.xlabel('Anzahl der Cluster')plt.ylabel('Trägheit')plt.title('Elbow-Methode zur Bestimmung der optimalen Clusteranzahl')plt.show()

• Erklärung:
  • Synthetischer Datensatz: Der Datensatz wird erneut generiert, um sicherzustellen, dass er konsistent mit dem vorherigen Beispiel ist.
  • KMeans-Implementierung: Eine Schleife läuft über mögliche Clusteranzahlen (1 bis 9) und führt den K-Means-Algorithmus für jede Anzahl durch. Die Trägheit (inertia) für jede Clusternummer wird berechnet und gespeichert.
  • Visualisierung: Der Elbow-Plot wird erstellt, indem die Trägheit gegen die Anzahl der Cluster geplottet wird. Der „Ellbogen“ im Plot repräsentiert die optimale Anzahl von Clustern. Eine deutliche Knickstelle im Plot zeigt, wo die Varianz innerhalb der Cluster plötzlich weniger stark abnimmt. Dies ist die geschätzte optimale Anzahl an Clustern.
• Ergebnis: In deinem Fall ist der Ellbogen bei ungefähr 3 sichtbar, was zeigt, dass die optimale Anzahl der Cluster für diesen Datensatz 3 ist. Dies bestätigt die generierten Clusteranzahl aus dem synthetischen Datensatz.

Aufgabe 4)

PCA und t-SNEPCA und t-SNE sind Dimensionreduktionsverfahren.

• PCA: Hauptkomponentenanalyse zur Reduktion hoher Dimensionalität durch Finden der Hauptkomponenten (Eigenvektoren).
• t-SNE: Nichtlineare Methode zur Visualisierung hochdimensionaler Daten durch Projektion auf geringdimensionalen Raum.
• PCA Methoden: \(X = U \Sigma V^T\)
• t-SNE Ziel: Minimierung der Kullback-Leibler-Divergenz.

c)

Implementiere ein t-SNE Verfahren in Python zur Reduktion der selben Datenmatrix \(X\) und visualisiere die Ergebnisse in einem zweidimensionalen Streudiagramm. Diskutiere die resultierende Visualisierung und vergleiche sie mit der durch die PCA erzeugten.

Lösung:

Implementierung von t-SNE in Python zur Reduktion der Datenmatrix und Visualisierung der Ergebnisse:

Die Datenmatrix X mit den Dimensionen 100 × 50 soll mithilfe von t-SNE auf zwei Dimensionen reduziert und anschließend visualisiert werden. Wir werden die Bibliothek scikit-learn nutzen, um t-SNE zu implementieren und die Ergebnisse in einem Streudiagramm darzustellen.

Implementierung:

import numpy as npimport matplotlib.pyplot as pltfrom sklearn.manifold import TSNEfrom sklearn.preprocessing import StandardScaler# Beispielhafte Generierung einer Datenmatrix X (100x50)np.random.seed(42)X = np.random.rand(100, 50)# Standardisierung der Datenscaler = StandardScaler()X_standardisiert = scaler.fit_transform(X)# t-SNE Implementierungtsne = TSNE(n_components=2, random_state=42)X_tsne = tsne.fit_transform(X_standardisiert)# Visualisierung der Ergebnisseplt.scatter(X_tsne[:, 0], X_tsne[:, 1], c='blue', edgecolor='k')plt.title('t-SNE Visualisierung')plt.xlabel('Komponente 1')plt.ylabel('Komponente 2')plt.show()

Diskussion der resultierenden Visualisierung und Vergleich mit PCA:

Die obige Implementierung nutzt t-SNE zur Reduktion der Datenmatrix auf zwei Dimensionen und visualisiert die Ergebnisse in einem Streudiagramm.

• t-SNE Visualisierung:Die t-SNE-Visualisierung zeigt Cluster und lokale Strukturen in den Daten, die möglicherweise besser erhalten bleiben als bei linearen Methoden wie PCA. Da t-SNE die Kullback-Leibler-Divergenz minimiert, zielt es darauf ab, dass nah beieinander liegende Punkte im hochdimensionalen Raum auch im niedrigdimensionalen Raum nah beieinander liegen. Dies führt oft zu einer klareren Trennung von Clustern.
• PCA Visualisierung:Die durch PCA erzeugte Visualisierung zeigt die Richtung der größten Varianz in den Daten. PCA ist linear, was bedeutet, dass sie die globalen Strukturen und Muster der Daten betont, jedoch möglicherweise lokale Strukturen weniger genau einfängt.

Zusammenfassung:

t-SNE und PCA haben unterschiedliche Ansätze zur Dimensionreduktion. PCA ist eine lineare Methode, die die globale Struktur der Daten betont und die maximale Varianz in niedrigen Dimensionen abbildet. t-SNE hingegen ist nichtlinear und fokussiert darauf, lokale Strukturen und Cluster hervorzuheben, indem es die Kullback-Leibler-Divergenz minimiert. In der Praxis eignet sich t-SNE besser zur Visualisierung und Untersuchung von Clustern in hochdimensionalen Daten, während PCA häufig zur Datenvorverarbeitung und Merkmalsreduktion verwendet wird.