Lineare Diskriminanzanalyse zur Klassifizierung

Einführung

In diesem Lab werden Sie die Lineare Diskriminanzanalyse (LDA) kennenlernen und erfahren, wie sie zur Klassifizierung eingesetzt werden kann. Wir werden die beliebte Python-Machine-Learning-Bibliothek scikit-learn verwenden, um die LDA umzusetzen. Wir werden auch untersuchen, wie die Kovarianz-Schätzer Ledoit-Wolf und Oracle Shrinkage Approximating (OAS) die Klassifizierung verbessern können.

Tipps für die VM

Nachdem die VM gestartet ist, klicken Sie in der oberen linken Ecke, um zur Registerkarte Notebook zu wechseln und Jupyter Notebook für die Übung zu öffnen.

Manchmal müssen Sie einige Sekunden warten, bis Jupyter Notebook vollständig geladen ist. Die Validierung von Vorgängen kann aufgrund der Einschränkungen von Jupyter Notebook nicht automatisiert werden.

Wenn Sie bei der Lernphase Probleme haben, können Sie Labby gerne fragen. Geben Sie nach der Sitzung Feedback, und wir werden das Problem für Sie prompt beheben.

Zufällige Daten generieren

Zunächst müssen wir zufällige Daten mit einem diskriminierenden Merkmal und rauschenden Merkmalen generieren. Wir werden die make_blobs-Funktion von scikit-learn verwenden, um zwei Cluster von Daten mit einem diskriminierenden Merkmal zu generieren. Anschließend werden wir zufälliges Rauschen zu den anderen Merkmalen hinzufügen.

import numpy as np
from sklearn.datasets import make_blobs

def generate_data(n_samples, n_features):
    """Generiert zufällige blob-ähnliche Daten mit rauschenden Merkmalen.

    Dies gibt ein Array mit den Eingabedaten der Form `(n_samples, n_features)`
    und ein Array mit `n_samples` Ziel-Labels zurück.

    Nur ein Merkmal enthält diskriminierende Informationen, die anderen Merkmale
    enthalten nur Rauschen.
    """
    X, y = make_blobs(n_samples=n_samples, n_features=1, centers=[[-2], [2]])

    ## füge nicht-diskriminierende Merkmale hinzu
    if n_features > 1:
        X = np.hstack([X, np.random.randn(n_samples, n_features - 1)])
    return X, y

LDA implementieren

Als nächstes werden wir die LDA mit der LinearDiscriminantAnalysis-Klasse von scikit-learn implementieren. Wir werden drei Klassifizierer erstellen:

• LDA ohne Shrinkage
• LDA mit Ledoit-Wolf-Shrinkage
• LDA mit OAS-Shrinkage

from sklearn.discriminant_analysis import LinearDiscriminantAnalysis
from sklearn.covariance import OAS

clf1 = LinearDiscriminantAnalysis(solver="lsqr", shrinkage=None)
clf2 = LinearDiscriminantAnalysis(solver="lsqr", shrinkage="auto")
oa = OAS(store_precision=False, assume_centered=False)
clf3 = LinearDiscriminantAnalysis(solver="lsqr", covariance_estimator=oa)

Klassifizierer trainieren und testen

Wir werden jeden Klassifizierer trainieren und testen, um zu sehen, wie sie auf den generierten Daten performen. Wir werden diesen Prozess mehrmals wiederholen, um einen durchschnittlichen Genauigkeitsscore zu erhalten.

n_train = 20  ## Stichproben für das Training
n_test = 200  ## Stichproben für das Testen
n_averages = 50  ## Wie oft die Klassifizierung wiederholt werden soll
n_features_max = 75  ## Maximale Anzahl von Merkmalen
step = 4  ## Schrittweite für die Berechnung

acc_clf1, acc_clf2, acc_clf3 = [], [], []
n_features_range = range(1, n_features_max + 1, step)

for n_features in n_features_range:
    score_clf1, score_clf2, score_clf3 = 0, 0, 0
    for _ in range(n_averages):
        X, y = generate_data(n_train, n_features)

        clf1.fit(X, y)
        clf2.fit(X, y)
        clf3.fit(X, y)

        X, y = generate_data(n_test, n_features)
        score_clf1 += clf1.score(X, y)
        score_clf2 += clf2.score(X, y)
        score_clf3 += clf3.score(X, y)

    acc_clf1.append(score_clf1 / n_averages)
    acc_clf2.append(score_clf2 / n_averages)
    acc_clf3.append(score_clf3 / n_averages)

Ergebnisse visualisieren

Schließlich werden wir die Klassifizierungsgenauigkeit für jeden Klassifizierer als Funktion der Anzahl der Merkmale darstellen. Wir werden matplotlib verwenden, um das Diagramm zu erstellen.

import matplotlib.pyplot as plt

features_samples_ratio = np.array(n_features_range) / n_train

plt.plot(
    features_samples_ratio,
    acc_clf1,
    linewidth=2,
    label="LDA",
    color="gold",
    linestyle="solid",
)
plt.plot(
    features_samples_ratio,
    acc_clf2,
    linewidth=2,
    label="LDA with Ledoit Wolf",
    color="navy",
    linestyle="dashed",
)
plt.plot(
    features_samples_ratio,
    acc_clf3,
    linewidth=2,
    label="LDA with OAS",
    color="red",
    linestyle="dotted",
)

plt.xlabel("n_features / n_samples")
plt.ylabel("Klassifizierungsgenauigkeit")

plt.legend(loc="lower left")
plt.ylim((0.65, 1.0))
plt.suptitle(
    "LDA (Lineare Diskriminanzanalyse) vs. "
    + "\n"
    + "LDA mit Ledoit Wolf vs. "
    + "\n"
    + "LDA mit OAS (1 diskriminierendes Merkmal)"
)
plt.show()

Zusammenfassung

In diesem Lab haben wir gelernt, wie man Lineare Diskriminanzanalyse (LDA) mit scikit-learn implementiert. Wir haben untersucht, wie die Ledoit-Wolf- und Oracle Shrinkage Approximating (OAS)-Schätzer der Kovarianz die Klassifizierungsgenauigkeit verbessern können. Wir haben auch zufällige Daten mit einem diskriminierenden Merkmal generiert und unsere Klassifizierer auf diesen Daten getestet. Schließlich haben wir die Klassifizierungsgenauigkeit als Funktion der Anzahl der Merkmale visualisiert.