Skaliert den Regularisierungsparameter für SVMs

Einführung

In diesem Lab wird der Effekt der Skalierung des Regularisierungsparameters bei der Verwendung von Support Vector Machines (SVMs) zur Klassifizierung demonstriert. Bei der SVM-Klassifizierung interessieren wir uns für die Minimierung des Risikos für die Gleichung:

C \sum_{i=1, n} \mathcal{L} (f(x_i), y_i) + \Omega (w)

wobei:

• C wird verwendet, um die Höhe der Regularisierung festzulegen
• L ist eine Verlustfunktion unserer Proben und unserer Modellparameter.
• Ω ist eine Strafmaßfunktion unserer Modellparameter

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 der 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 und synthetisches Dataset generieren

Wir beginnen, indem wir die erforderlichen Bibliotheken importieren und ein synthetisches Dataset generieren, das für die L1- und L2-Regularisierung geeignet ist.

import numpy as np
import pandas as pd
import matplotlib.pyplot as plt
from sklearn.datasets import make_classification
from sklearn.svm import LinearSVC
from sklearn.model_selection import validation_curve, ShuffleSplit

n_samples, n_features = 100, 300
X, y = make_classification(n_samples=n_samples, n_features=n_features, n_informative=5, random_state=1)

rng = np.random.RandomState(1)
y = np.sign(0.5 - rng.rand(n_samples))
X = rng.randn(n_samples, n_features // 5) + y[:, np.newaxis]
X += 5 * rng.randn(n_samples, n_features // 5)

Fall mit L1-Strafe

Im Falle der L1-Strafe besagt die Theorie, dass die Modellkonsistenz, was das Finden der richtigen Menge an nicht-null Parametern sowie ihrer Vorzeichen betrifft, durch die Skalierung von C erreicht werden kann. Wir demonstrieren diesen Effekt, indem wir ein synthetisches Dataset verwenden, das spars ist, was bedeutet, dass nur wenige Merkmale für das Modell informativ und nützlich sein werden.

model_l1 = LinearSVC(penalty="l1", loss="squared_hinge", dual=False, tol=1e-3)

Cs = np.logspace(-2.3, -1.3, 10)
train_sizes = np.linspace(0.3, 0.7, 3)
labels = [f"Anteil: {train_size}" for train_size in train_sizes]

results = {"C": Cs}
for label, train_size in zip(labels, train_sizes):
    cv = ShuffleSplit(train_size=train_size, test_size=0.3, n_splits=50, random_state=1)
    train_scores, test_scores = validation_curve(
        model_l1, X, y, param_name="C", param_range=Cs, cv=cv
    )
    results[label] = test_scores.mean(axis=1)
results = pd.DataFrame(results)

fig, axes = plt.subplots(nrows=1, ncols=2, sharey=True, figsize=(12, 6))

## Ergebnisse ohne Skalierung von C plotten
results.plot(x="C", ax=axes[0], logx=True)
axes[0].set_ylabel("CV-Score")
axes[0].set_title("Keine Skalierung")

## Ergebnisse durch Skalierung von C plotten
for train_size_idx, label in enumerate(labels):
    results_scaled = results[[label]].assign(
        C_scaled=Cs * float(n_samples * train_sizes[train_size_idx])
    )
    results_scaled.plot(x="C_scaled", ax=axes[1], logx=True, label=label)
axes[1].set_title("Skaliere C mit 1 / n_samples")

_ = fig.suptitle("Effekt der Skalierung von C mit L1-Strafe")

Fall mit L2-Strafe

Wir können ein ähnliches Experiment mit der l2-Strafe wiederholen. In diesem Fall besagt die Theorie, dass um die Vorhersagekonsistenz zu erreichen, der Strafparameter konstant gehalten werden sollte, wenn die Anzahl der Proben zunimmt.

model_l2 = LinearSVC(penalty="l2", loss="squared_hinge", dual=True)
Cs = np.logspace(-4.5, -2, 10)

labels = [f"Anteil: {train_size}" for train_size in train_sizes]
results = {"C": Cs}
for label, train_size in zip(labels, train_sizes):
    cv = ShuffleSplit(train_size=train_size, test_size=0.3, n_splits=50, random_state=1)
    train_scores, test_scores = validation_curve(
        model_l2, X, y, param_name="C", param_range=Cs, cv=cv
    )
    results[label] = test_scores.mean(axis=1)
results = pd.DataFrame(results)

fig, axes = plt.subplots(nrows=1, ncols=2, sharey=True, figsize=(12, 6))

## Ergebnisse ohne Skalierung von C plotten
results.plot(x="C", ax=axes[0], logx=True)
axes[0].set_ylabel("CV-Score")
axes[0].set_title("Keine Skalierung")

## Ergebnisse durch Skalierung von C plotten
for train_size_idx, label in enumerate(labels):
    results_scaled = results[[label]].assign(
        C_scaled=Cs * float(n_samples * train_sizes[train_size_idx])
    )
    results_scaled.plot(x="C_scaled", ax=axes[1], logx=True, label=label)
axes[1].set_title("Skaliere C mit 1 / n_samples")

_ = fig.suptitle("Effekt der Skalierung von C mit L2-Strafe")

Zusammenfassung

In diesem Lab wurde der Effekt der Skalierung des Regularisierungsparameters in SVMs für sowohl die L1- als auch die L2-Strafe demonstriert. Für die L1-Strafe haben wir beobachtet, dass der Kreuzvalidierungsfehler am besten mit dem Testfehler korreliert, wenn man C mit der Anzahl der Proben skaliert. Für die L2-Strafe ergibt sich das beste Ergebnis aus dem Fall, in dem C nicht skaliert wird.