Feature-Diskretisierung für die Klassifikation

Einführung

Beim maschinellen Lernen ist die Feature-Diskretisierung ein Verfahren, um die Anzahl von kontinuierlichen Variablen in einem Datensatz zu reduzieren, indem Bins oder Intervalle erstellt werden, um sie darzustellen. Dieses Verfahren kann nützlich sein, wenn die Anzahl der kontinuierlichen Variablen groß ist und der Algorithmus vereinfacht werden muss, um eine einfachere Analyse zu ermöglichen. In diesem Lab werden wir die Feature-Diskretisierung auf synthetischen Klassifikationsdatensätzen demonstrieren.

VM-Tipps

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 von Jupyter Notebook nicht automatisiert werden.

Wenn Sie während des Lernens Probleme haben, können Sie Labby gerne fragen. Geben Sie nach der Sitzung Feedback, und wir werden das Problem für Sie prompt beheben.

Bibliotheken importieren

In diesem Schritt werden wir die erforderlichen Bibliotheken für das Lab importieren. Wir werden die scikit-learn-Bibliothek für maschinelles Lernen verwenden, numpy für mathematische Operationen und matplotlib für die Datenvisualisierung.

import numpy as np
import matplotlib.pyplot as plt
from matplotlib.colors import ListedColormap
from sklearn.model_selection import train_test_split
from sklearn.preprocessing import StandardScaler
from sklearn.datasets import make_moons, make_circles, make_classification
from sklearn.linear_model import LogisticRegression
from sklearn.model_selection import GridSearchCV
from sklearn.pipeline import make_pipeline
from sklearn.preprocessing import KBinsDiscretizer
from sklearn.svm import SVC, LinearSVC
from sklearn.ensemble import GradientBoostingClassifier
from sklearn.utils._testing import ignore_warnings
from sklearn.exceptions import ConvergenceWarning

Daten vorbereiten

In diesem Schritt werden wir die synthetischen Klassifikationsdatensätze für die Feature-Diskretisierung vorbereiten. Wir werden die scikit-learn-Bibliothek verwenden, um drei verschiedene Datensätze zu generieren: Monde, konzentrische Kreise und linear trennbare Daten.

h = 0.02  ## Schrittweite im Gitter

n_samples = 100
datasets = [
    make_moons(n_samples=n_samples, noise=0.2, random_state=0),
    make_circles(n_samples=n_samples, noise=0.2, factor=0.5, random_state=1),
    make_classification(
        n_samples=n_samples,
        n_features=2,
        n_redundant=0,
        n_informative=2,
        random_state=2,
        n_clusters_per_class=1,
    ),
]

Klassifizierer und Parameter definieren

In diesem Schritt werden wir die Klassifizierer und die Parameter definieren, die im Feature-Diskretisierungsprozess verwendet werden sollen. Wir werden eine Liste von Klassifizierern erstellen, die Logistische Regression, linearen Support-Vektor-Maschine (SVM), Gradienten-Boosting-Klassifizierer und SVM mit einem radialbasisfunktionellen Kern umfasst. Wir werden auch einen Satz von Parametern für jeden Klassifizierer definieren, die im GridSearchCV-Algorithmus verwendet werden sollen.

## Liste von (Schätzer, param_grid), wobei param_grid im GridSearchCV verwendet wird
## Die Parameterspaces in diesem Beispiel sind auf einen schmalen Bereich begrenzt, um die Laufzeit zu reduzieren.
## In einem realen Anwendungsfall sollte ein breiterer Suchraum für die Algorithmen verwendet werden.
classifiers = [
    (
        make_pipeline(StandardScaler(), LogisticRegression(random_state=0)),
        {"logisticregression__C": np.logspace(-1, 1, 3)},
    ),
    (
        make_pipeline(StandardScaler(), LinearSVC(random_state=0, dual="auto")),
        {"linearsvc__C": np.logspace(-1, 1, 3)},
    ),
    (
        make_pipeline(
            StandardScaler(),
            KBinsDiscretizer(encode="onehot"),
            LogisticRegression(random_state=0),
        ),
        {
            "kbinsdiscretizer__n_bins": np.arange(5, 8),
            "logisticregression__C": np.logspace(-1, 1, 3),
        },
    ),
    (
        make_pipeline(
            StandardScaler(),
            KBinsDiscretizer(encode="onehot"),
            LinearSVC(random_state=0, dual="auto"),
        ),
        {
            "kbinsdiscretizer__n_bins": np.arange(5, 8),
            "linearsvc__C": np.logspace(-1, 1, 3),
        },
    ),
    (
        make_pipeline(
            StandardScaler(), GradientBoostingClassifier(n_estimators=5, random_state=0)
        ),
        {"gradientboostingclassifier__learning_rate": np.logspace(-2, 0, 5)},
    ),
    (
        make_pipeline(StandardScaler(), SVC(random_state=0)),
        {"svc__C": np.logspace(-1, 1, 3)},
    ),
]

names = [get_name(e).replace("StandardScaler + ", "") for e, _ in classifiers]

Daten visualisieren

In diesem Schritt werden wir die synthetischen Klassifikationsdatensätze vor der Feature-Diskretisierung visualisieren. Wir werden die Trainings- und Testpunkte für jeden Datensatz plotten.

fig, axes = plt.subplots(
    nrows=len(datasets), ncols=len(classifiers) + 1, figsize=(21, 9)
)

cm_piyg = plt.cm.PiYG
cm_bright = ListedColormap(["#b30065", "#178000"])

## iterieren über die Datensätze
for ds_cnt, (X, y) in enumerate(datasets):
    print(f"\ndataset {ds_cnt}\n---------")

    ## in Trainings- und Testteil aufteilen
    X_train, X_test, y_train, y_test = train_test_split(
        X, y, test_size=0.5, random_state=42
    )

    ## das Gitter für die Hintergrundfarben erstellen
    x_min, x_max = X[:, 0].min() - 0.5, X[:, 0].max() + 0.5
    y_min, y_max = X[:, 1].min() - 0.5, X[:, 1].max() + 0.5
    xx, yy = np.meshgrid(np.arange(x_min, x_max, h), np.arange(y_min, y_max, h))

    ## plotten Sie zunächst den Datensatz
    ax = axes[ds_cnt, 0]
    wenn ds_cnt == 0:
        ax.set_title("Eingabedaten")
    ## plotten Sie die Trainingspunkte
    ax.scatter(X_train[:, 0], X_train[:, 1], c=y_train, cmap=cm_bright, edgecolors="k")
    ## und Testpunkte
    ax.scatter(
        X_test[:, 0], X_test[:, 1], c=y_test, cmap=cm_bright, alpha=0.6, edgecolors="k"
    )
    ax.set_xlim(xx.min(), xx.max())
    ax.set_ylim(yy.min(), yy.max())
    ax.set_xticks(())
    ax.set_yticks(())

Feature-Diskretisierung implementieren

In diesem Schritt werden wir die Feature-Diskretisierung auf den Datensätzen mit der KBinsDiscretizer-Klasse aus scikit-learn implementieren. Dies wird die Features diskretisieren, indem ein Satz von Bins erstellt und dann die diskreten Werte mit One-Hot-Codierung codiert werden. Anschließend werden die Daten an einen linearen Klassifizierer angepasst und die Leistung ausgewertet.

## iterieren über die Klassifizierer
for est_idx, (name, (estimator, param_grid)) in enumerate(zip(names, classifiers)):
    ax = axes[ds_cnt, est_idx + 1]

    clf = GridSearchCV(estimator=estimator, param_grid=param_grid)
    mit ignore_warnings(category=ConvergenceWarning):
        clf.fit(X_train, y_train)
    score = clf.score(X_test, y_test)
    print(f"{name}: {score:.2f}")

    ## plotten Sie die Entscheidungsgrenze. Dazu werden wir jeder
    ## Punkt im Gitter [x_min, x_max]*[y_min, y_max] eine Farbe zuweisen.
    wenn hasattr(clf, "decision_function"):
        Z = clf.decision_function(np.column_stack([xx.ravel(), yy.ravel()]))
    sonst:
        Z = clf.predict_proba(np.column_stack([xx.ravel(), yy.ravel()]))[:, 1]

    ## bringen Sie das Ergebnis in einen Farbplot
    Z = Z.reshape(xx.shape)
    ax.contourf(xx, yy, Z, cmap=cm_piyg, alpha=0.8)

    ## plotten Sie die Trainingspunkte
    ax.scatter(
        X_train[:, 0], X_train[:, 1], c=y_train, cmap=cm_bright, edgecolors="k"
    )
    ## und Testpunkte
    ax.scatter(
        X_test[:, 0],
        X_test[:, 1],
        c=y_test,
        cmap=cm_bright,
        edgecolors="k",
        alpha=0.6,
    )
    ax.set_xlim(xx.min(), xx.max())
    ax.set_ylim(yy.min(), yy.max())
    ax.set_xticks(())
    ax.set_yticks(())

    wenn ds_cnt == 0:
        ax.set_title(name.replace(" + ", "\n"))
    ax.text(
        0.95,
        0.06,
        (f"{score:.2f}").lstrip("0"),
        size=15,
        bbox=dict(boxstyle="round", alpha=0.8, facecolor="white"),
        transform=ax.transAxes,
        horizontalalignment="right",
    )

Ergebnisse visualisieren

In diesem Schritt werden wir die Ergebnisse des Feature-Diskretisierungsprozesses visualisieren. Wir werden die Klassifikationsgenauigkeit auf dem Testset für jeden Klassifizierer und Datensatz plotten.

plt.tight_layout()

## Fügen Sie Überschriften über der Abbildung hinzu
plt.subplots_adjust(top=0.90)
Überschriften = [
    "Lineare Klassifizierer",
    "Feature-Diskretisierung und lineare Klassifizierer",
    "Nicht-lineare Klassifizierer",
]
für i, Überschrift in zip([1, 3, 5], Überschriften):
    ax = axes[0, i]
    ax.text(
        1.05,
        1.25,
        Überschrift,
        transform=ax.transAxes,
        horizontalalignment="center",
        size="x-large",
    )
plt.show()

Zusammenfassung

In diesem Lab haben wir die Feature-Diskretisierung auf synthetischen Klassifikationsdatensätzen mit scikit-learn demonstriert. Wir haben die Daten vorbereitet, Klassifizierer und Parameter definiert, die Feature-Diskretisierung implementiert und die Ergebnisse visualisiert. Diese Vorverarbeitungstechnik kann hilfreich sein, um die Komplexität eines Datensatzes zu reduzieren und die Leistung linearer Klassifizierer zu verbessern. Es sollte jedoch mit Vorsicht verwendet werden und in Verbindung mit anderen Techniken, um Überanpassung zu vermeiden.