Demonstration von KBinsDiscretizer-Strategien

Einführung

In diesem Lab werden wir die verschiedenen Strategien untersuchen, die in der Klasse KBinsDiscretizer der Python-Bibliothek scikit-learn zur Verfügung stehen. KBinsDiscretizer ist eine Klasse zum Diskretisieren von kontinuierlichen Merkmalen in kategorische Merkmale, indem die kontinuierlichen Daten in Intervalle eingeteilt werden. Wir werden die verschiedenen Strategien visualisieren, indem wir sie auf verschiedene Datensätze anwenden.

Tipps für die VM

Nachdem der Start der VM abgeschlossen ist, klicken Sie in der linken oberen 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 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.

Skills Graph

Bibliotheken importieren

Wir beginnen mit dem Import der erforderlichen Bibliotheken. Wir werden numpy, matplotlib.pyplot, make_blobs und KBinsDiscretizer aus dem Modul sklearn.preprocessing verwenden.

import numpy as np
import matplotlib.pyplot as plt
from sklearn.preprocessing import KBinsDiscretizer
from sklearn.datasets import make_blobs

Datensätze erstellen

Wir werden drei Datensätze für die Visualisierung erstellen. Der erste Datensatz wird eine Zufallsmenge von 200 Proben aus einer gleichmäßigen Verteilung zwischen -3 und 3 in beiden Dimensionen sein. Der zweite Datensatz wird eine Menge von 200 Proben sein, die mit der Funktion make_blobs aus sklearn.datasets generiert werden. Der dritte Datensatz wird ebenfalls mit der Funktion make_blobs generiert werden.

n_samples = 200
centers_0 = np.array([[0, 0], [0, 5], [2, 4], [8, 8]])
centers_1 = np.array([[0, 0], [3, 1]])

X_list = [
    np.random.RandomState(42).uniform(-3, 3, size=(n_samples, 2)),
    make_blobs(
        n_samples=[n_samples // 10, n_samples * 4 // 10, n_samples // 10, n_samples * 4 // 10],
        cluster_std=0.5,
        centers=centers_0,
        random_state=42,
    )[0],
    make_blobs(
        n_samples=[n_samples // 5, n_samples * 4 // 5],
        cluster_std=0.5,
        centers=centers_1,
        random_state=42,
    )[0],
]

Verschiedene Strategien anwenden

Wir werden nun die drei verschiedenen Strategien, die in KBinsDiscretizer zur Verfügung stehen, auf jeden der Datensätze anwenden. Die Strategien sind:

• 'uniform': Die Diskretisierung ist in jedem Merkmal gleichmäßig, was bedeutet, dass die Bin-Breiten in jeder Dimension konstant sind.
• 'quantile': Die Diskretisierung erfolgt auf den quantilen Werten, was bedeutet, dass jeder Bin ungefähr die gleiche Anzahl von Proben hat.
• 'kmeans': Die Diskretisierung basiert auf den Zentroiden eines KMeans-Clustering-Verfahrens.

strategies = ["uniform", "quantile", "kmeans"]

figure = plt.figure(figsize=(14, 9))
i = 1
for ds_cnt, X in enumerate(X_list):
    ax = plt.subplot(len(X_list), len(strategies) + 1, i)
    ax.scatter(X[:, 0], X[:, 1], edgecolors="k")
    if ds_cnt == 0:
        ax.set_title("Input data", size=14)

    xx, yy = np.meshgrid(
        np.linspace(X[:, 0].min(), X[:, 0].max(), 300),
        np.linspace(X[:, 1].min(), X[:, 1].max(), 300),
    )
    grid = np.c_[xx.ravel(), yy.ravel()]

    ax.set_xlim(xx.min(), xx.max())
    ax.set_ylim(yy.min(), yy.max())
    ax.set_xticks(())
    ax.set_yticks(())

    i += 1
    ## transform the dataset with KBinsDiscretizer
    for strategy in strategies:
        enc = KBinsDiscretizer(n_bins=4, encode="ordinal", strategy=strategy)
        enc.fit(X)
        grid_encoded = enc.transform(grid)

        ax = plt.subplot(len(X_list), len(strategies) + 1, i)

        ## horizontal stripes
        horizontal = grid_encoded[:, 0].reshape(xx.shape)
        ax.contourf(xx, yy, horizontal, alpha=0.5)
        ## vertical stripes
        vertical = grid_encoded[:, 1].reshape(xx.shape)
        ax.contourf(xx, yy, vertical, alpha=0.5)

        ax.scatter(X[:, 0], X[:, 1], edgecolors="k")
        ax.set_xlim(xx.min(), xx.max())
        ax.set_ylim(yy.min(), yy.max())
        ax.set_xticks(())
        ax.set_yticks(())
        if ds_cnt == 0:
            ax.set_title("strategy='%s'" % (strategy,), size=14)

        i += 1

plt.tight_layout()
plt.show()

Ergebnisse visualisieren

Wir werden nun die Ergebnisse der Anwendung der verschiedenen Strategien auf die Datensätze visualisieren. Die Diagramme zeigen die Gebiete, in denen die diskretisierte Codierung konstant ist.

Zusammenfassung

In diesem Lab haben wir die verschiedenen Strategien untersucht, die in der Klasse KBinsDiscretizer der Python-Bibliothek scikit-learn zur Verfügung stehen. Wir haben drei Datensätze erstellt und die drei verschiedenen Strategien auf jeden von ihnen angewandt. Anschließend haben wir die Ergebnisse der Diskretisierung visualisiert.