Demostración de las estrategias de KBinsDiscretizer

Introducción

En este laboratorio, exploraremos las diferentes estrategias disponibles en la clase KBinsDiscretizer de la biblioteca scikit-learn de Python. KBinsDiscretizer es una clase para discretizar características continuas en características categóricas mediante la división de los datos continuos en intervalos. Visualizaremos las diferentes estrategias aplicándolas a diferentes conjuntos de datos.

Consejos sobre la VM

Una vez finalizada la inicialización de la VM, haga clic en la esquina superior izquierda para cambiar a la pestaña Cuaderno y acceder a Jupyter Notebook para practicar.

A veces, es posible que tenga que esperar unos segundos a que Jupyter Notebook termine de cargarse. La validación de las operaciones no se puede automatizar debido a las limitaciones de Jupyter Notebook.

Si tiene problemas durante el aprendizaje, no dude en preguntar a Labby. Deje su retroalimentación después de la sesión y le resolveremos el problema inmediatamente.

Skills Graph

Importar bibliotecas

Comenzaremos importando las bibliotecas necesarias. Usaremos numpy, matplotlib.pyplot, make_blobs y KBinsDiscretizer del módulo sklearn.preprocessing.

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

Crear conjuntos de datos

Crearemos tres conjuntos de datos con fines de visualización. El primer conjunto de datos será un conjunto aleatorio de 200 muestras de una distribución uniforme entre -3 y 3 en ambas dimensiones. El segundo conjunto de datos será un conjunto de 200 muestras generadas usando la función make_blobs de sklearn.datasets. El tercer conjunto de datos también se generará usando la función 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],
]

Aplicar diferentes estrategias

Ahora aplicaremos las tres diferentes estrategias disponibles en KBinsDiscretizer a cada uno de los conjuntos de datos. Las estrategias son:

• 'uniforme': La discretización es uniforme en cada característica, lo que significa que los anchos de los intervalos son constantes en cada dimensión.
• 'cuantílica': La discretización se realiza en los valores cuantilados, lo que significa que cada intervalo tiene aproximadamente el mismo número de muestras.
• 'kmeans': La discretización se basa en los centroides de un procedimiento de agrupamiento KMeans.

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("Datos de entrada", 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
    ## transformar el conjunto de datos con 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)

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

        i += 1

plt.tight_layout()
plt.show()

Visualizar los resultados

Ahora visualizaremos los resultados de aplicar las diferentes estrategias a los conjuntos de datos. Las gráficas muestran las regiones donde la codificación discretizada es constante.

Resumen

En este laboratorio, exploramos las diferentes estrategias disponibles en la clase KBinsDiscretizer de la biblioteca scikit - learn de Python. Creamos tres conjuntos de datos y aplicamos las tres diferentes estrategias a cada uno de ellos. Luego visualizamos los resultados de la discretización.