Multiclass Sparse Logistic Regression

Einführung

In diesem Lab werden wir untersuchen, wie man Multiclass Sparse Logistic Regression auf dem 20newsgroups-Dataset mit scikit-learn verwendet. Wir werden die Leistung von Multinomial Logistic Regression mit One-versus-rest L1 Logistic Regression vergleichen.

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 nutzen.

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.

Skills Graph

Bibliotheken importieren

Wir beginnen mit dem Import der erforderlichen Bibliotheken und Module, die wir in diesem Lab verwenden werden.

import timeit
import warnings

import matplotlib.pyplot as plt
import numpy as np

from sklearn.datasets import fetch_20newsgroups_vectorized
from sklearn.linear_model import LogisticRegression
from sklearn.model_selection import train_test_split
from sklearn.exceptions import ConvergenceWarning

warnings.filterwarnings("ignore", category=ConvergenceWarning, module="sklearn")

Daten laden und vorbereiten

Als nächstes laden wir das 20newsgroups-Dataset und bereiten die Daten für das Training und die Tests vor.

## Wir verwenden den SAGA-Löser
solver = "saga"

## Senken Sie diesen Wert, um die Laufzeit zu verringern
n_samples = 5000

X, y = fetch_20newsgroups_vectorized(subset="all", return_X_y=True)
X = X[:n_samples]
y = y[:n_samples]

X_train, X_test, y_train, y_test = train_test_split(
    X, y, random_state=42, stratify=y, test_size=0.1
)
train_samples, n_features = X_train.shape
n_classes = np.unique(y).shape[0]

print(
    "Dataset 20newsgroup, train_samples=%i, n_features=%i, n_classes=%i"
    % (train_samples, n_features, n_classes)
)

Modelle definieren und trainieren

Wir werden zwei Modelle definieren, Multinomial und One-vs-Rest L1 Logistic Regression, und sie mit unterschiedlicher Anzahl von Epochen trainieren.

models = {
    "ovr": {"name": "One versus Rest", "iters": [1, 2, 3]},
    "multinomial": {"name": "Multinomial", "iters": [1, 2, 5]},
}

for model in models:
    ## Fügen Sie initiale Chance-Level-Werte hinzu, um die Grafik zu erstellen
    accuracies = [1 / n_classes]
    times = [0]
    densities = [1]

    model_params = models[model]

    ## Kleine Anzahl von Epochen für schnelle Laufzeit
    for this_max_iter in model_params["iters"]:
        print(
            "[model=%s, solver=%s] Anzahl der Epochen: %s"
            % (model_params["name"], solver, this_max_iter)
        )
        lr = LogisticRegression(
            solver=solver,
            multi_class=model,
            penalty="l1",
            max_iter=this_max_iter,
            random_state=42,
        )
        t1 = timeit.default_timer()
        lr.fit(X_train, y_train)
        train_time = timeit.default_timer() - t1

        y_pred = lr.predict(X_test)
        accuracy = np.sum(y_pred == y_test) / y_test.shape[0]
        density = np.mean(lr.coef_!= 0, axis=1) * 100
        accuracies.append(accuracy)
        densities.append(density)
        times.append(train_time)
    models[model]["times"] = times
    models[model]["densities"] = densities
    models[model]["accuracies"] = accuracies
    print("Testgenauigkeit für Modell %s: %.4f" % (model, accuracies[-1]))
    print(
        "%% nicht-nulle Koeffizienten für Modell %s, pro Klasse:\n %s"
        % (model, densities[-1])
    )
    print(
        "Laufzeit (%i Epochen) für Modell %s:%.2f"
        % (model_params["iters"][-1], model, times[-1])
    )

Ergebnisse visualisieren

Schließlich werden wir die Ergebnisse der trainierten Modelle mithilfe eines Liniendiagramms visualisieren.

fig = plt.figure()
ax = fig.add_subplot(111)

for model in models:
    name = models[model]["name"]
    times = models[model]["times"]
    accuracies = models[model]["accuracies"]
    ax.plot(times, accuracies, marker="o", label="Model: %s" % name)
    ax.set_xlabel("Train time (s)")
    ax.set_ylabel("Test accuracy")
ax.legend()
fig.suptitle("Multinomial vs One-vs-Rest Logistic L1\nDataset %s" % "20newsgroups")
fig.tight_layout()
fig.subplots_adjust(top=0.85)
run_time = timeit.default_timer() - t0
print("Example run in %.3f s" % run_time)
plt.show()

Zusammenfassung

In diesem Lab haben wir scikit-learn verwendet, um Multiclass Sparse Logistic Regression auf dem 20newsgroups-Dataset durchzuführen. Wir haben die Leistung der Multinomial Logistic Regression mit der one-versus-rest L1 Logistic Regression verglichen und die Ergebnisse mithilfe eines Liniendiagramms visualisiert.