Column Transformer con Tipos Mixtos

Introducción

Esta práctica ilustra cómo aplicar diferentes flujos de preprocesamiento y extracción de características a diferentes subconjuntos de características, utilizando ColumnTransformer. Esto es particularmente útil en el caso de conjuntos de datos que contienen diferentes tipos de datos heterogéneos, ya que es posible que queramos escalar las características numéricas y codificar en caliente las categóricas.

En esta práctica, utilizaremos el conjunto de datos del Titanic de OpenML para construir un flujo de trabajo que preprocese datos categóricos y numéricos utilizando ColumnTransformer y lo utilice para entrenar un modelo de regresión logística.

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 sus comentarios después de la sesión y lo resolveremos rápidamente para usted.

Skills Graph

Importar bibliotecas

En este paso, importaremos las bibliotecas necesarias para construir nuestro flujo de trabajo.

import numpy as np
from sklearn.compose import ColumnTransformer
from sklearn.datasets import fetch_openml
from sklearn.pipeline import Pipeline
from sklearn.impute import SimpleImputer
from sklearn.preprocessing import StandardScaler, OneHotEncoder
from sklearn.linear_model import LogisticRegression
from sklearn.model_selection import train_test_split, RandomizedSearchCV
from sklearn.feature_selection import SelectPercentile, chi2

Cargar el conjunto de datos

En este paso, cargaremos el conjunto de datos del Titanic de OpenML utilizando fetch_openml.

X, y = fetch_openml(
    "titanic", version=1, as_frame=True, return_X_y=True, parser="pandas"
)

Definir características numéricas y categóricas

En este paso, definiremos las características numéricas y categóricas que utilizaremos para nuestro flujo de trabajo. También definiremos los flujos de preprocesamiento para los datos numéricos y categóricos.

numeric_features = ["age", "fare"]
numeric_transformer = Pipeline(
    steps=[("imputer", SimpleImputer(strategy="median")), ("scaler", StandardScaler())]
)

categorical_features = ["embarked", "sex", "pclass"]
categorical_transformer = Pipeline(
    steps=[
        ("encoder", OneHotEncoder(handle_unknown="ignore")),
        ("selector", SelectPercentile(chi2, percentile=50)),
    ]
)

Definir el preprocesador

En este paso, definiremos el ColumnTransformer que se utilizará para preprocesar nuestros datos.

preprocessor = ColumnTransformer(
    transformers=[
        ("num", numeric_transformer, numeric_features),
        ("cat", categorical_transformer, categorical_features),
    ]
)

Adjuntar el clasificador al flujo de preprocesamiento

En este paso, adjuntaremos el clasificador de regresión logística a nuestro flujo de preprocesamiento utilizando Pipeline.

clf = Pipeline(
    steps=[("preprocessor", preprocessor), ("classifier", LogisticRegression())]
)

Dividir los datos

En este paso, dividiremos nuestros datos en conjuntos de entrenamiento y prueba utilizando train_test_split.

X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=0)

Ajustar el flujo de trabajo

En este paso, ajustaremos nuestro flujo de trabajo a nuestros datos de entrenamiento.

clf.fit(X_train, y_train)

Evaluar el flujo de trabajo

En este paso, evaluaremos el rendimiento de nuestro flujo de trabajo calculando la puntuación del modelo.

print("model score: %.3f" % clf.score(X_test, y_test))

Usar ColumnTransformer para seleccionar columnas por tipos de datos

En este paso, usaremos ColumnTransformer para seleccionar columnas por tipos de datos. Usaremos make_column_selector para seleccionar columnas basadas en sus tipos de datos.

from sklearn.compose import make_column_selector as selector

subset_feature = ["embarked", "sex", "pclass", "age", "fare"]
X_train, X_test = X_train[subset_feature], X_test[subset_feature]

preprocessor = ColumnTransformer(
    transformers=[
        ("num", numeric_transformer, selector(dtype_exclude="category")),
        ("cat", categorical_transformer, selector(dtype_include="category")),
    ]
)
clf = Pipeline(
    steps=[("preprocessor", preprocessor), ("classifier", LogisticRegression())]
)

Usar búsqueda en cuadrícula para ajustar hiperparámetros

En este paso, usaremos búsqueda en cuadrícula para ajustar los hiperparámetros de nuestro flujo de trabajo.

param_grid = {
    "preprocessor__num__imputer__strategy": ["mean", "median"],
    "preprocessor__cat__selector__percentile": [10, 30, 50, 70],
    "classifier__C": [0.1, 1.0, 10, 100],
}

search_cv = RandomizedSearchCV(clf, param_grid, n_iter=10, random_state=0)
search_cv.fit(X_train, y_train)

print("Best params:")
print(search_cv.best_params_)
print(f"Internal CV score: {search_cv.best_score_:.3f}")

Resumen

En este laboratorio, aprendimos cómo usar ColumnTransformer para preprocesar datos categóricos y numéricos en un flujo de trabajo y cómo usar búsqueda en cuadrícula para ajustar los hiperparámetros de nuestro flujo de trabajo.