Schritt-für-Schritt Logistische Regression

Einführung

In diesem Lab werden wir die Sparsität von Lösungen untersuchen, wenn L1-, L2- und Elastic-Net-Penalisierung für verschiedene Werte von C verwendet werden. Wir werden Logistische Regression verwenden, um 8x8-Bilder von Ziffern in zwei Klassen zu klassifizieren: 0-4 gegen 5-9. Wir werden die Koeffizienten der Modelle für verschiedene C-Werte visualisieren.

Tipps für die VM

Nachdem der VM-Start abgeschlossen 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 von Einschränkungen in 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.

Importieren der erforderlichen Bibliotheken

Der erste Schritt besteht darin, die erforderlichen Bibliotheken zu importieren. Wir werden numpy, matplotlib.pyplot, datasets, StandardScaler und LogisticRegression aus sklearn.linear_model benötigen.

import numpy as np
import matplotlib.pyplot as plt
from sklearn.linear_model import LogisticRegression
from sklearn import datasets
from sklearn.preprocessing import StandardScaler

Laden des Datensatzes

Wir werden den Digits-Datensatz mit datasets.load_digits(return_X_y=True) laden. Wir werden die Daten auch mithilfe von StandardScaler().fit_transform(X) standardisieren. Die Zielvariable wird binär sein, wobei 0-4 als 0 und 5-9 als 1 klassifiziert werden.

X, y = datasets.load_digits(return_X_y=True)
X = StandardScaler().fit_transform(X)
y = (y > 4).astype(int)

Definition des Regularisierungsparameters und des L1-Verhältnisses

Wir werden den Regularisierungsparameter C und das L1-Verhältnis l1_ratio für die Elastic-Net-Penalisierung definieren. Wir werden l1_ratio auf 0,5 setzen.

l1_ratio = 0.5

Erstellen von Subplots zur Visualisierung

Wir werden Subplots erstellen, um die Koeffizienten der Modelle für verschiedene C-Werte zu visualisieren. Wir werden 3 Zeilen und 3 Spalten von Subplots erstellen.

fig, axes = plt.subplots(3, 3)

Trainieren von logistischen Regressionsmodellen mit unterschiedlichen Strafen und Regularisierungsparametern

Wir werden logistische Regressionsmodelle mit L1-, L2- und Elastic-Net-Strafen und verschiedenen Werten von C trainieren. Wir werden die Toleranz für eine kurze Trainingszeit erhöhen.

for i, (C, axes_row) in enumerate(zip((1, 0.1, 0.01), axes)):
    clf_l1_LR = LogisticRegression(C=C, penalty="l1", tol=0.01, solver="saga")
    clf_l2_LR = LogisticRegression(C=C, penalty="l2", tol=0.01, solver="saga")
    clf_en_LR = LogisticRegression(C=C, penalty="elasticnet", solver="saga", l1_ratio=l1_ratio, tol=0.01)
    clf_l1_LR.fit(X, y)
    clf_l2_LR.fit(X, y)
    clf_en_LR.fit(X, y)

Berechnung der Sparsität und der Scores

Wir werden die Sparsität (Prozentsatz der Koeffizienten, die Null sind) und die Scores für jedes Modell berechnen.

    coef_l1_LR = clf_l1_LR.coef_.ravel()
    coef_l2_LR = clf_l2_LR.coef_.ravel()
    coef_en_LR = clf_en_LR.coef_.ravel()

    sparsity_l1_LR = np.mean(coef_l1_LR == 0) * 100
    sparsity_l2_LR = np.mean(coef_l2_LR == 0) * 100
    sparsity_en_LR = np.mean(coef_en_LR == 0) * 100

    score_l1_LR = clf_l1_LR.score(X, y)
    score_l2_LR = clf_l2_LR.score(X, y)
    score_en_LR = clf_en_LR.score(X, y)

Visualisierung der Koeffizienten

Wir werden die Koeffizienten der Modelle für jede Strafe und jeden C-Wert visualisieren.

    for ax, coefs in zip(axes_row, [coef_l1_LR, coef_en_LR, coef_l2_LR]):
        ax.imshow(np.abs(coefs.reshape(8, 8)), interpolation='nearest', cmap='binary', vmax=1, vmin=0)
        ax.set_xticks(())
        ax.set_yticks(())

Setzen von Titeln und Beschriftungen

Wir werden die Titel und Beschriftungen für die Subplots setzen.

    if i == 0:
        axes_row[0].set_title("L1 Strafe")
        axes_row[1].set_title("Elastic-Net\nl1_ratio = %s" % l1_ratio)
        axes_row[2].set_title("L2 Strafe")

    axes_row[0].set_ylabel("C = %s" % C)

Ergebnisse ausgeben

Wir werden die Sparsität und die Scores für jedes Modell ausgeben.

    print("C=%.2f" % C)
    print("{:<40} {:.2f}%".format("Sparsität mit L1-Strafe:", sparsity_l1_LR))
    print("{:<40} {:.2f}%".format("Sparsität mit Elastic-Net-Strafe:", sparsity_en_LR))
    print("{:<40} {:.2f}%".format("Sparsität mit L2-Strafe:", sparsity_l2_LR))
    print("{:<40} {:.2f}".format("Score mit L1-Strafe:", score_l1_LR))
    print("{:<40} {:.2f}".format("Score mit Elastic-Net-Strafe:", score_en_LR))
    print("{:<40} {:.2f}".format("Score mit L2-Strafe:", score_l2_LR))

Visualisierung anzeigen

Wir werden die Subplots anzeigen.

plt.show()

Zusammenfassung

In diesem Lab haben wir die Sparsität der Lösungen untersucht, wenn L1-, L2- und Elastic-Net-Strafen für verschiedene Werte von C verwendet werden. Wir haben die logistische Regression verwendet, um 8x8-Bilder von Ziffern in zwei Klassen zu klassifizieren: 0-4 gegen 5-9. Wir haben die Koeffizienten der Modelle für verschiedene C-Werte visualisiert. Wir haben auch die Sparsität und die Scores für jedes Modell berechnet und die Ergebnisse ausgegeben.