Démonstration des stratégies de KBinsDiscretizer

Introduction

Dans ce laboratoire, nous explorerons les différentes stratégies disponibles dans la classe KBinsDiscretizer de la bibliothèque scikit-learn de Python. KBinsDiscretizer est une classe pour discrétiser les caractéristiques continues en caractéristiques catégorielles en divisant les données continues en intervalles. Nous visualiserons les différentes stratégies en les appliquant à différents ensembles de données.

Conseils sur la machine virtuelle

Une fois le démarrage de la machine virtuelle terminé, cliquez dans le coin supérieur gauche pour basculer vers l'onglet Notebook pour accéder à Jupyter Notebook pour la pratique.

Parfois, vous devrez peut-être attendre quelques secondes pour que Jupyter Notebook ait fini de charger. La validation des opérations ne peut pas être automatisée en raison des limites de Jupyter Notebook.

Si vous rencontrez des problèmes pendant l'apprentissage, n'hésitez pas à demander à Labby. Donnez votre feedback après la session, et nous résoudrons rapidement le problème pour vous.

Importation des bibliothèques

Nous commencerons par importer les bibliothèques nécessaires. Nous utiliserons numpy, matplotlib.pyplot, make_blobs et KBinsDiscretizer du module sklearn.preprocessing.

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

Création d'ensembles de données

Nous allons créer trois ensembles de données à des fins de visualisation. Le premier ensemble de données sera un ensemble aléatoire de 200 échantillons provenant d'une distribution uniforme entre -3 et 3 dans les deux dimensions. Le second ensemble de données sera un ensemble de 200 échantillons générés à l'aide de la fonction make_blobs de sklearn.datasets. Le troisième ensemble de données sera également généré à l'aide de la fonction make_blobs.

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],
]

Appliquer différentes stratégies

Nous allons maintenant appliquer les trois différentes stratégies disponibles dans KBinsDiscretizer à chacun des ensembles de données. Les stratégies sont les suivantes :

• 'uniforme' : La discrétisation est uniforme pour chaque caractéristique, ce qui signifie que les largeurs de bin sont constantes dans chaque dimension.
• 'quantile' : La discrétisation est effectuée sur les valeurs quantiles, ce qui signifie que chaque bin a approximativement le même nombre d'échantillons.
• 'kmeans' : La discrétisation est basée sur les centroïdes d'une procédure de regroupement KMeans.

strategies = ["uniforme", "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("Données d'entrée", 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
    ## transformer l'ensemble de données avec 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)

        ## bandes horizontales
        horizontal = grid_encoded[:, 0].reshape(xx.shape)
        ax.contourf(xx, yy, horizontal, alpha=0.5)
        ## bandes verticales
        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("stratégie='%s'" % (strategy,), size=14)

        i += 1

plt.tight_layout()
plt.show()

Visualiser les résultats

Nous allons maintenant visualiser les résultats de l'application des différentes stratégies aux ensembles de données. Les graphiques montrent les régions où le codage discrétisé est constant.

Sommaire

Dans ce laboratoire, nous avons exploré les différentes stratégies disponibles dans la classe KBinsDiscretizer de la bibliothèque Python scikit - learn. Nous avons créé trois ensembles de données et appliqué les trois différentes stratégies à chacun d'entre eux. Nous avons ensuite visualisé les résultats de la discrétisation.