Discretizar características continuas con KBinsDiscretizer

Introducción

Esta práctica demuestra cómo discretizar características continuas utilizando la clase KBinsDiscretizer en Scikit-learn. La discretización es el proceso de transformar características continuas en características discretas dividiendo los valores de la característica en un conjunto de intervalos (bins). Esto puede ser útil cuando se trabajan con modelos lineales que solo pueden modelar relaciones lineales, o para reducir la complejidad de los árboles de decisión.

Consejos sobre la VM

Una vez que se haya iniciado 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.

Cargar las bibliotecas necesarias

En este paso, importaremos las bibliotecas necesarias.

import numpy as np
import matplotlib.pyplot as plt

from sklearn.linear_model import LinearRegression
from sklearn.preprocessing import KBinsDiscretizer
from sklearn.tree import DecisionTreeRegressor

Crear el conjunto de datos

En este paso, crearemos un conjunto de datos con una característica de entrada continua y una característica de salida continua. Utilizaremos el método numpy.random.RandomState() para generar números aleatorios para la característica de entrada y el método numpy.sin() para generar la característica de salida.

rnd = np.random.RandomState(42)
X = rnd.uniform(-3, 3, size=100)
y = np.sin(X) + rnd.normal(size=len(X)) / 3
X = X.reshape(-1, 1)

Visualizar el conjunto de datos

En este paso, visualizaremos el conjunto de datos utilizando un diagrama de dispersión.

plt.scatter(X, y, color='black')
plt.show()

Discretizar la característica de entrada

En este paso, utilizaremos la clase KBinsDiscretizer para discretizar la característica de entrada. Crearemos 10 intervalos (bins) y utilizaremos codificación one-hot para transformar los datos.

enc = KBinsDiscretizer(n_bins=10, encode="onehot")
X_binned = enc.fit_transform(X)

Visualizar el conjunto de datos discretizado

En este paso, visualizaremos el conjunto de datos discretizado utilizando un diagrama de dispersión.

plt.scatter(X_binned, y, color='black')
plt.show()

Entrenar un modelo de regresión lineal

En este paso, entrenaremos un modelo de regresión lineal en el conjunto de datos original.

reg = LinearRegression().fit(X, y)

Entrenar un modelo de árbol de decisión

En este paso, entrenaremos un modelo de árbol de decisión en el conjunto de datos original.

reg = DecisionTreeRegressor(min_samples_split=3, random_state=0).fit(X, y)

Entrenar un modelo de regresión lineal en el conjunto de datos discretizado

En este paso, entrenaremos un modelo de regresión lineal en el conjunto de datos discretizado.

reg = LinearRegression().fit(X_binned, y)

Entrenar un modelo de árbol de decisión en el conjunto de datos discretizado

En este paso, entrenaremos un modelo de árbol de decisión en el conjunto de datos discretizado.

reg = DecisionTreeRegressor(min_samples_split=3, random_state=0).fit(X_binned, y)

Visualizar los resultados

En este paso, visualizaremos los resultados de los modelos de regresión lineal y de árbol de decisión antes y después de la discretización.

## predecir con el conjunto de datos original
fig, (ax1, ax2) = plt.subplots(ncols=2, sharey=True, figsize=(10, 4))
line = np.linspace(-3, 3, 1000, endpoint=False).reshape(-1, 1)
reg = LinearRegression().fit(X, y)
ax1.plot(line, reg.predict(line), linewidth=2, color="green", label="regresión lineal")
reg = DecisionTreeRegressor(min_samples_split=3, random_state=0).fit(X, y)
ax1.plot(line, reg.predict(line), linewidth=2, color="red", label="árbol de decisión")
ax1.plot(X[:, 0], y, "o", c="k")
ax1.legend(loc="best")
ax1.set_ylabel("Salida de regresión")
ax1.set_xlabel("Característica de entrada")
ax1.set_title("Resultado antes de la discretización")

## predecir con el conjunto de datos transformado
line_binned = enc.transform(line)
reg = LinearRegression().fit(X_binned, y)
ax2.plot(
    line,
    reg.predict(line_binned),
    linewidth=2,
    color="green",
    linestyle="-",
    label="regresión lineal",
)
reg = DecisionTreeRegressor(min_samples_split=3, random_state=0).fit(X_binned, y)
ax2.plot(
    line,
    reg.predict(line_binned),
    linewidth=2,
    color="red",
    linestyle=":",
    label="árbol de decisión",
)
ax2.plot(X[:, 0], y, "o", c="k")
ax2.vlines(enc.bin_edges_[0], *plt.gca().get_ylim(), linewidth=1, alpha=0.2)
ax2.legend(loc="best")
ax2.set_xlabel("Característica de entrada")
ax2.set_title("Resultado después de la discretización")

plt.tight_layout()
plt.show()

Resumen

En este laboratorio, aprendimos cómo discretizar características continuas utilizando la clase KBinsDiscretizer de Scikit-learn. La discretización puede ser útil cuando se trabaja con modelos lineales o para reducir la complejidad de los árboles de decisión. También aprendimos cómo entrenar modelos de regresión lineal y árbol de decisión en ambos conjuntos de datos originales y discretizados, y cómo visualizar los resultados.