Escalonamento e Transformação de Dados

Introdução

Este laboratório demonstra como usar diferentes técnicas de escalonamento e transformação em um conjunto de dados com valores discrepantes usando a biblioteca scikit-learn do Python.

Dicas da Máquina Virtual

Após o início da VM, clique no canto superior esquerdo para mudar para a aba Notebook para acessar o Jupyter Notebook para praticar.

Às vezes, pode ser necessário aguardar alguns segundos para que o Jupyter Notebook termine de carregar. A validação das operações não pode ser automatizada devido a limitações no Jupyter Notebook.

Se você encontrar problemas durante o aprendizado, sinta-se à vontade para perguntar ao Labby. Forneça feedback após a sessão e resolveremos o problema rapidamente para você.

Importar Bibliotecas e Conjunto de Dados

Primeiro, precisamos importar as bibliotecas necessárias e carregar o conjunto de dados California Housing do scikit-learn.

import numpy as np
import matplotlib.pyplot as plt
from sklearn.preprocessing import MinMaxScaler, StandardScaler, RobustScaler, Normalizer, QuantileTransformer, PowerTransformer
from sklearn.datasets import fetch_california_housing

## Carregar o conjunto de dados California Housing
dataset = fetch_california_housing()
X_full, y_full = dataset.data, dataset.target
feature_names = dataset.feature_names

Selecionar Recursos e Definir Mapeamento de Recursos

Em seguida, selecionamos dois recursos do conjunto de dados para facilitar a visualização e definimos um mapeamento dos nomes dos recursos para uma melhor visualização.

## Selecionar dois recursos
features = ["MedInc", "AveOccup"]
features_idx = [feature_names.index(feature) for feature in features]
X = X_full[:, features_idx]

## Definir mapeamento de recursos
feature_mapping = {
    "MedInc": "Rendimento médio no bloco",
    "AveOccup": "Ocupação média de casas",
}

Definir Distribuições

Definimos uma lista de diferentes escalonadores, transformadores e normalizadores para colocar os dados dentro de um intervalo pré-definido e armazená-los numa lista chamada distribuições.

## Definir distribuições
distributions = [
    ("Dados não escalonados", X),
    ("Dados após escalonamento padrão", StandardScaler().fit_transform(X)),
    ("Dados após escalonamento min-max", MinMaxScaler().fit_transform(X)),
    ("Dados após escalonamento robusto", RobustScaler(quantile_range=(25, 75)).fit_transform(X)),
    ("Dados após normalização L2 por amostra", Normalizer().fit_transform(X)),
    ("Dados após transformação de quantis (pdf uniforme)", QuantileTransformer(output_distribution="uniform").fit_transform(X)),
    ("Dados após transformação de quantis (pdf gaussiano)", QuantileTransformer(output_distribution="normal").fit_transform(X)),
    ("Dados após transformação de potência (Yeo-Johnson)", PowerTransformer(method="yeo-johnson").fit_transform(X)),
    ("Dados após transformação de potência (Box-Cox)", PowerTransformer(method="box-cox").fit_transform(X)),
]

Plotar Distribuições

Finalmente, criamos uma função para plotar cada distribuição e chamamos a função para cada distribuição na lista. A função mostrará dois gráficos para cada escalonador/transformador/normalizador. O gráfico da esquerda mostra um gráfico de dispersão do conjunto de dados completo, e o gráfico da direita exclui os valores extremos, considerando apenas 99% do conjunto de dados, excluindo outliers marginais. Além disso, as distribuições marginais para cada recurso serão mostradas nas laterais do gráfico de dispersão.

## Plotar distribuições
def plot_distribution(axes, X, y, hist_nbins=50, title="", x0_label="", x1_label=""):
    ax, hist_X1, hist_X0 = axes

    ax.set_title(title)
    ax.set_xlabel(x0_label)
    ax.set_ylabel(x1_label)

    ## O gráfico de dispersão
    colors = cm.plasma_r(y)
    ax.scatter(X[:, 0], X[:, 1], alpha=0.5, marker="o", s=5, lw=0, c=colors)

    ## Removendo as linhas superior e direita para estética
    ## Criar um layout de eixos agradável
    ax.spines["top"].set_visible(False)
    ax.spines["right"].set_visible(False)
    ax.get_xaxis().tick_bottom()
    ax.get_yaxis().tick_left()
    ax.spines["left"].set_position(("outward", 10))
    ax.spines["bottom"].set_position(("outward", 10))

    ## Histograma para o eixo X1 (recurso 5)
    hist_X1.set_ylim(ax.get_ylim())
    hist_X1.hist(
        X[:, 1], bins=hist_nbins, orientation="horizontal", color="grey", ec="grey"
    )
    hist_X1.axis("off")

    ## Histograma para o eixo X0 (recurso 0)
    hist_X0.set_xlim(ax.get_xlim())
    hist_X0.hist(
        X[:, 0], bins=hist_nbins, orientation="vertical", color="grey", ec="grey"
    )
    hist_X0.axis("off")


## escalonar a saída entre 0 e 1 para a barra de cores
y = minmax_scale(y_full)

## plasma não existe no matplotlib < 1.5
cmap = getattr(cm, "plasma_r", cm.hot_r)

def create_axes(title, figsize=(16, 6)):
    fig = plt.figure(figsize=figsize)
    fig.suptitle(title)

    ## definir o eixo para o primeiro gráfico
    ## ... (código restante)

Resumo

Este laboratório demonstrou como usar diferentes técnicas de escalonamento e transformação em um conjunto de dados com outliers usando a biblioteca scikit-learn do Python. Aprendemos como selecionar recursos, definir mapeamento de recursos e plotar distribuições. Também exploramos os efeitos de diferentes técnicas de escalonamento e transformação e como elas podem afetar os dados.