Pipelines de prétraitement et d'extraction de fonctionnalités | Jeu de données Titanic

Introduction

Ce laboratoire illustre comment appliquer différents pipelines de prétraitement et d'extraction de fonctionnalités à différents sous-ensembles de fonctionnalités, en utilisant ColumnTransformer. Cela est particulièrement pratique dans le cas de jeux de données qui contiennent différents types de données, car nous pouvons vouloir mettre à l'échelle les fonctionnalités numériques et encoder en une-hot les fonctionnalités catégorielles.

Dans ce laboratoire, nous utiliserons le jeu de données Titanic d'OpenML pour construire un pipeline qui prétraite les données catégorielles et numériques à l'aide de ColumnTransformer et l'utiliser pour entraîner un modèle de régression logistique.

Conseils sur la machine virtuelle

Une fois le démarrage de la machine virtuelle terminé, cliquez dans le coin supérieur gauche pour passer à l'onglet Notebook pour accéder à Jupyter Notebook pour la pratique.

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

Si vous rencontrez des problèmes pendant l'apprentissage, n'hésitez pas à demander à Labby. Donnez des commentaires après la session, et nous résoudrons rapidement le problème pour vous.

Importation des bibliothèques

Dans cette étape, nous allons importer les bibliothèques nécessaires pour construire notre 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

Charger le jeu de données

Dans cette étape, nous allons charger le jeu de données Titanic d'OpenML en utilisant fetch_openml.

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

Définir les fonctionnalités numériques et catégorielles

Dans cette étape, nous allons définir les fonctionnalités numériques et catégorielles que nous utiliserons pour notre pipeline. Nous allons également définir les pipelines de prétraitement pour les données numériques et catégorielles.

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)),
    ]
)

Définir le prétraitement

Dans cette étape, nous allons définir le ColumnTransformer qui sera utilisé pour prétraiter nos données.

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

Ajouter le classifieur au pipeline de prétraitement

Dans cette étape, nous allons ajouter le classifieur de régression logistique à notre pipeline de prétraitement en utilisant Pipeline.

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

Diviser les données

Dans cette étape, nous allons diviser nos données en ensembles d'entraînement et de test en utilisant train_test_split.

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

Ajuster le pipeline

Dans cette étape, nous allons ajuster notre pipeline aux données d'entraînement.

clf.fit(X_train, y_train)

Évaluer le pipeline

Dans cette étape, nous allons évaluer les performances de notre pipeline en calculant le score du modèle.

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

Utiliser ColumnTransformer pour sélectionner des colonnes en fonction des types de données

Dans cette étape, nous allons utiliser ColumnTransformer pour sélectionner des colonnes en fonction de leurs types de données. Nous allons utiliser make_column_selector pour sélectionner des colonnes en fonction de leurs types de données.

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())]
)

Utiliser la recherche en grille pour ajuster les hyperparamètres

Dans cette étape, nous allons utiliser la recherche en grille pour ajuster les hyperparamètres de notre 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("Best params:")
print(search_cv.best_params_)
print(f"Internal CV score: {search_cv.best_score_:.3f}")

Sommaire

Dans ce laboratoire, nous avons appris à utiliser ColumnTransformer pour prétraiter les données catégorielles et numériques dans un pipeline et à utiliser la recherche en grille pour ajuster les hyperparamètres de notre pipeline.

Column Transformer avec types mixtes