Mise à l'échelle et transformation des données

Introduction

Ce laboratoire montre comment utiliser différentes techniques d'échelle et de transformation sur un ensemble de données avec des valeurs aberrantes à l'aide de la bibliothèque scikit-learn de Python.

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 Carnet de notes pour accéder au carnet Jupyter pour pratiquer.

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

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.

Skills Graph

Importation des bibliothèques et de l'ensemble de données

Tout d'abord, nous devons importer les bibliothèques nécessaires et charger l'ensemble de données California Housing à partir de 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

## Charger l'ensemble de données California Housing
dataset = fetch_california_housing()
X_full, y_full = dataset.data, dataset.target
feature_names = dataset.feature_names

Sélectionner les caractéristiques et définir la carte des caractéristiques

Ensuite, nous sélectionnons deux caractéristiques de l'ensemble de données pour faciliter la visualisation et définissons une carte des noms des caractéristiques pour une meilleure visualisation.

## Sélectionner deux caractéristiques
features = ["MedInc", "AveOccup"]
features_idx = [feature_names.index(feature) for feature in features]
X = X_full[:, features_idx]

## Définir la carte des caractéristiques
feature_mapping = {
    "MedInc": "Revenu médian dans le bloc",
    "AveOccup": "Occupation moyenne des maisons",
}

Définir les distributions

Nous définissons une liste de différents échelleurs, transformateurs et normaliseurs pour ramener les données dans une plage prédéfinie et les stockons dans une liste appelée distributions.

## Définir les distributions
distributions = [
    ("Données non mises à l'échelle", X),
    ("Données après mise à l'échelle standard", StandardScaler().fit_transform(X)),
    ("Données après mise à l'échelle min-max", MinMaxScaler().fit_transform(X)),
    ("Données après mise à l'échelle robuste", RobustScaler(quantile_range=(25, 75)).fit_transform(X)),
    ("Données après normalisation L2 par échantillon", Normalizer().fit_transform(X)),
    ("Données après transformation quantile (pdf uniforme)", QuantileTransformer(output_distribution="uniform").fit_transform(X)),
    ("Données après transformation quantile (pdf gaussienne)", QuantileTransformer(output_distribution="normal").fit_transform(X)),
    ("Données après transformation de puissance (Yeo-Johnson)", PowerTransformer(method="yeo-johnson").fit_transform(X)),
    ("Données après transformation de puissance (Box-Cox)", PowerTransformer(method="box-cox").fit_transform(X)),
]

Tracer les distributions

Enfin, nous créons une fonction pour tracer chaque distribution et appelons la fonction pour chaque distribution de la liste. La fonction affichera deux graphiques pour chaque échelleur/normaliseur/transformateur. Le graphique de gauche montre un nuage de points de l'ensemble de données complet, et le graphique de droite exclut les valeurs extrêmes, en considérant seulement 99 % de l'ensemble de données, en excluant les valeurs aberrantes marginales. De plus, les distributions marginales pour chaque caractéristique seront affichées sur les côtés du nuage de points.

## Tracer les distributions
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)

    ## Le nuage de points
    colors = cm.plasma_r(y)
    ax.scatter(X[:, 0], X[:, 1], alpha=0.5, marker="o", s=5, lw=0, c=colors)

    ## Suppression de la ligne supérieure et de la ligne droite pour l'esthétique
    ## créer un bel agencement d'axes
    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))

    ## Histogramme pour l'axe X1 (caractéristique 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")

    ## Histogramme pour l'axe X0 (caractéristique 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")


## Mettre à l'échelle la sortie entre 0 et 1 pour la barre de couleur
y = minmax_scale(y_full)

## plasma n'existe pas dans 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)

    ## définir l'axe pour le premier graphique
    left, width = 0.1, 0.22
    bottom, height = 0.1, 0.7
    bottom_h = height + 0.15
    left_h = left + width + 0.02

    rect_scatter = [left, bottom, width, height]
    rect_histx = [left, bottom_h, width, 0.1]
    rect_histy = [left_h, bottom, 0.05, height]

    ax_scatter = plt.axes(rect_scatter)
    ax_histx = plt.axes(rect_histx)
    ax_histy = plt.axes(rect_histy)

    ## définir l'axe pour le graphique agrandi
    left = width + left + 0.2
    left_h = left + width + 0.02

    rect_scatter = [left, bottom, width, height]
    rect_histx = [left, bottom_h, width, 0.1]
    rect_histy = [left_h, bottom, 0.05, height]

    ax_scatter_zoom = plt.axes(rect_scatter)
    ax_histx_zoom = plt.axes(rect_histx)
    ax_histy_zoom = plt.axes(rect_histy)

    ## définir l'axe pour la barre de couleur
    left, width = width + left + 0.13, 0.01

    rect_colorbar = [left, bottom, width, height]
    ax_colorbar = plt.axes(rect_colorbar)

    return (
        (ax_scatter, ax_histy, ax_histx),
        (ax_scatter_zoom, ax_histy_zoom, ax_histx_zoom),
        ax_colorbar,
    )

def make_plot(item_idx):
    title, X = distributions[item_idx]
    ax_zoom_out, ax_zoom_in, ax_colorbar = create_axes(title)
    axarr = (ax_zoom_out, ax_zoom_in)
    plot_distribution(
        axarr[0],
        X,
        y,
        hist_nbins=200,
        x0_label=feature_mapping[features[0]],
        x1_label=feature_mapping[features[1]],
        title="Données complètes",
    )

    ## agrandissement
    zoom_in_percentile_range = (0, 99)
    cutoffs_X0 = np.percentile(X[:, 0], zoom_in_percentile_range)
    cutoffs_X1 = np.percentile(X[:, 1], zoom_in_percentile_range)

    non_outliers_mask = np.all(X > [cutoffs_X0[0], cutoffs_X1[0]], axis=1) & np.all(
        X < [cutoffs_X0[1], cutoffs_X1[1]], axis=1
    )
    plot_distribution(
        axarr[1],
        X[non_outliers_mask],
        y[non_outliers_mask],
        hist_nbins=50,
        x0_label=feature_mapping[features[0]],
        x1_label=feature_mapping[features[1]],
        title="Agrandissement",
    )

    norm = mpl.colors.Normalize(y_full.min(), y_full.max())
    mpl.colorbar.ColorbarBase(
        ax_colorbar,
        cmap=cmap,
        norm=norm,
        orientation="vertical",
        label="Mappage de couleur pour les valeurs de y",
    )

## Tracer toutes les distributions
for i in range(len(distributions)):
    make_plot(i)

plt.show()

Sommaire

Ce laboratoire a démontré comment utiliser différentes techniques d'échelle et de transformation sur un ensemble de données avec des valeurs aberrantes à l'aide de la bibliothèque scikit-learn de Python. Nous avons appris comment sélectionner des caractéristiques, définir une carte des caractéristiques et tracer des distributions. Nous avons également exploré les effets de différentes techniques d'échelle et de transformation et comment elles peuvent affecter les données.