Pipelines de Pré-processamento e Extração de Características | Conjunto de Dados Titanic

Introdução

Este laboratório ilustra como aplicar diferentes pipelines de pré-processamento e extração de características a diferentes subconjuntos de características, utilizando ColumnTransformer. Isto é particularmente útil para conjuntos de dados que contêm tipos de dados heterogéneos, uma vez que podemos querer escalar as características numéricas e codificar em one-hot as características categóricas.

Neste laboratório, utilizaremos o conjunto de dados Titanic do OpenML para construir um pipeline que pré-processa dados categóricos e numéricos utilizando ColumnTransformer e utilizá-lo para treinar um modelo de regressão logística.

Dicas da VM

Após o arranque da VM, clique no canto superior esquerdo para mudar para a aba Notebook para aceder ao Jupyter Notebook para a prática.

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 a aprendizagem, não hesite em contactar o Labby. Forneça feedback após a sessão e resolveremos prontamente o problema para si.

Importar Bibliotecas

Neste passo, iremos importar as bibliotecas necessárias para construir o nosso pipeline.

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

Carregar o Conjunto de Dados

Neste passo, carregaremos o conjunto de dados Titanic do 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 e Categóricas

Neste passo, definiremos as características numéricas e categóricas que utilizaremos no nosso pipeline. Também definiremos os pipelines de pré-processamento para dados numéricos e 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 o Pré-processador

Neste passo, definiremos o ColumnTransformer que será utilizado para pré-processar os nossos dados.

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

Adicionar o Classificador ao Pipeline de Pré-processamento

Neste passo, adicionaremos o classificador de regressão logística ao nosso pipeline de pré-processamento utilizando Pipeline.

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

Dividir os Dados

Neste passo, dividiremos os nossos dados em conjuntos de treino e teste 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 o Pipeline

Neste passo, ajustaremos o nosso pipeline aos nossos dados de treino.

clf.fit(X_train, y_train)

Avaliar o Pipeline

Neste passo, avaliaremos o desempenho do nosso pipeline calculando a pontuação do modelo.

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

Utilizar ColumnTransformer Selecionando Colunas por Tipos de Dados

Neste passo, utilizaremos ColumnTransformer selecionando colunas por seus tipos de dados. Usaremos make_column_selector para selecionar colunas com base em seus tipos de dados.

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 Busca em Grade para Ajustar Hiperparâmetros

Neste passo, usaremos busca em grade para ajustar os hiperparâmetros do nosso pipeline.

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("Melhores parâmetros:")
print(search_cv.best_params_)
print(f"Pontuação de validação cruzada interna: {search_cv.best_score_:.3f}")

Resumo

Neste laboratório, aprendemos como usar ColumnTransformer para pré-processar dados categóricos e numéricos em um pipeline e como usar busca em grade para ajustar os hiperparâmetros do nosso pipeline.

Transformador de Colunas com Tipos Mistos