Transformación de datos categóricos usando TargetEncoder

Introducción

En este laboratorio, aprenderemos a usar la clase TargetEncoder de la biblioteca Scikit-learn. La codificación de destino es una técnica utilizada para transformar datos categóricos en datos numéricos que se pueden utilizar como entrada para algoritmos de aprendizaje automático. El TargetEncoder reemplaza cada categoría de una característica categórica con la media de la variable objetivo para esa categoría. Este método es útil en casos donde existe una fuerte relación entre la característica categórica y la variable objetivo.

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.

Skills Graph

Instalar las bibliotecas necesarias

Primero, necesitamos instalar las bibliotecas necesarias. Vamos a utilizar las bibliotecas Scikit-learn, Pandas y Matplotlib. Ejecute el siguiente comando para instalar estas bibliotecas:

!pip install scikit-learn pandas matplotlib

Importar las bibliotecas necesarias

A continuación, necesitamos importar las bibliotecas necesarias. Ejecute el siguiente código para importar las bibliotecas necesarias:

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

Crear un conjunto de datos sintético

Para este laboratorio, crearemos un conjunto de datos sintético con tres características categóricas: una característica informativa con cardinalidad media, una característica no informativa con cardinalidad media y una característica no informativa con alta cardinalidad. Usaremos la clase KBinsDiscretizer de Scikit-learn para generar la característica informativa. Ejecute el siguiente código para crear el conjunto de datos sintético:

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)

Entrenar un regresor Ridge en datos sin codificar

En esta sección, entrenaremos un regresor Ridge en el conjunto de datos con y sin codificación y exploraremos la influencia del codificador de destino con y sin validación cruzada por intervalos. Primero, entrenaremos un modelo Ridge en las características sin procesar. Ejecute el siguiente código para entrenar el modelo 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))

Entrenar un regresor Ridge con validación cruzada

A continuación, crearemos un pipeline con el TargetEncoder y el modelo Ridge. El pipeline utiliza TargetEncoder.fit_transform que utiliza validación cruzada. Ejecute el siguiente código para entrenar el modelo Ridge con validación cruzada:

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

Evaluar los coeficientes del modelo lineal con validación cruzada

Los coeficientes del modelo lineal muestran que la mayor parte del peso está en la característica en el índice de columna 0, que es la característica informativa. Ejecute el siguiente código para evaluar los coeficientes del modelo lineal con validación cruzada:

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

Entrenar un regresor Ridge sin validación cruzada

Mientras que TargetEncoder.fit_transform utiliza validación cruzada por intervalos, TargetEncoder.transform en sí mismo no realiza ninguna validación cruzada. Utiliza la agregación del conjunto de entrenamiento completo para transformar las características categóricas. Por lo tanto, podemos usar TargetEncoder.fit seguido de TargetEncoder.transform para deshabilitar la validación cruzada. Esta codificación se pasa luego al modelo Ridge. Ejecute el siguiente código para entrenar el modelo Ridge sin validación cruzada:

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

Evaluar los coeficientes del modelo lineal sin validación cruzada

El modelo Ridge se sobreajusta porque asigna más peso a la característica de cardinalidad extremadamente alta en relación con la característica informativa. Ejecute el siguiente código para evaluar los coeficientes del modelo lineal sin validación cruzada:

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

Resumen

En este laboratorio, aprendimos cómo usar la clase TargetEncoder de Scikit-learn para transformar datos categóricos en datos numéricos que se pueden usar como entrada para algoritmos de aprendizaje automático. También aprendimos la importancia de la validación cruzada por intervalos en la prevención del sobreajuste. Entrenamos un modelo Ridge en los datos brutos y evaluamos su rendimiento. También entrenamos un modelo Ridge con validación cruzada y evaluamos los coeficientes del modelo lineal. Finalmente, entrenamos un modelo Ridge sin validación cruzada y evaluamos los coeficientes del modelo lineal.