Vorlesungsaufzeichnung Hauptkomponentenanalyse (VL 18)
PCA¶
Die Principal Component Analysis (Hauptkomponentenanalyse) ist ein unsupervised Verfahren, bei dem eine Koordinatentransformation auf den Daten vorgenommen wird, sodass die neuen Koordinatenachsen geordnet sind danach, wo die Daten die höhere Varianz aufweisen. Eine sehr häufige Anwendung ist eine Projektion auf die ersten (wenigen) Koordinaten nach einer PCA, um die Anzahl der Dimensionen zu reduzieren ohne dabei zu viel Informationen aus den Daten wegzuwerfen.
Wenn jemand „wir machen eine PCA“ sagt, sind meist die Schritte 1–2 gemeint, oft auch 1–3:
fit — aus den Daten eine lineare, invertierbare Koordinatentransformation berechnen, genauer: eine Orthonormalbasis. Die neuen Koordinatenachsen heißen Hauptkomponenten oder Hauptachsen und sind danach geordnet, in welcher Richtung die Daten die höhere Varianz aufweisen.
transform — die Transformation auf Daten anwenden. Das dürfen auch andere Daten sein als die, aus denen sie berechnet wurde; genau deshalb sind es zwei Schritte.
Dimensionsreduktion — die transformierten Daten auf die ersten Hauptkomponenten projizieren, also auf einen niedrigdimensionalen linearen Unterraum.
In scikit-learn heißen die ersten beiden Schritte genau so (PCA().fit(x), pca.transform(x), und fit_transform für beides auf einmal), und Schritt 3 steckt im Parameter n_components: PCA(n_components=2) wirft beim Transformieren alle Hauptkomponenten außer den ersten beiden weg. Wer n_components weglässt, bekommt nur eine Drehung des Koordinatensystems und verliert nichts.
Die beiden Abbildungen zeigen genau diese zwei Fälle. Blau sind die Originaldaten im Raum, grau ihre Projektionen auf die Koordinatenebenen; eingeblendet ist die Differenz der Gesamtvarianz vor und nach der Projektion auf die -Ebene.

Figure 1:Fall (a): ist konstant 1. Die Projektion auf die -Ebene hat exakt dieselbe Gesamtvarianz wie die Originaldaten — die dritte Koordinate trägt keine Information.

Figure 2:Fall (b): . Jetzt geht bei der Projektion etwas verloren, aber nur von einer Gesamtvarianz von — weniger als ein halbes Prozent.
Fall (b) ist der realistische: Eine Koordinate ist nie exakt konstant, sie schwankt nur wenig. Die PCA macht daraus eine quantitative Aussage — sie sagt nicht nur, dass man projizieren darf, sondern auch, wie viel Varianz das kostet (in scikit-learn pca.explained_variance_ratio_).
Eine Koordinatentransformation ist nichts anderes als eine Matrixmultiplikation mit einer invertierbaren quadratischen Matrix. So eine Matrix kann in jede Richtung stauchen oder strecken und außerdem um jede Achse um einen Winkel drehen oder scheren. Das Ziel der PCA ist es, Koordinaten zu finden, sodass in der ersten Achse, der -Achse, die höchste Varianz vorliegt. Erinnerung: Bei einer Matrix, interpretiert als lineare Abbildung durch Matrixmultiplikation, sind die Bilder der Basisvektoren genau die Spalten der Matrix. Wenn wir einen Vektor bestimmen können, der die Richtung der größten Varianz angibt, können wir diesen in eine Matrix als erste Spalte schreiben und auf den Untervektorraum projizieren, der orthogonal zu diesem Vektor ist (d.h. wir betrachten alle Vektoren, die mit unserer ersten Matrixspalte einen rechten Winkel haben, da bleibt ein Vektorraum eine Dimension kleiner übrig). Induktiv können wir nun weitermachen um eine Matrix zu bestimmen. Die Umkehrabbildung ist dann eine Transformation, die die Richtung der größten Varianz auf den ersten Einheitsbasisvektor abbildet, also auf die -Achse.
Weil wir jede Hauptachse normieren und die nächste immer im Orthogonalkomplement der bisherigen suchen, sind die Spalten von normiert und stehen paarweise senkrecht aufeinander, sie bilden also eine Orthonormalbasis. Eine solche Matrix heißt orthogonal (auch: Orthonormalmatrix). Für sie gilt (Einheitsmatrix), also : Die Rücktransformation ist einfach die Transponierte, das Invertieren ist geschenkt. Warum die Hauptachsen von selbst senkrecht aufeinander stehen, sehen wir am Ende der Herleitung unten.
Leider haben wir bisher noch nicht festgestellt, wie man die Richtung der größten Varianz herausfindet.
Herleitung¶
Diese Beispiele bringen uns darauf, uns vorzustellen, welche Matrix die beobachteten Daten aus einer Standardnormalverteilung hervorgebracht haben könnte (zumindest, bei welcher das am plausibelsten wäre). Genau die Eigenvektoren zum größten Eigenwert von sind dabei die Richtungen der größten Varianz.
So eine Kovarianzmatrix kann man immer aufstellen. Wenn wir das mit unseren echten Daten machen, und dann daraus eine “Wurzel” ziehen könnten, dann hätten wir die Matrix bestimmt. Zum Glück haben Kovarianzmatrizen eine besondere Eigenschaft: sie sind positiv definit und symmetrisch. (Im Kapitel Multivariate Normalverteilung haben wir gesehen, dass die Kovarianzmatrix die Ellipsen der Dichte beschreibt; die Eigenvektoren, die wir jetzt berechnen, sind genau die Achsen dieser Ellipsen.)
Um diese Matrix zu bestimmen, gibt es eine sehr einfache Möglichkeit, wenn eine Diagonalmatrix mit lauter positiven Einträgen ist, denn dann ist eine Diagonalmatrix, deren Einträge die jeweiligen Wurzeln sind. Wenn aber keine Diagonalmatrix ist, dann gibt es Verfahren, die Koordinaten zu wechseln, um aus eine Diagonalmatrix zu machen. Das bedeutet mathematisch, dass man ersetzen kann durch eine Transformation rückwärts, dann eine Diagonalmatrix , dann die Transformation vorwärts. In Formeln: .
Angenommen, wir hätten eine derartige Zerlegung bestimmt (man sagt auch: eine Eigenraumzerlegung), dann können wir als Wurzel zu berechnen und erfüllt
Die gesuchte Matrix erfüllt , umgestellt also . Das bedeutet für jede Spalte von und dem -ten Diagonaleintrag von eine Gleichung , d.h. die Spalten von sind genau die Eigenvektoren von und die Diagonaleinträge von sind genau die Eigenwerte von zu diesen Eigenvektoren.
Dass Eigenvektoren zu verschiedenen Eigenwerten senkrecht aufeinander stehen, kann man in einer Zeile nachrechnen: Sind und mit , so ist wegen
also und damit . Normiert man die Eigenvektoren noch, so ist die Matrix aller Skalarprodukte , also die Einheitsmatrix. Das ist der Grund, warum die “Rotation” der PCA (die Matrix aus dem Abschnitt über Koordinatentransformationen oben) durch bloßes Transponieren invertiert wird, , was auch der Code unten ausnutzt.
Damit haben wir also alle Zutaten beisammen, wenn wir nur irgendwie die Eigenvektoren der Kovarianzmatrix bestimmen können!
Ein gutes Verfahren, um den Eigenvektor zum größten Eigenwert zu bestimmen: fange mit einem zufälligen Vektor an und wende die Matrix darauf an. Wenn es ein Eigenvektor ist - gut, merken wir. Wenn nicht, so wird der Vektor dadurch in eine Richtung abgebildet, die mit höherer Wahrscheinlichkeit etwas mehr in Richtung des Eigenvektors zum größten Eigenwert zeigt. Wenden wir die Matrix also wiederholt an, ist die Chance groß, immer näher an einen Eigenvektor zu kommen.
Ein weniger effizientes Verfahren ist das, was Sie in der linearen Algebra gelernt haben sollten: man bestimmt zunächst die Eigenwerte als Nullstellen des charakteristischen Polynoms und für jeden Eigenwert bestimmt man den Eigenraum mit dem Gaussverfahren, d.h. man löst die Gleichung .
Numpy und scikit-learn greifen auf LAPACK zurück, was in Fortran geschrieben ist und eine Singulärwertzerlegung (die Zerlegung ) in zwei Schritten durchführt. Wir wollen uns darüber nicht länger den Kopf zerbrechen, denn das gehört in eine Lineare Algebra- oder Numerik-Vorlesung. Wir wollen natürlich trotzdem den Rechner zur Hilfe nehmen:
import numpy as np
import scipy.stats as st
import matplotlib.pyplot as plt
from sklearn import datasetsC = np.array([[2.5, 0.5], [0.5, 1.75]]) # zum Beispiel!
# C ist symmetrisch, also nehmen wir eigh: reelle Eigenwerte, garantiert aufsteigend sortiert
# (np.linalg.eig garantiert keine Reihenfolge der Eigenwerte).
eigenvalues, eigenvectors = np.linalg.eigh(C)
eigenvalues, eigenvectors = eigenvalues[::-1], eigenvectors[:, ::-1] # absteigend, wie bei der SVD
print(eigenvalues)
print(eigenvectors)
T, s, vh = np.linalg.svd(C) # SVD = Singular Value Decomposition; Singulärwerte absteigend
assert np.allclose(s, eigenvalues)
print("die Transformation T ist in diesem Beispiel:")
print(T)
# Da C symmetrisch positiv definit ist, ist T orthogonal, also vh = T^{-1} = T^T
# (Eigenvektoren sind nur bis auf das Vorzeichen eindeutig, deshalb können sich
# eigenvectors und T in den Vorzeichen einzelner Spalten unterscheiden.)
assert np.allclose(vh, T.T)[2.75 1.5 ]
[[-0.89442719 0.4472136 ]
[-0.4472136 -0.89442719]]
die Transformation T ist in diesem Beispiel:
[[-0.89442719 -0.4472136 ]
[-0.4472136 0.89442719]]
Die Eigenwerte sind die Varianzen der Daten entlang der zugehörigen Eigenvektoren, der Hauptkomponenten. Ihr Anteil an der Gesamtvarianz , hier also und , heißt erklärte Varianz (explained variance) der jeweiligen Komponente. Mit dieser Größe entscheidet man später, wie viele Komponenten man behält.
Dimensionsreduktion in fünf Schritten¶
Aus einem Datensatz macht die PCA einen Datensatz in mit :
Zentrieren: Von jedem Merkmal seinen Mittelwert abziehen, sodass der Datensatz den Schwerpunkt 0 hat (meist auch skalieren, siehe unten).
Kovarianzmatrix der zentrierten Daten berechnen.
Eigenzerlegung: Eigenwerte und zugehörige normierte Eigenvektoren von bestimmen.
Auswählen: Die Eigenvektoren zu den größten Eigenwerten behalten — sie erklären den Anteil der Gesamtvarianz.
Projizieren: Jeden zentrierten Datenpunkt auf seine neuen Koordinaten abbilden.
C = np.array([[5.0, 3.0], [3.0, 5.0]])
werte, vektoren = np.linalg.eigh(C)
werte, vektoren = werte[::-1], vektoren[:, ::-1] # absteigend
print("Eigenwerte:", werte, " erklärte Varianz der 1. HK:", werte[0] / werte.sum())
x = np.array([2.0, 2.0])
neue_koordinaten = vektoren.T @ x # Schritt 5: Skalarprodukte mit v_1, v_2
print("neue Koordinaten:", neue_koordinaten)
assert np.isclose(abs(neue_koordinaten[0]), 2 * np.sqrt(2)) and np.isclose(neue_koordinaten[1], 0)
Eigenwerte: [8. 2.] erklärte Varianz der 1. HK: 0.8
neue Koordinaten: [2.82842712 0. ]
Jetzt betrachten wir anstelle der fiktiven Kovarianzmatrix ein echtes Sample , welches wir dann mit einer Koordinatentransformation verzerren und mit der eben besprochenen Methode die Koordinatentransformation ‘rückgängig’ machen:
fig, axs = plt.subplots(1, 3, figsize=(9, 3))
x = st.multivariate_normal(mean=[0,0], cov=np.eye(2)).rvs(100000)
C = np.cov(x, rowvar=False)
assert np.all(np.isclose(np.eye(2), C, atol=0.1))
axs[0].scatter(x[:,0], x[:,1], alpha=0.1)
axs[0].set_title("Standardnormalverteilung")
# eine willkürliche Transformation:
Q = np.array([[6.75, 0.25], [1.75, 1.75]])
new_x = np.matmul(Q, x.T).T
axs[1].scatter(new_x[:,0], new_x[:,1], alpha=0.1)
axs[1].set_title("Transformierte Stichprobe")
new_C = np.cov(new_x, rowvar=False)
print(new_C)
T, s, Tinv = np.linalg.svd(new_C)
newer_x = np.matmul(Tinv, new_x.T).T
axs[2].scatter(newer_x[:,0], newer_x[:,1], alpha=0.1)
axs[2].set_title("Rücktransformiert")
plt.show()[[45.88617049 12.27313705]
[12.27313705 6.13139888]]

Betrachten Sie die Plots ganz genau. Haben wir die Transformation vollständig rückgängig gemacht? Und wenn ja/nein, woran erkennen Sie das?
Berechnung¶
Ebenso können wir nun natürlich mit Daten verfahren, die wir gar nicht selbst transformiert haben, die möglicherweise auch gar nicht ursprünglich aus einer Standardnormalverteilung gesampelt wurden.
iris = datasets.load_iris()
x = iris.data
C = np.cov(x, rowvar=False)
print(C)
T, s, Tinv = np.linalg.svd(C)
pca_x = np.matmul(Tinv, x.T).T
fig, ax = plt.subplots()
ax.scatter(pca_x[:,0], pca_x[:,1], c=iris.target, alpha=0.6)
ax.set_title("Die ersten zwei Hauptkomponenten des Iris-Datensatzes")
plt.show()
fig = plt.figure(figsize=(7,7))
ax = plt.axes(projection='3d')
ax.view_init(15, 75)
ax.scatter3D(pca_x[:,0], pca_x[:,1], pca_x[:,2], c=iris.target)
ax.set_title("Die ersten drei Hauptkomponenten des Iris-Datensatzes")
plt.show()[[ 0.68569351 -0.042434 1.27431544 0.51627069]
[-0.042434 0.18997942 -0.32965638 -0.12163937]
[ 1.27431544 -0.32965638 3.11627785 1.2956094 ]
[ 0.51627069 -0.12163937 1.2956094 0.58100626]]


Berechnung mit scikit-learn¶
Wir müssen uns noch nicht einmal die Mühe machen, selbst die Singulärwertzerlegung oder die Eigenvektoren der Kovarianzmatrix auszurechnen - das kann scikit-learn auch für uns tun:
from sklearn.decomposition import PCA
pca_iris = PCA().fit_transform(iris.data)
fig = plt.figure(figsize=(7,7))
ax = plt.axes(projection='3d')
ax.view_init(15, 75)
ax.scatter3D(pca_iris[:,0], pca_iris[:,1], pca_iris[:,2], c=iris.target)
ax.set_title("Die ersten drei Hauptkomponenten des Iris-Datensatzes")
plt.show()
Ein ganz anderer Zugang zum Finden der Richtung maximaler Varianz ist es, die Summe der quadrierten Abstände der Punkte zu einer Geraden zu minimieren.
Die Summe der quadrierten Abstände ist, bis auf den Faktor , ein mittlerer quadratischer Fehler. Und zum kennen wir das beste konstante Modell schon: Es ist der Mittelwert (Kapitel Erwartungswert und Varianz, Abschnitt „Quadratische Abweichung“). In diesem Sinn ist die erste Hauptkomponente das beste lineare Modell — die Gerade durch den Mittelwert, die den mittleren quadratischen Abstand minimiert —, und die Animation zeigt, dass das genau die Richtung größter Varianz ist.
Ein Detail, das man leicht überliest und das die PCA von der linearen Regression unterscheidet: Hier wird der senkrechte Abstand zur Geraden minimiert, bei der Regression dagegen der vertikale Abstand in Richtung der Zielgröße. Die beiden Geraden sind deshalb im Allgemeinen verschieden.
Dieses Vorgehen ist hier bildlich dargestellt:

Figure 3:Die Gerade dreht sich, bis die Summe der quadrierten Abstände minimal wird — das ist dieselbe Richtung, die die größte Varianz hat.
Anwendungsbeispiel MNIST¶
Bisher haben wir die Dimension nur zum plotten reduziert - für viele Algorithmen ist es aber erforderlich, die Dimension wenigstens hinreichend klein zu halten, damit das Programm nicht wochenlang laufen muss. Ein Datensatz, der etwas mehr als nur 4 Variablen hat, ist der MNIST Datensatz von handschriftlichen Ziffern.
digits = datasets.load_digits()
fig, axs = plt.subplots(1,10, figsize=(10,1))
for i in range(10):
axs[i].axis("off")
axs[i].matshow(digits.images[i],
cmap='gray_r')
plt.show()
x = digits.data
pca_x = PCA().fit_transform(x)
from sklearn.cluster import KMeans
kmeans_result = KMeans(n_clusters=10, n_init=1).fit(x)
kmeans_after_pca = KMeans(n_clusters=10, n_init=1).fit(pca_x)
from sklearn import metrics
print(metrics.normalized_mutual_info_score(digits.target, kmeans_result.labels_))
print(metrics.normalized_mutual_info_score(digits.target, kmeans_after_pca.labels_))
print(metrics.normalized_mutual_info_score(kmeans_result.labels_, kmeans_after_pca.labels_))
0.7236776816130616
0.7165493927158051
0.9199617902288166
Wie viele Komponenten braucht man? Scikit-learn liefert die erklärte Varianz jeder Komponente direkt (explained_variance_ratio_, das sind die Eigenwerte der Kovarianzmatrix geteilt durch ihre Summe). Die kumulierte Kurve zeigt, wie viel Varianz die ersten Komponenten zusammen erklären:
pca = PCA().fit(x)
ratio = pca.explained_variance_ratio_
kumuliert = np.cumsum(ratio)
fig, ax = plt.subplots()
ax.plot(np.arange(1, len(ratio) + 1), kumuliert, marker=".")
ax.axhline(0.9, linestyle="--", color="gray")
ax.set_xlabel("Anzahl Komponenten")
ax.set_ylabel("erklärte Varianz (kumuliert)")
plt.show()
print("Komponenten für 90% der Varianz:", np.searchsorted(kumuliert, 0.9) + 1, "von", len(ratio))
Komponenten für 90% der Varianz: 21 von 64
# Jetzt schmeissen wir Dimensionen weg,
# und analysieren wie dadurch die Klassifikation leidet:
scores = np.full(33, 0.0)
pca_x = PCA().fit_transform(x)
def update_scores(scores, pca_x, maxn, minn):
for n in range(maxn, minn-1, -1):
pca_x = pca_x[:,:n]
kmeans_after_pca = KMeans(n_clusters=10, n_init=1).fit(pca_x)
scores[n] = metrics.normalized_mutual_info_score(digits.target, kmeans_after_pca.labels_)
return scores, pca_x# Work in batches to avoid Jupyter cell timeout after 30 seconds:
scores, pca_x = update_scores(scores, pca_x, 32, 17)scores, pca_x = update_scores(scores, pca_x, 16, 1)fig, ax = plt.subplots()
ax.plot(np.arange(0, 33), scores)
ax.invert_xaxis()
plt.show()
Wie man im Graph erkennen kann, leidet die 10-Means-Performance als Klassifikator erst, wenn man von den ursprünglich 64 Dimensionen nur noch 10 übrig lässt, und dann weiter reduziert.
Wir haben in den Iris-Daten bereits gesehen, dass die Kovarianzmatrizen innerhalb der Gruppen leicht unterschiedlich ausfallen. Genau genommen wollen wir für eine optimale Unterscheidung der Gruppen auch gar nicht die Richtungen der größten Varianz bevorzugt betrachten, sondern noch viel lieber die Richtung, die die beste Unterscheidung erlaubt. Um das zu betrachten, muss man die Klassen aber bereits kennen - also supervised learning. Ein solches Verfahren ist Linear Discriminant Analysis (LDA).
Skalenunterschiede¶
Problematisch wird es, wenn die Daten nicht, wie in den Beispielen zuvor, auf gleichen Skalen liegen (einmal Meter, einmal Zentimeter) oder sogar die Skalen unbekannt oder inkompatibel (Sekunden, Meter) sind.
Dann dominieren die Variablen mit großen Zahlen, was eine Verzerrung der eigentlich angestrebten Koordinatentransformation ist. Um das zu vermeiden, reskaliert man jede Variable mit der Standardabweichung. Ebenso verschiebt man jede Variable, sodass der Mittelwert 0 wird. Das nennt sich ‘Standardisierung’. Es ist dann besonders sinnvoll, wenn die Variable annähernd normalverteilt ist.
Eine ‘Normalisierung’ ist eine Reskalierung auf das Intervall . Sie ist dann besonders sinnvoll, wenn die Variable nicht normalverteilt ist.
Jede solche Umskalierung nennt sich ‘Feature Scaling’.
In Python kann man das mit scikit-learn machen, indem man ein Scaler-Objekt verwendet:
import numpy as np
import matplotlib.pyplot as plt
from sklearn.preprocessing import StandardScaler
np.random.seed(1234)
# craft some dummy data:
dummycenters = [[10, 0.04, 3],
[20, 0.03, 2],
[30, 0.02, 1],
[40, 0.01, 4]]
# make a random symmetric matrix with A@A.T for a random matrix A,
# make it positive definite by adding an identity matrix
dummycovs = (4*(A@A.T + np.eye(3))
for A in (np.random.rand(3,3)
for _ in range(4)))
dummydata = np.concatenate([np.random.multivariate_normal(center,
cov,
size=200)
for center, cov in zip(dummycenters, dummycovs)])
dummymu = np.mean(dummydata, axis=0)# scale it:
scaler = StandardScaler()
scaled = scaler.fit_transform(dummydata)
scaledmu = np.mean(scaled, axis=0)
# let's take a look:
fig, axs = plt.subplots(2, 1, figsize=(8,8))
axs[0].scatter(dummydata[:,0], dummydata[:,1])
axs[0].plot(dummymu[0], dummymu[1], "+",
label="Mittelwert")
axs[1].scatter(scaled[:,0], scaled[:,1])
axs[1].plot(scaledmu[0], scaledmu[1], "+")
axs[1].set_title("Unten: Standardskaliert")
fig.legend()
fig.suptitle("Oben: Ausgangsdaten")
plt.show()
Wir betrachten jetzt den Einfluss der Skalierung auf die PCA und anschließendes Clustering mit k-Means, denn anstatt einfach immer alles durch den StandardScaler zu jagen, sollte man stets betrachten, welchen Unterschied es macht:
from sklearn.decomposition import PCA
from sklearn.cluster import KMeans
dummy_pca = PCA().fit_transform(dummydata)
scaled_pca = PCA().fit_transform(scaled)
dummy_kmeans = KMeans(4, n_init=1).fit(dummy_pca)
scaled_kmeans = KMeans(4, n_init=1).fit(scaled_pca)
# to compare:
original_labels = np.concatenate([np.full(200, k) for k in range(4)])# let's take a look:
fig, axs = plt.subplots(2, 2, figsize=(10,10))
axs[0][0].scatter(dummy_pca[:,0], dummy_pca[:,1],
c=dummy_kmeans.labels_)
axs[1][0].scatter(scaled_pca[:,0], scaled_pca[:,1],
c=scaled_kmeans.labels_)
axs[0][1].scatter(dummy_pca[:,0], dummy_pca[:,1],
c=original_labels)
axs[1][1].scatter(scaled_pca[:,0], scaled_pca[:,1],
c=original_labels)
axs[1][0].set_title("Links: Labels von k-Means")
axs[1][1].set_title("Rechts: ursprüngliche Klassen")
fig.suptitle("Oben: Unskaliert PCA,\n Unten: Standardskaliert PCA")
plt.show()
Man kann in der oberen Zeile deutlich erkennen, dass k-Means auf den unskalierten Daten gut funktioniert. An der unteren Zeile sehen wir, dass bei Standardskalierung die Hauptkomponenten anders liegen (daher sieht das Bild gedreht aus), aber auch, dass k-Means die Cluster nicht gut eingeteilt hat.
Das ist letztlich eine Inkarnation von Simpson’s Paradox, denn die “richtige” Art, die Daten zu skalieren, wäre hier so, dass die Cluster möglichst standardnormalverteilt werden. Um das zu erreichen müsste man aber erst Clustern, dann die Standardskalierung der Cluster berechnen, mit einem geeigneten Mittelwert davon dann die ganzen Daten gemeinsam skalieren. Danach ergibt sich beim Clustern wiederum ein anderes Bild - und man kann das Verfahren iterieren. In diesem Setting ist es vorteilhaft, nicht k-Means zu verwenden, sondern gleich ein Verfahren, welches keine standardnormalverteilten Cluster annimmt (z.B. gemischte Gausssche Modelle).
Anwendungsbeispiel Wine¶
Zuletzt betrachten wir noch ein ‘Erfolgsbeispiel’ des Standardskalierens:
import pandas as pd
from sklearn.datasets import load_wine
df, target = load_wine(return_X_y=True, as_frame=True)
assert type(df) == pd.DataFrame
assert type(target) == pd.Seriesunscaled_pca = PCA(n_components=2).fit_transform(df)
unscaled_kmeans = KMeans(3, n_init=1).fit(unscaled_pca)
scaled = StandardScaler().fit_transform(df)
scaled_pca = PCA(n_components=2).fit_transform(scaled)
scaled_kmeans = KMeans(3, n_init=1).fit(scaled_pca)
fig, axs = plt.subplots(2, 2, figsize=(10,10))
axs[0][0].scatter(unscaled_pca[:,0], unscaled_pca[:,1], c=unscaled_kmeans.labels_)
axs[1][0].scatter(scaled_pca[:,0], scaled_pca[:,1], c=scaled_kmeans.labels_)
axs[0][1].scatter(unscaled_pca[:,0], unscaled_pca[:,1], c=target)
axs[1][1].scatter(scaled_pca[:,0], scaled_pca[:,1], c=target)
axs[1][0].set_title("Links: Labels von k-Means")
axs[1][1].set_title("Rechts: ursprüngliche Klassen")
fig.suptitle("Oben: Unskaliert PCA,\n Unten: Standardskaliert PCA")
plt.show()
Statt hier nur auf das Bild zu achten, ist es besser, auch eine Kennzahl auszurechnen. Wie zuvor verwenden wir dazu ein Entropie-basiertes Maß, die gemeinsame Information der beiden Klassenvariablen (Kapitel Relative Entropie), normiert auf den Mittelwert ihrer beiden Entropien:
from sklearn.metrics import normalized_mutual_info_score
scaled_score = normalized_mutual_info_score(scaled_kmeans.labels_, target)
unscaled_score = normalized_mutual_info_score(unscaled_kmeans.labels_, target)
print("Die skalierte Variante ist mit %f Ähnlichkeit zur 'echten' Klasse besser als die unskalierte Variante mit nur %f Ähnlichkeit" % (scaled_score, unscaled_score))Die skalierte Variante ist mit 0.865642 Ähnlichkeit zur 'echten' Klasse besser als die unskalierte Variante mit nur 0.423309 Ähnlichkeit