Escalado de Características en el Aprendizaje Automático

Introducción

La escalación de características es un paso importante de preprocesamiento para muchos algoritmos de aprendizaje automático. Consiste en reescalar cada característica de modo que tenga una desviación estándar de 1 y una media de 0. En este laboratorio, exploraremos la importancia de la escalación de características y su efecto en los modelos de aprendizaje automático utilizando la biblioteca scikit-learn en Python.

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 resolveremos rápidamente el problema para usted.

Cargar y preparar los datos

Cargaremos el conjunto de datos de vinos de scikit-learn y lo dividiremos en conjuntos de entrenamiento y prueba. También escalaremos las características en el conjunto de entrenamiento utilizando el StandardScaler del módulo de preprocesamiento de scikit-learn.

from sklearn.datasets import load_wine
from sklearn.model_selection import train_test_split
from sklearn.preprocessing import StandardScaler

X, y = load_wine(return_X_y=True, as_frame=True)
scaler = StandardScaler().set_output(transform="pandas")

X_train, X_test, y_train, y_test = train_test_split(
    X, y, test_size=0.30, random_state=42
)
scaled_X_train = scaler.fit_transform(X_train)

Efecto de la reescalación en un modelo de k-vecinos más cercanos

Utilizaremos un subconjunto de dos características del conjunto de datos de vinos para entrenar un clasificador de k-vecinos más cercanos. Visualizaremos el límite de decisión del clasificador utilizando datos no escalados y escalados.

import matplotlib.pyplot as plt
from sklearn.inspection import DecisionBoundaryDisplay
from sklearn.neighbors import KNeighborsClassifier

X_plot = X[["proline", "hue"]]
X_plot_scaled = scaler.fit_transform(X_plot)
clf = KNeighborsClassifier(n_neighbors=20)

def fit_and_plot_model(X_plot, y, clf, ax):
    clf.fit(X_plot, y)
    disp = DecisionBoundaryDisplay.from_estimator(
        clf,
        X_plot,
        response_method="predict",
        alpha=0.5,
        ax=ax,
    )
    disp.ax_.scatter(X_plot["proline"], X_plot["hue"], c=y, s=20, edgecolor="k")
    disp.ax_.set_xlim((X_plot["proline"].min(), X_plot["proline"].max()))
    disp.ax_.set_ylim((X_plot["hue"].min(), X_plot["hue"].max()))
    return disp.ax_

fig, (ax1, ax2) = plt.subplots(ncols=2, figsize=(12, 6))

fit_and_plot_model(X_plot, y, clf, ax1)
ax1.set_title("KNN sin escalado")

fit_and_plot_model(X_plot_scaled, y, clf, ax2)
ax2.set_xlabel("proline escalado")
ax2.set_ylabel("hue escalado")
_ = ax2.set_title("KNN con escalado")

Efecto de la reescalación en una reducción de dimensionalidad por Análisis de Componentes Principales (PCA)

Utilizaremos el Análisis de Componentes Principales (PCA) para reducir la dimensionalidad del conjunto de datos de vinos. Compararemos los componentes principales encontrados utilizando PCA en datos no escalados con aquellos obtenidos cuando se escala primero los datos utilizando StandardScaler.

import pandas as pd
from sklearn.decomposition import PCA

pca = PCA(n_components=2).fit(X_train)
scaled_pca = PCA(n_components=2).fit(scaled_X_train)
X_train_transformed = pca.transform(X_train)
X_train_std_transformed = scaled_pca.transform(scaled_X_train)

first_pca_component = pd.DataFrame(
    pca.components_[0], index=X.columns, columns=["without scaling"]
)
first_pca_component["with scaling"] = scaled_pca.components_[0]
first_pca_component.plot.bar(
    title="Weights of the first principal component", figsize=(6, 8)
)

_ = plt.tight_layout()

fig, (ax1, ax2) = plt.subplots(nrows=1, ncols=2, figsize=(10, 5))

target_classes = range(0, 3)
colors = ("blue", "red", "green")
markers = ("^", "s", "o")

for target_class, color, marker in zip(target_classes, colors, markers):
    ax1.scatter(
        x=X_train_transformed[y_train == target_class, 0],
        y=X_train_transformed[y_train == target_class, 1],
        color=color,
        label=f"class {target_class}",
        alpha=0.5,
        marker=marker,
    )

    ax2.scatter(
        x=X_train_std_transformed[y_train == target_class, 0],
        y=X_train_std_transformed[y_train == target_class, 1],
        color=color,
        label=f"class {target_class}",
        alpha=0.5,
        marker=marker,
    )

ax1.set_title("Unscaled training dataset after PCA")
ax2.set_title("Standardized training dataset after PCA")

for ax in (ax1, ax2):
    ax.set_xlabel("1st principal component")
    ax.set_ylabel("2nd principal component")
    ax.legend(loc="upper right")
    ax.grid()

_ = plt.tight_layout()

Efecto de la reescalación en el rendimiento del modelo

Entrenaremos un modelo de regresión logística con datos reducidos por PCA para evaluar el efecto de la escalación de características en el rendimiento del modelo. Compararemos el rendimiento del modelo con características no escaladas y escaladas.

import numpy as np
from sklearn.pipeline import make_pipeline
from sklearn.linear_model import LogisticRegressionCV
from sklearn.metrics import accuracy_score
from sklearn.metrics import log_loss

Cs = np.logspace(-5, 5, 20)

unscaled_clf = make_pipeline(pca, LogisticRegressionCV(Cs=Cs))
unscaled_clf.fit(X_train, y_train)

scaled_clf = make_pipeline(scaler, pca, LogisticRegressionCV(Cs=Cs))
scaled_clf.fit(X_train, y_train)

y_pred = unscaled_clf.predict(X_test)
y_pred_scaled = scaled_clf.predict(X_test)
y_proba = unscaled_clf.predict_proba(X_test)
y_proba_scaled = scaled_clf.predict_proba(X_test)

print("Test accuracy for the unscaled PCA")
print(f"{accuracy_score(y_test, y_pred):.2%}\n")
print("Test accuracy for the standardized data with PCA")
print(f"{accuracy_score(y_test, y_pred_scaled):.2%}\n")
print("Log-loss for the unscaled PCA")
print(f"{log_loss(y_test, y_proba):.3}\n")
print("Log-loss for the standardized data with PCA")
print(f"{log_loss(y_test, y_proba_scaled):.3}")

Resumen

En este laboratorio, aprendimos sobre la importancia de la escalación de características en el aprendizaje automático y su efecto en el rendimiento del modelo. Exploramos el efecto de la escalación de características en un modelo de k-vecinos más cercanos y en la reducción de dimensionalidad por PCA. También entrenamos un modelo de regresión logística con datos reducidos por PCA para evaluar el efecto de la escalación de características en el rendimiento del modelo. Encontramos que escalar las características antes de reducir la dimensionalidad da como resultado componentes del mismo orden de magnitud y mejora la separabilidad de las clases, lo que conduce a un mejor rendimiento del modelo.