Knowledge Discovery in Databases mit Übung - Exam

Aufgabe 1)

Du arbeitest als Datenwissenschaftler für ein E-Commerce-Unternehmen und bist verantwortlich für die Reinigung und Aufbereitung eines großen Datensatzes mit Kundentransaktionsdaten. Der Datensatz enthält mehrere Inkonsistenzen, fehlende Werte, Duplikate und Rauschen. Zur Verbesserung der Datenqualität und Genauigkeit ist eine gründliche Datenbereinigung unerlässlich.

a)

Beschreibe drei Techniken, die Du verwenden würdest, um den Datensatz von Rauschen und Inkonsistenzen zu bereinigen. Erkläre dabei jeweils den grundsätzlichen Ansatz der Technik und wie sie speziell in Deinem Fall angewendet werden könnte.

Lösung:

Um den Datensatz von Rauschen und Inkonsistenzen zu bereinigen, sind hier drei Techniken, die ich verwenden würde:

• Technik 1: Erkennen und Entfernen von Ausreißern Grundsätzlicher Ansatz: Ausreißer sind ungewöhnlich hohe oder niedrige Werte, welche die Analyse verfälschen können. Diese können durch die Verwendung statistischer Methoden wie der Z-Score-Berechnung oder dem Interquartilsabstand (IQR) identifiziert werden. Werte, die über einen definierten Schwellenwert hinausgehen, werden als Ausreißer betrachtet. Anwendung in Deinem Fall: In Deinem Kundentransaktionsdatensatz könnten extrem hohe Transaktionsbeträge auf Fehler oder Betrug hinweisen. Durch die Berechnung des Z-Scores für die Transaktionsbeträge könnten Werte, die z.B. mehr als 3 Standardabweichungen vom Mittelwert abweichen, als Ausreißer identifiziert und entweder entfernt oder weiter untersucht werden.
• Technik 2: Imputation fehlender Werte Grundsätzlicher Ansatz: Fehlende Werte können die Analyse der Daten beeinträchtigen. Statt diese einfach zu entfernen, was zu einem Verlust wertvoller Informationen führen könnte, können verschiedene Imputationstechniken verwendet werden. Dazu gehören Mittelwert-, Median- oder Modus-Imputation sowie fortgeschrittene Methoden wie die Mehrfache Imputation oder die K-Nearest-Neighbors (KNN) Imputation. Anwendung in Deinem Fall: Wenn in Deinem Datensatz beispielsweise das Feld „Einkommen“ für einige Kunden fehlt, könntest Du den Mittelwert der bekannten Einkommen nutzen, um die fehlenden Werte zu ersetzen. Alternativ kannst Du fortgeschrittene Methoden wie KNN verwenden, um basierend auf den Eigenschaften ähnlicher Kunden realistischere Werte zu imputieren.
• Technik 3: Entfernen von Duplikaten Grundsätzlicher Ansatz: Duplikate treten häufig in großen Datensätzen auf und können Analysen verfälschen. Das Entfernen von Duplikaten erfordert eine sorgfältige Überprüfung der Daten, um sicherzustellen, dass nur echte Duplikate entfernt werden. Dies kann durch die Verwendung eindeutiger Schlüssel oder durch den Vergleich mehrerer Felder erreicht werden. Anwendung in Deinem Fall: In Deinem Kundentransaktionsdatensatz könnten Duplikate auftreten, wenn zum Beispiel gleiche Transaktionen versehentlich mehrfach erfasst wurden. Durch die Überprüfung von Feldern wie Transaktions-ID, Datum und Betrag kannst Du echte Duplikate identifizieren und entfernen, um sicherzustellen, dass jede Transaktion nur einmal im Datensatz vorhanden ist.

b)

Ein häufiger Fehler im Datensatz ist das Fehlen von transaktionsspezifischen Informationen wie dem Transaktionsbetrag oder dem Datum. Beschreibe den Prozess der Imputation und wähle eine geeignete Methode, um die fehlenden Werte im Datensatz zu ersetzen. Begründe Deine Entscheidung und berechne ein Beispiel mit fiktiven Daten. Angenommen, die Transaktionsbeträge in EUR sind: [50, 75, ?, 100, ?, 90].

Lösung:

Um die fehlenden Werte im Datensatz zu ersetzen, kannst Du den Prozess der Imputation nutzen. Imputation ist eine Technik, bei der fehlende Werte durch geschätzte Werte ersetzt werden, die auf den vorhandenen Daten basieren. Dies hilft, die Integrität des Datensatzes zu bewahren und die Genauigkeit der Analysen zu verbessern.

Schritte der Imputation

• Erkennen der fehlenden Werte: Der erste Schritt besteht darin, die fehlenden Werte im Datensatz zu identifizieren. Dies kann manuell oder mit Hilfe von Bibliotheken wie Pandas in Python erfolgen.
• Wahl einer Imputationsmethode: Es gibt mehrere Methoden zur Imputation, wie z.B. Mittelwert-, Median-, Modus-Imputation oder fortgeschrittenere Methoden wie K-Nearest-Neighbors (KNN) oder Mehrfache Imputation. Jede Methode hat ihre Vor- und Nachteile.
• Imputation der fehlenden Werte: Nachdem eine Methode gewählt wurde, werden die fehlenden Werte ersetzt.
• Überprüfung der Resultate: Es ist wichtig, zu überprüfen, ob die Imputation sinnvoll ist und keine Verzerrungen oder unerwünschten Muster eingeführt wurden.

Geeignete Methode und Begründung

In diesem Fall würde ich die Mittelwert-Imputation wählen. Diese Methode ist einfach zu implementieren und funktioniert gut für numerische Daten wie Transaktionsbeträge, wenn der Datensatz keine extremen Ausreißer enthält, die den Mittelwert verzerren könnten. Der Mittelwert gibt auch einen guten Schätzwert für den Durchschnitt der Transaktionsbeträge.

Beispielrechnung

Angenommen, die Transaktionsbeträge in EUR sind: [50, 75, ?, 100, ?, 90]. Zuerst berechnen wir den Mittelwert der vorhandenen Werte:

• Vorhandene Werte: 50, 75, 100, 90
• Mittelwert = \frac{50 + 75 + 100 + 90}{4} = \frac{315}{4} = 78.75

Jetzt können wir die fehlenden Werte (markiert als ?) durch den Mittelwert ersetzen:

Transaktionsbeträge: [50, 75, 78.75, 100, 78.75, 90]

Durchführung in Python

import pandas as pdimport numpy as np# Initialer Datensatz mit fehlenden Wertendaten = {'Transaktionsbetrag': [50, 75, np.nan, 100, np.nan, 90]}df = pd.DataFrame(daten)# Mittelwert berechnenmittelwert = df['Transaktionsbetrag'].mean()# Fehldaten durch Mittelwert ersetzendf['Transaktionsbetrag'].fillna(mittelwert, inplace=True)print(df)

Das Ergebnis ist ein bereinigter Datensatz:

Transaktionsbetrag0              50.001              75.002              78.753             100.004              78.755              90.00

Durch die Mittelwert-Imputation haben wir die fehlenden Werte durch den berechneten Mittelwert ersetzt, was zu einem vollständigen Datensatz führt.

c)

Im Datensatz wurden Duplikate entdeckt, die zwischen fehlerhaften und korrekten Datenzeilen unterscheiden. Beschreibe den Prozess der Deduplication und entwickle einen Algorithmus in Python, der diese Duplikate identifiziert und entfernt. Zeige ein Beispiel anhand der folgenden fiktiven Daten (ID, Kunde, Transaktion, Datum): [(1, 'A', 100, '2023-10-01'), (2, 'B', 200, '2023-10-02'), (1, 'A', 100, '2023-10-01'), (3, 'C', 150, '2023-10-03')].

Lösung:

Der Prozess der Deduplication, also das Entfernen von Duplikaten, ist essenziell, um die Datenqualität zu gewährleisten und genaue Analysen durchführen zu können. Hier sind die Schritte zur Deduplication und ein Python-Algorithmus, der dies erreicht:

Schritte der Deduplication

• Erkennen von Duplikaten: Identifiziere Zeilen, die mehrfach im Datensatz vorkommen. Dies kann durch den Vergleich von Schlüsselattributen wie der ID, Kunde, Transaktion und Datum erfolgen.
• Bestimmung der zu behaltenden Zeile: Entscheide, welche der Duplikate korrekt sind. Oft wird die erste gefundene Zeile behalten und die restlichen entfernt.
• Entfernen der Duplikate: Entferne die erkannten Duplikate aus dem Datensatz.
• Überprüfung der Resultate: Überprüfe den bereinigten Datensatz, um sicherzustellen, dass keine unerwünschten Zeilen entfernt oder behalten wurden.

Algorithmus in Python

Hier ist ein Python-Algorithmus, der die Duplikate in einem DataFrame basierend auf allen Spalten erkennt und entfernt:

import pandas as pd# Fiktive Datendaten = [(1, 'A', 100, '2023-10-01'),         (2, 'B', 200, '2023-10-02'),         (1, 'A', 100, '2023-10-01'),         (3, 'C', 150, '2023-10-03')]# Erstellen des DataFramesdf = pd.DataFrame(daten, columns=['ID', 'Kunde', 'Transaktion', 'Datum'])# Anzeigen des ursprünglichen DataFramesprint('Ursprünglicher DataFrame:')print(df)# Identifizieren und Entfernen von Duplikatendf_bereinigt = df.drop_duplicates()# Anzeigen des bereinigten DataFramesprint('Bereinigter DataFrame:')print(df_bereinigt)

Beispiel mit den gegebenen Daten

Der ursprüngliche Datensatz enthält Duplikate:

ID  Kunde  Transaktion       Datum0   1      A          100  2023-10-011   2      B          200  2023-10-022   1      A          100  2023-10-013   3      C          150  2023-10-03

Nach der Deduplication sieht der bereinigte Datensatz wie folgt aus:

ID  Kunde  Transaktion       Datum0   1      A          100  2023-10-011   2      B          200  2023-10-023   3      C          150  2023-10-03

In diesem Beispiel wurde die duplizierte Zeile (ID 1, Kunde 'A', Transaktion 100, Datum '2023-10-01') erfolgreich entfernt.

Dieser Algorithmus identifiziert und entfernt Duplikate basierend auf allen Spalten des DataFrames. Du kannst die Methode drop_duplicates() weiter anpassen, indem Du angibst, welche Spalten verglichen werden sollen, oder indem Du definierst, welche der duplizierten Zeilen beibehalten werden soll (z.B. die erste oder die letzte).

Aufgabe 2)

Du hast einen Datensatz mit Verkaufszahlen für ein Online-Geschäft, der tägliche Verkaufszahlen über einen Zeitraum von einem Jahr enthält. Deine Aufgabe besteht darin, verschiedene Datenvorbereitungs- und Transformationstechniken anzuwenden, um die Daten für die weitere Analyse zu normalisieren und zu aggregieren. Die täglichen Verkaufszahlen variieren stark, sodass verschiedene Normalisierungsmethoden in Betracht gezogen werden müssen. Ebenfalls sollen verschiedene Aggregationstechniken verwendet werden, um monatliche Summen und Durchschnittswerte zu berechnen.

a)

Wende die Min-Max-Skalierung auf die Verkaufszahlen an. Die niedrigste Verkaufszahl im Datensatz beträgt 10 und die höchste Verkaufszahl beträgt 500. Berechne die normalisierten Werte für eine Verkaufszahl von 200 und 450. Verwende die Formel: \ \( \text{X'} = \frac{\text{X} - \text{min}(X)}{\text{max}(X) - \text{min}(X)} \)

Lösung:

Um die Min-Max-Skalierung auf die Verkaufszahlen anzuwenden, verwenden wir die gegebene Formel:

\( \text{X'} = \frac{\text{X} - \text{min}(X)}{\text{max}(X) - \text{min}(X)} \)

Hierbei:

• min(X) = 10 (niedrigste Verkaufszahl)
• max(X) = 500 (höchste Verkaufszahl)
• X = Verkaufszahl, die normalisiert werden soll

Wir berechnen die normalisierten Werte für:

• Verkaufszahl von 200
• Verkaufszahl von 450

Für die Verkaufszahl 200:

\( \text{X'} = \frac{200 - 10}{500 - 10} \)\( \text{X'} = \frac{190}{490} \)\( \text{X'} ≈ 0.3878 \)

Für die Verkaufszahl 450:

\( \text{X'} = \frac{450 - 10}{500 - 10} \)\( \text{X'} = \frac{440}{490} \)\( \text{X'} ≈ 0.8979 \)

Die normalisierten Werte sind somit:

• Für eine Verkaufszahl von 200: 0.3878
• Für eine Verkaufszahl von 450: 0.8979

b)

Eine weitere Methode zur Normalisierung ist die Z-Skalierung. Berechne die z-transformierten Werte für die Verkaufszahlen 200 und 450. Gegeben sind der Mittelwert \( \text{mean}(X) = 150 \) und die Standardabweichung \( \text{std}(X) = 50 \). Verwende die Formel: \ \( \text{Z} = \frac{\text{X} - \text{mean}(X)}{\text{std}(X)} \)

Lösung:

Um die Z-Skalierung auf die Verkaufszahlen anzuwenden, verwenden wir die gegebene Formel:

\( \text{Z} = \frac{\text{X} - \text{mean}(X)}{\text{std}(X)} \)

Hierbei:

• mean(X) = 150 (Mittelwert)
• std(X) = 50 (Standardabweichung)
• X = Verkaufszahl, die z-transformiert werden soll

Wir berechnen die z-transformierten Werte für:

• Verkaufszahl von 200
• Verkaufszahl von 450

Für die Verkaufszahl 200:

\( \text{Z} = \frac{200 - 150}{50} \)\( \text{Z} = \frac{50}{50} \)\( \text{Z} = 1 \)

Für die Verkaufszahl 450:

\( \text{Z} = \frac{450 - 150}{50} \)\( \text{Z} = \frac{300}{50} \)\( \text{Z} = 6 \)

Die z-transformierten Werte sind somit:

• Für eine Verkaufszahl von 200: 1
• Für eine Verkaufszahl von 450: 6

c)

Berechne für die Verkaufszahlen eines Monats den Durchschnitt und die Summe der Verkäufe. Gegeben sind die Verkaufszahlen: [120, 130, 150, 180, 200, 210, 220, 240, 260, 280, 300, 310, 320, 330, 340, 350, 360, 370, 380, 390, 400, 420, 440, 460, 480, 500, 520, 540, 560, 580]. Verwende die Formeln: \ \( \text{Durchschnitt} = \frac{1}{N}\sum_{i=1}^{N} X_i \) \ \( \text{Summe} = \sum_{i=1}^{N} X_i \)

Lösung:

Um den Durchschnitt und die Summe der Verkaufszahlen des Monats zu berechnen, verwenden wir die folgenden Formeln:

 \( \text{Durchschnitt} = \frac{1}{N} \sum_{i=1}^{N} X_i \)  \( \text{Summe} = \sum_{i=1}^{N} X_i \) 

Gegeben sind die Verkaufszahlen des Monats:

[120, 130, 150, 180, 200, 210, 220, 240, 260, 280, 300, 310, 320, 330, 340, 350, 360, 370, 380, 390, 400, 420, 440, 460, 480, 500, 520, 540, 560, 580]

Hierbei ist N die Anzahl der Tage des Monats, also:

N = 30

Wir berechnen zuerst die Summe der Verkaufszahlen:

 \( \text{Summe} = 120 + 130 + 150 + 180 + 200 + 210 + 220 + 240 + 260 + 280 + 300 + 310 + 320 + 330 + 340 + 350 + 360 + 370 + 380 + 390 + 400 + 420 + 440 + 460 + 480 + 500 + 520 + 540 + 560 + 580 \)  \( \text{Summe} = 9300 \) 

Nun berechnen wir den Durchschnitt der Verkaufszahlen:

 \( \text{Durchschnitt} = \frac{1}{30} \times \text{Summe} \)  \( \text{Durchschnitt} = \frac{1}{30} \times 9300 \)  \( \text{Durchschnitt} = 310 \) 

Die Ergebnisse sind somit:

• Durchschnitt: 310
• Summe: 9300

Aufgabe 3)

Überwachtes Lernen, einschließlich Regression und Klassifikation Angewandtes Lernen aus bekannten Eingabe- und Ausgabe-Datenpaaren, um ein Modell zu erstellen, das zukünftige Ausgaben vorhersagen kann.

• Grundlegende Methoden: Regression und Klassifikation
• Regression: Vorhersage kontinuierlicher Werte, z.B. lineare Regression; Formel: \(y = \beta_0 + \beta_1 x + \epsilon \)
• Klassifikation: Zuweisung von Kategorien, z.B. logistische Regression; Entscheidungsgrenzen: \(P(y=1|x) = \frac{1}{1+e^{-wx}} \)
• Wichtig: Datensätze in Trainings- und Testdaten unterteilen
• Evaluationsmetriken: RMSE für Regression, Genauigkeit für Klassifikation
• Algorithmen: k-NN, SVM, Entscheidungsbäume

a)

Angenommen, Du hast einen Datensatz mit den Attributen Anzahl Studienstunden (x) und erreichte Punktzahl (y). Du möchtest das Modell einer linearen Regression fitten.

• Gib die allgemeine Form der linearen Regressionsgleichung an.
• Erkläre, wie Du die Parameter \( \beta_0 \) und \( \beta_1 \) schätzen würdest.
• Wenn Du ein Modell trainiert hast und die berechneten Parameter \( \beta_0 = 2 \) und \( \beta_1 = 5 \) sind, was wäre die vorhergesagte Punktzahl für jemanden, der 3 Stunden studiert hat?

Lösung:

• Allgemeine Form der linearen Regressionsgleichung: Die allgemeine Form der linearen Regressionsgleichung ist:

   y = \beta_0 + \beta_1 x + \epsilon 

  Hierbei ist y die vorhergesagte abhängige Variable (die erreichte Punktzahl), x die unabhängige Variable (die Anzahl der Studienstunden), \(\beta_0\) ist der Achsenabschnitt und \(\beta_1\) ist die Steigung der Regressionsgeraden. Das \(\epsilon\) steht für den Fehlerterm.
• Schätzung der Parameter \(\beta_0\) und \(\beta_1\): Die Parameter \(\beta_0\) und \(\beta_1\) werden durch die Methode der kleinsten Quadrate geschätzt, indem die Summe der quadratischen Abstände (Fehler) zwischen den beobachteten Werten und den vorhergesagten Werten minimiert wird. Die Formeln zur Schätzung lauten wie folgt:

  \(\beta_1 = \frac{\sum{(x_i - \overline{x})(y_i - \overline{y})}}{\sum{(x_i - \overline{x})^2}}\)\(\beta_0 = \overline{y} - \beta_1\overline{x}\)

  Hierbei sind \( \overline{x} \) und \( \overline{y} \) die Mittelwerte der unabhängigen und abhängigen Variablen.
• Vorhergesagte Punktzahl für jemanden, der 3 Stunden studiert hat: Wenn das trainierte Modell die Parameter \(\beta_0 = 2\) und \(\beta_1 = 5\) hat, kann die vorhergesagte Punktzahl für jemanden, der 3 Stunden studiert hat, durch Einsetzen der Werte in die lineare Regressionsgleichung berechnet werden:

   y = 2 + 5 \cdot 3  y = 2 + 15  y = 17 

  Somit wäre die vorhergesagte Punktzahl 17.

b)

Für eine Klassifikationsaufgabe hast Du zwei Kategorien: bestanden (y=1) und nicht bestanden (y=0). Du verwendest logistische Regression, um vorherzusagen, ob ein Student bestehen wird basierend auf der Anzahl der Studienstunden (x).

• Schreibe die allgemeine Form der logistischen Regressionsgleichung.
• Erkläre, wie die Entscheidungsgrenze genutzt wird, um eine Klasse zu bestimmen.
• Angenommen, die Gewichte des Modells sind \( w = [1, 2] \). Was ist die Wahrscheinlichkeit, dass ein Student mit 1 Stunde Studienzeit bestehen wird?

Lösung:

• Allgemeine Form der logistischen Regressionsgleichung: Die logistische Regressionsgleichung ist wie folgt:

  P(y=1|x) = \frac{1}{1+e^{-(w_0 + w_1 x)}} 

  Hierbei ist P(y=1|x) die Wahrscheinlichkeit, dass der Student besteht (y=1) basierend auf der Anzahl der Studienstunden (x). Die Gewichte w_0 und w_1 sind Parameter des Modells.
• Entscheidungsgrenze nutzen, um eine Klasse zu bestimmen: In der logistischen Regression wird eine Schwellenwert (Entscheidungsgrenze) genutzt, um vorherzusagen, ob ein Student bestehen wird oder nicht. Normalerweise wird diese Grenze auf 0.5 gesetzt. Das bedeutet: - Wenn P(y=1|x) >= 0.5, dann wird die Klasse y = 1 (Bestanden) vorhergesagt.- Wenn P(y=1|x) < 0.5, dann wird die Klasse y = 0 (Nicht bestanden) vorhergesagt.
• Wahrscheinlichkeit, dass ein Student mit 1 Stunde Studienzeit bestehen wird: Angenommen, die Gewichte des Modells sind w = [1, 2], dann ist die logistische Regressionsgleichung:

  P(y=1|x) = \frac{1}{1+e^{-(1 + 2\cdot x)}} 

  Für einen Studenten mit 1 Stunde Studienzeit setzen wir x = 1 ein:

  P(y=1|1) = \frac{1}{1+e^{-(1 + 2\cdot 1)}} = \frac{1}{1+e^{-(1 + 2)}} = \frac{1}{1+e^{-3}} = \frac{1}{1 + 0.0498} = \frac{1}{1.0498} ≈ 0.9526 

  Somit beträgt die Wahrscheinlichkeit, dass ein Student mit 1 Stunde Studienzeit bestehen wird, ungefähr 95.26%.

Aufgabe 4)

Du möchtest eine Clusteranalyse mit dem k-Means-Algorithmus durchführen. Du hast eine Datenmenge von 150 Kunden, die du in 3 Cluster (Gruppen) unterteilen möchtest, um ähnliche Verhaltensmuster zu identifizieren. Jeder Kunde hat Attribute wie Alter, jährliches Einkommen und Ausgaben. Da der k-Means-Algorithmus die Mittelwerte der Clusterzentren iterativ optimiert, musst du die zugehörigen Formeln und Distanzmaße kennen, um diesen Prozess zu verstehen und durchzuführen.

a)

Erkläre den k-Means-Algorithmus, indem du die Schritte des Algorithmus beschreibst. Gehe insbesondere darauf ein, wie die initialen Cluster-Zentralen gewählt werden und wie das Zuweisen der Datenpunkte zu den Clustern abläuft.

Lösung:

Beschreibung des k-Means-Algorithmus:

• Initialisierung: Zunächst wird die Anzahl der Cluster k festgelegt. In Deinem Fall sind dies 3 Cluster. Die initialen Cluster-Zentren (auch Centroids genannt) werden auf verschiedene Weise gewählt, zum Beispiel zufällig aus den vorhandenen Datenpunkten oder durch ausgeklügeltere Methoden wie k-Means++. Diese Zentren sind erst einmal nur Schätzungen.
• Zuweisung der Datenpunkte: Jeder Datenpunkt wird dem Cluster zugewiesen, dessen Zentrum ihm am nächsten liegt. Dies wird anhand eines Distanzmaßes wie der euklidischen Distanz berechnet. Die Formel für die euklidische Distanz zwischen einem Datenpunkt x und einem Clusterzentrum c ist:

d(x, c) = \sqrt{\sum_{i=1}^{n}(x_i - c_i)^2}

• Berechnung der neuen Zentren: Nachdem alle Datenpunkte zugewiesen wurden, werden die Clusterzentren aktualisiert. Dies geschieht, indem der Durchschnitt der Positionen aller Datenpunkte in einem Cluster berechnet wird. Wenn X die Menge der Datenpunkte im Cluster j ist, dann wird das neue Clusterzentrum c_j berechnet als:

c_j = \frac{1}{|X|} \sum_{x \in X}x

• Überprüfung der Konvergenz: Die Schritte 2 und 3 werden iterativ wiederholt, bis sich die Clusterzentren nicht mehr signifikant ändern oder eine maximale Anzahl von Iterationen erreicht ist.
• Ergebnis: Am Ende dieses Prozesses erhält man k Cluster, wobei jeder Datenpunkt dem Cluster zugewiesen ist, dessen Clusterzentrum ihm am nächsten liegt.

b)

Implementiere den k-Means-Algorithmus in einer Programmiersprache deiner Wahl (z. B. Python). Benutze dabei folgende Musterdaten für die 150 Kunden:

import numpy as npfrom sklearn.datasets import make_blobs# Erzeugung von 150 Kunden-Datenpunkten mit 3 ClusternX, y = make_blobs(n_samples=150, centers=3, n_features=3, random_state=42)# Deine Implementierung hier

Lösung:

Hier ist eine Implementierung des k-Means-Algorithmus in Python, wobei die Musterdaten für die 150 Kunden verwendet werden:

import numpy as npfrom sklearn.datasets import make_blobsimport matplotlib.pyplot as plt# Erzeugung von 150 Kunden-Datenpunkten mit 3 ClusternX, y = make_blobs(n_samples=150, centers=3, n_features=3, random_state=42)# Initialisierung der Cluster-Zentrendef initialize_centroids(X, k):    np.random.seed(42)    random_indices = np.random.permutation(X.shape[0])    centroids = X[random_indices[:k]]    return centroids# Zuweisung der Datenpunkte zu den nächsten Zentrendef assign_clusters(X, centroids):    distances = np.sqrt(((X - centroids[:, np.newaxis])**2).sum(axis=2))    return np.argmin(distances, axis=0)# Berechnung neuer Zentrendef update_centroids(X, labels, k):    centroids = np.array([X[labels == i].mean(axis=0) for i in range(k)])    return centroids# Hauptalgorithmusdef k_means(X, k, max_iters=100):    centroids = initialize_centroids(X, k)    for _ in range(max_iters):        labels = assign_clusters(X, centroids)        new_centroids = update_centroids(X, labels, k)        # Überprüfung der Konvergenz        if np.all(centroids == new_centroids):            break        centroids = new_centroids    return centroids, labels# Anzahl der Clusterk = 3centroids, labels = k_means(X, k)# Visualisierung der Ergebnissefig = plt.figure()ax = fig.add_subplot(111, projection='3d')colors = ['r', 'g', 'b']for i in range(k):    points = X[labels == i]    ax.scatter(points[:, 0], points[:, 1], points[:, 2], s=20, c=colors[i])ax.scatter(centroids[:, 0], centroids[:, 1], centroids[:, 2], s=300, c='yellow', marker='*', label='Centroids')plt.title('K-Means Clustering')plt.xlabel('Feature 1')plt.ylabel('Feature 2')ax.set_zlabel('Feature 3')plt.legend()plt.show()

Diese Implementierung des k-Means-Algorithmus in Python:

• Initialisiert Cluster-Zentren mit der initialize_centroids-Funktion.
• Weist die Datenpunkte den nächsten Zentren zu mit der assign_clusters-Funktion.
• Aktualisiert die Zentren basierend auf den neuen Zuweisungen mit der update_centroids-Funktion.
• Wiederholt die Schritte, bis Konvergenz erreicht ist oder die maximale Anzahl von Iterationen erreicht ist.

Die Ergebnisse werden abschließend in einem 3D-Plot visualisiert.

c)

Berechne die Summe der quadratischen Abstände für die unten stehenden Punkte manuell, wenn die Cluster-Zentralen wie folgt gewählt werden:

• Cluster 1: \(C_1 = (25, 30000, 1600)\)
• Cluster 2: \(C_2 = (45, 50000, 2500)\)
• Cluster 3: \(C_3 = (30, 70000, 3400)\)

Gegebene Datenpunkte: \(x_1 = (23, 32000, 1500) \, x_2 = (46, 48000, 2550) \, x_3 = (29, 71000, 3300)\)

Die Formel zur Berechnung der Summe der quadratischen Abstände lautet:

\[ \sum_{j=1}^k \sum_{x_i \in C_j} ||x_i - \mu_j||^2 \]

Lösung:

Um die Summe der quadratischen Abstände zu berechnen, müssen wir zunächst die euklidische Distanz zwischen jedem gegebenen Datenpunkt und den entsprechenden Cluster-Zentren berechnen. Anschließend quadrieren wir diese Werte und summieren sie.

Gegeben:

• Cluster 1 Zentrum: \(C_1 = (25, 30000, 1600)\)
• Cluster 2 Zentrum: \(C_2 = (45, 50000, 2500)\)
• Cluster 3 Zentrum: \(C_3 = (30, 70000, 3400)\)

Datenpunkte:

• \(x_1 = (23, 32000, 1500)\)
• \(x_2 = (46, 48000, 2550)\)
• \(x_3 = (29, 71000, 3300)\)

Wir gehen davon aus, dass jeder Datenpunkt seinem nächstgelegenen Cluster zugeordnet wird:

Berechnung der Distanzen für jeden Datenpunkt und das zugewiesene Cluster:

• Für \(x_1\) und \(C_1\):

\[ \text{Distanz } ||x_1 - C_1||^2 = (23-25)^2 + (32000-30000)^2 + (1500-1600)^2 \]\[ = (-2)^2 + (2000)^2 + (-100)^2 \]\[ = 4 + 4000000 + 10000 \]\[ = 4010004 \]

• Für \(x_2\) und \(C_2\):

\[ \text{Distanz } ||x_2 - C_2||^2 = (46-45)^2 + (48000-50000)^2 + (2550-2500)^2 \]\[ = (1)^2 + (-2000)^2 + (50)^2 \]\[ = 1 + 4000000 + 2500 \]\[ = 4002501 \]

• Für \(x_3\) und \(C_3\):

\[ \text{Distanz } ||x_3 - C_3||^2 = (29-30)^2 + (71000-70000)^2 + (3300-3400)^2 \]\[ = (-1)^2 + (1000)^2 + (-100)^2 \]\[ = 1 + 1000000 + 10000 \]\[ = 1010001 \]

Summe der quadratischen Abstände:

\[ \sum_{j=1}^k \sum_{x_i \in C_j} ||x_i - \mu_j||^2 = 4010004 + 4002501 + 1010001 = 9022506 \]

Die Summe der quadratischen Abstände für die gegebenen Punkte beträgt also \(9022506\).

d)

Diskutiere die Wahl der Parameter (wie die Anzahl der Cluster und das verwendete Distanzmaß) und deren Einfluss auf die Qualität der Clusteranalyse. Welche Herausforderungen können bei der Wahl der Parameter auftreten?

Lösung:

Diskussion der Wahl der Parameter und deren Einfluss auf die Qualität der Clusteranalyse:

• Anzahl der Cluster (k):Die Wahl der Anzahl der Cluster ist einer der wichtigsten Parameter im k-Means-Algorithmus. Eine falsche Wahl kann die Qualität der Clusteranalyse stark beeinträchtigen.Einige Methoden zur Bestimmung der optimalen Anzahl von Clustern sind:
• Elbow-Methode:Hierbei wird der Wert der Summe der quadratischen Abstände (Summe der Intracluster-Distanzen) in Abhängigkeit von der Anzahl der Cluster dargestellt. Der Punkt, an dem eine deutliche Reduktion aufhört (das „Ellbogen“-Punkt), wird als die optimale Anzahl der Cluster betrachtet.
• Silhouette-Koeffizient:Dieser Koeffizient misst, wie ähnlich ein Punkt zu den Punkten in seinem eigenen Cluster im Vergleich zu denen in anderen Clustern ist. Ein höherer Silhouette-Wert deutet auf besser definierte Cluster hin.
• Distanzmaß:Das gewählte Distanzmaß hat einen erheblichen Einfluss auf die Clustering-Ergebnisse. Das weitverbreitetste Distanzmaß ist die euklidische Distanz, die für viele datenpunkte im Raum geeignet ist. Andere mögliche Distanzmaße sind:
• Manhattan-Distanz:Sie eignet sich gut für städtische Planungsaufgaben, bei denen die Entfernung entlang einer Gitterstruktur erfolgt.
• Kosinus-Ähnlichkeit:Gut für Textdaten oder andere hochdimensionale Daten, da sie den Winkel zwischen den Punkten statt der absoluten Distanz misst.
• Herausforderungen bei der Parameterwahl:
• Über- und Untersegmentierung:Wählt man zu viele Cluster, kann es zu einer Übersegmentierung kommen, bei der viele Cluster entstehen, die sich kaum voneinander unterscheiden. Wählt man zu wenige Cluster, werden unterschiedliche Datenpunkte möglicherweise in einem Cluster gruppiert, obwohl sie unterschiedlichen Segmenten angehören sollten.
• Skalierung und Normalisierung:Wenn die Attribute der Daten unterschiedliche Skalen haben (z.B. Alter in Jahren und Einkommen in Euros), können große Werte die Distanzmaße dominieren. Eine Standardisierung oder Normalisierung der Daten ist daher oft notwendig.
• Sensitivität gegenüber Ausreißern:Der k-Means-Algorithmus ist empfindlich gegenüber Ausreißern, da diese die Berechnung der Clusterzentren stark beeinflussen können. Manchmal ist es notwendig, Ausreißer vorab zu entfernen oder robusteres Clustering-Verfahren zu verwenden.
• Anfangszentren:Die Wahl der initialen Cluster-Zentren kann den Konvergenzprozess und das endgültige Ergebnis beeinträchtigen. Verschiedene Initialisierungsmethoden wie k-Means++ können helfen, bessere Startpunkte zu finden.

Insgesamt ist es wichtig, die Parameterwahl basierend auf einer fundierten Analyse der Daten und Experimenten zu treffen, um qualitativ hochwertige Clustering-Ergebnisse zu erzielen.