Transformation des données catégorielles à l'aide de TargetEncoder

Introduction

Dans ce laboratoire, nous allons apprendre à utiliser la classe TargetEncoder de la bibliothèque Scikit-learn. Le codage cible est une technique utilisée pour transformer les données catégorielles en données numériques qui peuvent être utilisées en tant qu'entrée pour les algorithmes d'apprentissage automatique. Le TargetEncoder remplace chaque catégorie d'une caractéristique catégorielle par la moyenne de la variable cible pour cette catégorie. Cette méthode est utile dans les cas où il existe une forte relation entre la caractéristique catégorielle et la cible.

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 la pratique.

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.

Installer les bibliothèques requises

Tout d'abord, nous devons installer les bibliothèques requises. Nous allons utiliser les bibliothèques Scikit-learn, Pandas et Matplotlib. Exécutez la commande suivante pour installer ces bibliothèques :

!pip install scikit-learn pandas matplotlib

Importer les bibliothèques requises

Ensuite, nous devons importer les bibliothèques requises. Exécutez le code suivant pour importer les bibliothèques requises :

import numpy as np
import pandas as pd
from sklearn.preprocessing import KBinsDiscretizer, TargetEncoder
from sklearn.linear_model import Ridge
from sklearn.pipeline import make_pipeline
from sklearn.model_selection import train_test_split
import matplotlib.pyplot as plt

Créer un ensemble de données synthétique

Pour ce laboratoire, nous allons créer un ensemble de données synthétique avec trois caractéristiques catégorielles : une caractéristique informative avec une cardinalité moyenne, une caractéristique non informative avec une cardinalité moyenne et une caractéristique non informative avec une cardinalité élevée. Nous utiliserons la classe KBinsDiscretizer de Scikit-learn pour générer la caractéristique informative. Exécutez le code suivant pour créer l'ensemble de données synthétique :

n_samples = 50_000

rng = np.random.RandomState(42)
y = rng.randn(n_samples)
noise = 0.5 * rng.randn(n_samples)
n_categories = 100

kbins = KBinsDiscretizer(
    n_bins=n_categories, encode="ordinal", strategy="uniform", random_state=rng
)
X_informative = kbins.fit_transform((y + noise).reshape(-1, 1))

permuted_categories = rng.permutation(n_categories)
X_informative = permuted_categories[X_informative.astype(np.int32)]

X_shuffled = rng.permutation(X_informative)

X_near_unique_categories = rng.choice(
    int(0.9 * n_samples), size=n_samples, replace=True
).reshape(-1, 1)

X = pd.DataFrame(
    np.concatenate(
        [X_informative, X_shuffled, X_near_unique_categories],
        axis=1,
    ),
    columns=["informative", "shuffled", "near_unique"],
)
X_train, X_test, y_train, y_test = train_test_split(X, y, random_state=0)

Entraîner un régresseur Ridge sur les données brutes

Dans cette section, nous allons entraîner un régresseur Ridge sur l'ensemble de données avec et sans codage et explorer l'influence du codage cible avec et sans validation croisée par intervalle. Tout d'abord, nous allons entraîner un modèle Ridge sur les caractéristiques brutes. Exécutez le code suivant pour entraîner le modèle Ridge :

ridge = Ridge(alpha=1e-6, solver="lsqr", fit_intercept=False)

raw_model = ridge.fit(X_train, y_train)
print("Raw Model score on training set: ", raw_model.score(X_train, y_train))
print("Raw Model score on test set: ", raw_model.score(X_test, y_test))

Entraîner un régresseur Ridge avec validation croisée

Ensuite, nous allons créer un pipeline avec le TargetEncoder et le modèle Ridge. Le pipeline utilise TargetEncoder.fit_transform qui utilise la validation croisée. Exécutez le code suivant pour entraîner le modèle Ridge avec validation croisée :

model_with_cv = make_pipeline(TargetEncoder(random_state=0), ridge)
model_with_cv.fit(X_train, y_train)
print("Model with CV on training set: ", model_with_cv.score(X_train, y_train))
print("Model with CV on test set: ", model_with_cv.score(X_test, y_test))

Évaluer les coefficients du modèle linéaire avec validation croisée

Les coefficients du modèle linéaire montrent que la majeure partie du poids est sur la caractéristique à l'index de colonne 0, qui est la caractéristique informative. Exécutez le code suivant pour évaluer les coefficients du modèle linéaire avec validation croisée :

coefs_cv = pd.Series(
    model_with_cv[-1].coef_, index=model_with_cv[-1].feature_names_in_
).sort_values()
_ = coefs_cv.plot(kind="barh")

Entraîner un régresseur Ridge sans validation croisée

Alors que TargetEncoder.fit_transform utilise la validation croisée par intervalle, TargetEncoder.transform lui-même ne réalise pas de validation croisée. Il utilise l'agrégation de l'ensemble d'entraînement complet pour transformer les caractéristiques catégorielles. Ainsi, nous pouvons utiliser TargetEncoder.fit suivi de TargetEncoder.transform pour désactiver la validation croisée. Cette codification est ensuite passée au modèle Ridge. Exécutez le code suivant pour entraîner le modèle Ridge sans validation croisée :

target_encoder = TargetEncoder(random_state=0)
target_encoder.fit(X_train, y_train)
X_train_no_cv_encoding = target_encoder.transform(X_train)
X_test_no_cv_encoding = target_encoder.transform(X_test)

model_no_cv = ridge.fit(X_train_no_cv_encoding, y_train)
print(
    "Model without CV on training set: ",
    model_no_cv.score(X_train_no_cv_encoding, y_train),
)
print(
    "Model without CV on test set: ", model_no_cv.score(X_test_no_cv_encoding, y_test)
)

Évaluer les coefficients du modèle linéaire sans validation croisée

Le modèle Ridge surapprend car il attribue plus de poids à la caractéristique à cardinalité extrêmement élevée par rapport à la caractéristique informative. Exécutez le code suivant pour évaluer les coefficients du modèle linéaire sans validation croisée :

coefs_no_cv = pd.Series(
    model_no_cv.coef_, index=model_no_cv.feature_names_in_
).sort_values()
_ = coefs_no_cv.plot(kind="barh")

Sommaire

Dans ce laboratoire, nous avons appris à utiliser la classe TargetEncoder de Scikit-learn pour transformer les données catégorielles en données numériques qui peuvent être utilisées en tant qu'entrée pour les algorithmes d'apprentissage automatique. Nous avons également appris l'importance de la validation croisée par intervalle pour prévenir le surapprentissage. Nous avons entraîné un modèle Ridge sur les données brutes et évalué ses performances. Nous avons également entraîné un modèle Ridge avec validation croisée et évalué les coefficients du modèle linéaire. Enfin, nous avons entraîné un modèle Ridge sans validation croisée et évalué les coefficients du modèle linéaire.