Discretização de Características Contínuas com KBinsDiscretizer

Introdução

Este laboratório demonstra como discretizar características contínuas utilizando a classe KBinsDiscretizer no Scikit-learn. A discretização é o processo de transformar características contínuas em características discretas, dividindo os valores das características em um conjunto de intervalos (bins). Isto pode ser útil ao trabalhar com modelos lineares que só podem modelar relações lineares, ou para reduzir a complexidade de árvores de decisão.

Dicas da Máquina Virtual

Após o arranque da máquina virtual, clique no canto superior esquerdo para mudar para a aba Notebook para aceder ao Jupyter Notebook para praticar.

Por vezes, pode ser necessário esperar alguns segundos para o Jupyter Notebook terminar de carregar. A validação das operações não pode ser automatizada devido a limitações no Jupyter Notebook.

Se tiver problemas durante o aprendizado, não hesite em contactar o Labby. Forneça feedback após a sessão, e resolveremos prontamente o problema para si.

Carregar as Bibliotecas Necessárias

Neste passo, iremos importar as bibliotecas necessárias.

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

Criar o Conjunto de Dados

Neste passo, criaremos um conjunto de dados com uma característica de entrada contínua e uma característica de saída contínua. Usaremos o método numpy.random.RandomState() para gerar números aleatórios para a característica de entrada e o método numpy.sin() para gerar a característica de saída.

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 o Conjunto de Dados

Neste passo, visualizaremos o conjunto de dados utilizando um gráfico de dispersão.

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

Discretizar a Característica de Entrada

Neste passo, usaremos a classe KBinsDiscretizer para discretizar a característica de entrada. Criaremos 10 bins e usaremos a codificação one-hot para transformar os dados.

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

Visualizar o Conjunto de Dados Discretizado

Neste passo, visualizaremos o conjunto de dados discretizado utilizando um gráfico de dispersão.

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

Treinar um Modelo de Regressão Linear

Neste passo, treinaremos um modelo de regressão linear no conjunto de dados original.

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

Treinar um Modelo de Árvore de Decisão

Neste passo, treinaremos um modelo de árvore de decisão no conjunto de dados original.

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

Treinar um Modelo de Regressão Linear no Conjunto de Dados Discretizado

Neste passo, treinaremos um modelo de regressão linear no conjunto de dados discretizado.

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

Treinar um Modelo de Árvore de Decisão no Conjunto de Dados Discretizado

Neste passo, treinaremos um modelo de árvore de decisão no conjunto de dados discretizado.

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

Visualizar os Resultados

Neste passo, visualizaremos os resultados dos modelos de regressão linear e árvore de decisão antes e depois da discretização.

## prever com o conjunto de dados 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="regressão linear")
reg = DecisionTreeRegressor(min_samples_split=3, random_state=0).fit(X, y)
ax1.plot(line, reg.predict(line), linewidth=2, color="red", label="árvore de decisão")
ax1.plot(X[:, 0], y, "o", c="k")
ax1.legend(loc="best")
ax1.set_ylabel("Saída da regressão")
ax1.set_xlabel("Característica de entrada")
ax1.set_title("Resultado antes da discretização")

## prever com o conjunto de dados 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="regressão linear",
)
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="árvore de decisão",
)
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 após a discretização")

plt.tight_layout()
plt.show()

Resumo

Neste laboratório, aprendemos como discretizar características contínuas utilizando a classe KBinsDiscretizer no Scikit-learn. A discretização pode ser útil ao trabalhar com modelos lineares ou para reduzir a complexidade de árvores de decisão. Também aprendemos como treinar modelos de regressão linear e árvores de decisão nos conjuntos de dados originais e discretizados, e como visualizar os resultados.