Tutorial ScikitLearn: Codificación de variables categóricas

¿Qué es la codificación de variables categóricas a numéricas?

En el ámbito del aprendizaje automático, es común trabajar con datos que contienen variables categóricas. Estas variables representan categorías o etiquetas, como el color de un coche (rojo, azul, verde) o el tipo de mascota (perro, gato, pájaro). Sin embargo, muchos algoritmos de machine learning requieren que los datos sean numéricos para poder procesarlos adecuadamente.

La codificación de variables categóricas a numéricas es el proceso mediante el cual transformamos estas categorías en valores numéricos que los algoritmos pueden interpretar. Sin esta transformación, no podríamos utilizar variables categóricas en modelos como regresiones o redes neuronales, ya que estos modelos no pueden operar directamente con texto o etiquetas categóricas.

Por ejemplo, si intentamos ajustar un modelo de regresión lineal utilizando una variable categórica sin codificar, obtendremos un error:

import pandas as pd
from sklearn.linear_model import LinearRegression

# Datos de ejemplo con variable categórica
data = pd.DataFrame({
    'Color': ['Rojo', 'Verde', 'Azul', 'Rojo', 'Verde'],
    'Precio': [10, 15, 12, 14, 13]
})

X = data[['Color']]
y = data['Precio']

# Intentar ajustar un modelo de regresión lineal
modelo = LinearRegression()

try:
    modelo.fit(X, y)
except ValueError as e:
    print("Error al ajustar el modelo:", e)

Este código generará un ValueError indicando que el modelo no puede manejar variables de tipo objeto o categóricas. Por ello, es necesario convertir la variable "Color" a una representación numérica antes de proceder.

Existen diferentes métodos para realizar esta codificación, cada uno con sus propias ventajas y limitaciones. Algunos de los métodos más comunes son la codificación ordinal, donde se asigna un número entero a cada categoría, y la codificación one-hot, que crea variables binarias (0 o 1) para representar la presencia de una categoría.

Por ejemplo, consideremos nuevamente la variable categórica "Color" con las categorías "Rojo", "Verde" y "Azul". Mediante codificación ordinal, podríamos asignar 1 a "Rojo", 2 a "Verde" y 3 a "Azul". Sin embargo, este método introduce una relación de orden que puede no existir entre las categorías.

Para evitar suposiciones implícitas de orden, podemos utilizar la codificación one-hot. Este método crea nuevas variables binarias para cada categoría. Así, generaríamos tres nuevas variables: "Color_Rojo", "Color_Verde" y "Color_Azul", donde cada variable toma el valor 1 si la instancia pertenece a esa categoría y 0 en caso contrario.

La elección del método de codificación adecuado es crucial, ya que puede afectar al rendimiento del modelo. Algunos algoritmos son sensibles a la representación numérica de las variables, por lo que es importante entender cómo y por qué realizamos la codificación de las variables categóricas.

En Scikit-Learn, existen diversas herramientas para facilitar este proceso. En las próximas secciones, exploraremos cómo utilizar get_dummies() de pandas, OneHotEncoder, LabelEncoder y OrdinalEncoder para transformar variables categóricas a numéricas de manera eficiente y adecuada para nuestros modelos.

Codificación con Pandas get_dummies()

La función get_dummies() de Pandas es una herramienta fundamental para la codificación de variables categóricas. Convierte variables categóricas en una representación numérica mediante la creación de columnas binarias, permitiendo que los algoritmos de machine learning procesen adecuadamente estos datos. Este proceso es conocido como codificación one-hot, donde cada categoría única se transforma en una columna separada con valores 0 o 1.

Por ejemplo, consideremos un conjunto de datos con las columnas "Color", "Tamaño" y "Precio":

import pandas as pd

# Datos de ejemplo
data = pd.DataFrame({
    'Color': ['Rojo', 'Verde', 'Azul', 'Rojo', 'Verde'],
    'Tamaño': ['Grande', 'Pequeño', 'Mediano', 'Grande', 'Mediano'],
    'Precio': [10, 15, 12, 14, 13]
})

Al aplicar get_dummies() a este DataFrame, convertimos las variables categóricas en columnas binarias:

# Aplicar get_dummies()
data_codificada = pd.get_dummies(data)
print(data_codificada)

El resultado es un nuevo DataFrame donde cada categoría única se representa como una columna independiente:

   Precio  Color_Azul  Color_Rojo  Color_Verde  Tamaño_Grande  Tamaño_Mediano  Tamaño_Pequeño
0      10           0           1            0              1               0               0
1      15           0           0            1              0               0               1
2      12           1           0            0              0               1               0
3      14           0           1            0              1               0               0
4      13           0           0            1              0               1               0

Es importante observar que se han generado columnas nuevas como "Color_Azul", "Color_Rojo", "Color_Verde", "Tamaño_Grande", "Tamaño_Mediano" y "Tamaño_Pequeño". Cada fila tiene un 1 en la columna que corresponde a su categoría original y 0 en las demás.

Para evitar la multicolinealidad que puede surgir al incluir todas las categorías, es común utilizar el parámetro drop_first=True. Esto elimina la primera categoría de cada variable, reduciendo la posibilidad de redundancia en los datos:

# Aplicar get_dummies() con drop_first
data_codificada = pd.get_dummies(data, drop_first=True)
print(data_codificada)

El resultado excluye una categoría por variable categórica:

   Precio  Color_Rojo  Color_Verde  Tamaño_Mediano  Tamaño_Pequeño
0      10           1            0               0               0
1      15           0            1               0               1
2      12           0            0               1               0
3      14           1            0               0               0
4      13           0            1               1               0

Otra funcionalidad útil es la capacidad de especificar qué columnas codificar mediante el parámetro columns. Si deseamos codificar únicamente la variable "Color", podemos hacerlo de la siguiente manera:

# Codificar solo la columna "Color"
data_codificada = pd.get_dummies(data, columns=['Color'], drop_first=True)
print(data_codificada)

El DataFrame resultante mantiene la variable "Tamaño" sin codificar:

   Tamaño  Precio  Color_Rojo  Color_Verde
0  Grande      10           1            0
1 Pequeño      15           0            1
2 Mediano      12           0            0
3  Grande      14           1            0
4 Mediano      13           0            1

En situaciones donde existen valores faltantes en las variables categóricas, podemos utilizar el parámetro dummy_na=True para crear una columna adicional que indique la presencia de valores nulos:

# Introducir un valor nulo en "Tamaño"
data.loc[2, 'Tamaño'] = None

# Aplicar get_dummies() incluyendo NaN
data_codificada = pd.get_dummies(data, dummy_na=True)
print(data_codificada)

El resultado incluye columnas para valores nulos, lo que permite gestionar adecuadamente los datos incompletos:

   Precio  Color_Azul  Color_Rojo  Color_Verde  Tamaño_Grande  Tamaño_Mediano  \
0      10           0           1            0              1               0   
1      15           0           0            1              0               0   
2      12           1           0            0              0               0   
3      14           0           1            0              1               0   
4      13           0           0            1              0               1   

   Tamaño_Pequeño  Tamaño_nan  
0               0           0  
1               1           0  
2               0           1  
3               0           0  
4               0           0  

Al trabajar con conjuntos de datos grandes que contienen variables categóricas con muchas categorías únicas, es esencial manejar eficientemente estas variables para evitar la creación de un número excesivo de columnas. Una estrategia común es agrupar las categorías menos frecuentes en una categoría "Otros" antes de aplicar get_dummies(). Esto simplifica el modelo y reduce el riesgo de sobreajuste.

Es importante destacar que get_dummies() es una función de transformación simple y directa, pero no mantiene un registro de las categorías ajustadas en el conjunto de entrenamiento. Por ello, al aplicar la misma transformación al conjunto de prueba, debemos asegurarnos de que las columnas generadas coincidan. Una forma de lograr consistencia es utilizar los parámetros categories y reindex para alinear las columnas entre los conjuntos.

Por ejemplo, al codificar el conjunto de entrenamiento:

# Conjunto de entrenamiento
train_data = data.iloc[:3]

# Codificar el conjunto de entrenamiento
train_encoded = pd.get_dummies(train_data, columns=['Color'], drop_first=True)
train_encoded

Y luego, al codificar el conjunto de prueba, reindexamos para asegurar que las columnas coincidan:

# Conjunto de prueba
test_data = data.iloc[3:]

# Codificar el conjunto de prueba
test_encoded = pd.get_dummies(test_data, columns=['Color'], drop_first=True)

# Reindexar para coincidir con las columnas del conjunto de entrenamiento
test_encoded = test_encoded.reindex(columns=train_encoded.columns, fill_value=0)
test_encoded

De esta manera, garantizamos que ambos conjuntos tengan las mismas columnas, lo cual es esencial para el entrenamiento y la evaluación del modelo.

Aunque get_dummies() es una herramienta eficiente para la codificación básica, en escenarios más complejos es recomendable utilizar el OneHotEncoder de Scikit-Learn. A diferencia de get_dummies(), OneHotEncoder forma parte de la API de Scikit-Learn y puede integrarse fácilmente en pipelines, manteniendo un seguimiento de las categorías aprendidas durante el ajuste del modelo.

Al utilizar get_dummies(), es crucial considerar el impacto en el rendimiento del modelo y en la interpretabilidad de los resultados. Una codificación adecuada de las variables categóricas contribuye significativamente a la eficacia del proceso de preprocesamiento de datos y al éxito de los algoritmos de machine learning aplicados.

Codificación con OneHotEncoder de Scikit Learn

En Scikit Learn, la clase OneHotEncoder es una herramienta esencial para transformar variables categóricas en una representación numérica adecuada para algoritmos de aprendizaje automático. A diferencia de get_dummies() de pandas, OneHotEncoder forma parte de la API de Scikit Learn y se integra perfectamente en pipelines, facilitando el preprocesamiento y evitando problemas comunes al aplicar transformaciones a nuevos datos.

La codificación one-hot crea una columna binaria por cada categoría posible en una variable categórica. Este método es preferible cuando no existe una relación de orden entre las categorías y se desea evitar introducir sesgos en el modelo.

A continuación, se muestra cómo utilizar OneHotEncoder para codificar variables categóricas:

import numpy as np
import pandas as pd
from sklearn.preprocessing import OneHotEncoder

# Datos de ejemplo
data = pd.DataFrame({
    'Color': ['Rojo', 'Verde', 'Azul', 'Rojo', 'Verde'],
    'Tamaño': ['Grande', 'Pequeño', 'Mediano', 'Grande', 'Mediano'],
    'Precio': [10, 15, 12, 14, 13]
})

# Seleccionar las variables categóricas
X_categoricas = data[['Color', 'Tamaño']]

Primero, se instancía OneHotEncoder y se ajusta a los datos categóricos:

# Crear una instancia de OneHotEncoder
encoder = OneHotEncoder(drop='first', sparse_output=False)

# Ajustar y transformar los datos categóricos
X_encoded = encoder.fit_transform(X_categoricas)

En este ejemplo, se establece el parámetro drop='first' para eliminar la primera categoría de cada variable, lo que ayuda a evitar la multicolinealidad. Además, sparse_output=False devuelve un array denso en lugar de una matriz dispersa, facilitando su manipulación.

El resultado de la codificación es:

print(X_encoded)

[[0. 1. 0. 0.]
 [1. 0. 0. 1.]
 [0. 0. 1. 0.]
 [0. 1. 0. 0.]
 [1. 0. 1. 0.]]

Para interpretar las columnas resultantes, es útil obtener los nombres de las características generadas por el codificador:

# Obtener nombres de las nuevas características
nuevas_columnas = encoder.get_feature_names_out(input_features=['Color', 'Tamaño'])
print(nuevas_columnas)

['Color_Rojo' 'Color_Verde' 'Tamaño_Mediano' 'Tamaño_Pequeño']

De esta manera, se puede crear un DataFrame con las nuevas variables codificadas:

# Crear DataFrame con las nuevas variables
X_encoded_df = pd.DataFrame(X_encoded, columns=nuevas_columnas)

# Unir con otras variables numéricas
data_final = pd.concat([data[['Precio']], X_encoded_df], axis=1)
print(data_final)

   Precio  Color_Rojo  Color_Verde  Tamaño_Mediano  Tamaño_Pequeño
0      10         0.0          1.0             0.0             0.0
1      15         1.0          0.0             0.0             1.0
2      12         0.0          0.0             1.0             0.0
3      14         0.0          1.0             0.0             0.0
4      13         1.0          0.0             1.0             0.0

Al utilizar OneHotEncoder dentro de un pipeline, se garantiza que las transformaciones aplicadas durante el entrenamiento se replicarán de manera consistente en los nuevos datos:

from sklearn.compose import ColumnTransformer
from sklearn.pipeline import Pipeline
from sklearn.linear_model import LinearRegression

# Definir columnas numéricas y categóricas
columnas_numericas = ['Precio']
columnas_categoricas = ['Color', 'Tamaño']

# Crear transformador de columnas
preprocesador = ColumnTransformer(
    transformers=[
        ('num', 'passthrough', columnas_numericas),
        ('cat', OneHotEncoder(drop='first'), columnas_categoricas)
    ]
)

# Crear pipeline completo
modelo = Pipeline(steps=[
    ('preprocesador', preprocesador),
    ('regresor', LinearRegression())
], memory = None)

# Separar variables independientes y dependiente
X = data.drop('Precio', axis=1)
y = data['Precio']

# Entrenar el modelo
modelo.fit(X, y)

En este ejemplo, el ColumnTransformer aplica OneHotEncoder sólo a las columnas categóricas, mientras que deja pasar las columnas numéricas sin cambios. Esto permite combinar diferentes tipos de preprocesamiento en un solo paso.

Es importante mencionar que OneHotEncoder maneja de forma nativa los valores desconocidos en datos de prueba utilizando el parámetro handle_unknown. Si se establece en 'ignore', el codificador ignorará las categorías no vistas durante el ajuste:

# Crear instancia con handle_unknown
encoder = OneHotEncoder(drop='first', handle_unknown='ignore', sparse_output=False)

Esto es útil cuando se espera que aparezcan nuevas categorías en los datos futuros.

Además, OneHotEncoder puede trabajar con datos categóricos ya sea como cadenas de texto o como categorías de pandas. Para optimizar el rendimiento, se pueden convertir las variables categóricas a tipo category:

# Convertir a tipo category
data['Color'] = data['Color'].astype('category')
data['Tamaño'] = data['Tamaño'].astype('category')

# Verificar tipos de datos
print(data.dtypes)

Color     category
Tamaño    category
Precio       int64
dtype: object

Al hacerlo, se mejora la eficiencia de almacenamiento y se asegura una mejor compatibilidad con OneHotEncoder.

En casos donde se trabaja con variables categóricas de alta cardinalidad, es decir, con muchas categorías únicas, el uso de OneHotEncoder puede generar un número muy elevado de columnas. Para abordar este problema, se pueden utilizar técnicas de agrupamiento de categorías poco frecuentes o considerar otros codificadores como HashingEncoder.

A partir de la versión 1.3 de Scikit Learn, OneHotEncoder ofrece el parámetro min_frequency para agrupar categorías infrecuentes automáticamente:

# Agrupar categorías con baja frecuencia
encoder = OneHotEncoder(min_frequency=2, handle_unknown='infrequent_if_exist', sparse_output=False)

# Ajustar y transformar
X_encoded = encoder.fit_transform(X_categoricas)
nuevas_columnas = encoder.get_feature_names_out()

En este caso, las categorías que aparecen menos de dos veces se agrupan bajo una nueva categoría denominada infrequent.

Por último, es posible combinar OneHotEncoder con otras técnicas de preprocesamiento mediante el uso de pipelines y transformadores personalizados. Esto permite construir flujos de trabajo más complejos y adaptados a las necesidades específicas de cada proyecto.

La correcta aplicación de OneHotEncoder es fundamental para preparar los datos categóricos de manera eficiente y evitar problemas como el sobrereajuste o la multicolinealidad. Al integrarlo en el flujo de trabajo con Scikit Learn, se logra un proceso de preprocesamiento robusto y reproducible, esencial para el éxito en proyectos de aprendizaje automático.

Codificación con Label Encoding y Ordinal Encoding y en qué se diferencian de OneHotEncoder

En el preprocesamiento de datos, es fundamental transformar las variables categóricas en una representación numérica para que los algoritmos de aprendizaje automático puedan procesarlas. Dos técnicas comunes para lograr esto son el Label Encoding y el Ordinal Encoding, ambas disponibles en Scikit-Learn. Aunque pueden parecer similares, tienen diferencias clave respecto al OneHotEncoder, especialmente en cómo manejan las relaciones entre categorías y su impacto en los modelos.

Label Encoding con LabelEncoder

El LabelEncoder de Scikit-Learn convierte cada categoría de una variable en un número entero único. Esta técnica es útil cuando la variable categórica es nominal y no existe un orden inherente entre las categorías. Sin embargo, el LabelEncoder se aplica normalmente a una sola variable y puede introducir problemas si las categorías codificadas se interpretan erróneamente como numéricamente significativas por el modelo.

Ejemplo de uso de LabelEncoder:

import pandas as pd
from sklearn.preprocessing import LabelEncoder

# Datos de ejemplo
data = pd.DataFrame({
    'Colores': ['Rojo', 'Verde', 'Azul', 'Rojo', 'Azul']
})

# Crear una instancia de LabelEncoder
le = LabelEncoder()

# Ajustar y transformar los datos
data['Colores_encoded'] = le.fit_transform(data['Colores'])

print(data)

Salida:

  Colores  Colores_encoded
0    Rojo                2
1   Verde                1
2    Azul                0
3    Rojo                2
4    Azul                0

En este ejemplo, las categorías 'Rojo', 'Verde' y 'Azul' se han convertido en 2, 1 y 0 respectivamente. Es importante destacar que estos números no implican ninguna relación de orden; son simplemente etiquetas numéricas.

Ordinal Encoding con OrdinalEncoder

El OrdinalEncoder es similar al LabelEncoder pero se utiliza para transformar múltiples variables categóricas simultáneamente y permite asignar un orden específico a las categorías. Es adecuado para variables categóricas ordinales, donde las categorías tienen una relación de orden inherente.

Ejemplo de uso de OrdinalEncoder:

from sklearn.preprocessing import OrdinalEncoder

# Datos de ejemplo con variables ordinales
data = pd.DataFrame({
    'Tamaño': ['Pequeño', 'Mediano', 'Grande', 'Pequeño', 'Grande']
})

# Definir el orden deseado de las categorías
orden_tamaño = ['Pequeño', 'Mediano', 'Grande']

# Crear instancia de OrdinalEncoder con categorías especificadas
oe = OrdinalEncoder(categories=[orden_tamaño])

# Ajustar y transformar los datos
data['Tamaño_encoded'] = oe.fit_transform(data[['Tamaño']])

print(data)

Salida:

     Tamaño  Tamaño_encoded
0   Pequeño             0.0
1   Mediano             1.0
2    Grande             2.0
3   Pequeño             0.0
4    Grande             2.0

Aquí, las categorías se han codificado según el orden especificado: 'Pequeño' como 0, 'Mediano' como 1 y 'Grande' como 2. Esta codificación refleja la relación ordinal entre las categorías.

Diferencias con OneHotEncoder

El OneHotEncoder transforma las variables categóricas en una matriz binaria, creando una columna por cada categoría única, donde cada fila tiene un 1 en la columna de su categoría y 0 en las demás. A diferencia del LabelEncoder y OrdinalEncoder, el OneHotEncoder evita asignar valores numéricos que puedan implicar un orden o una relación matemática entre las categorías.

Comparación:

• LabelEncoder: Asigna un número entero a cada categoría sin considerar ninguna ordenación. Puede llevar a que los modelos interpreten estas etiquetas numéricas como información cuantitativa, lo que es inapropiado para variables nominales.
• OrdinalEncoder: Asigna números enteros a categorías teniendo en cuenta un orden específico. Es útil para variables ordinales pero puede introducir relaciones de magnitud que influyan en el modelo.
• OneHotEncoder: Convierte cada categoría en una nueva columna binaria. Evita introducir relaciones numéricas entre categorías y es adecuado para variables nominales sin orden.

Impacto en los modelos de aprendizaje automático

El uso de LabelEncoder o OrdinalEncoder puede ser problemático en modelos sensibles a los valores numéricos, como los modelos lineales, ya que pueden interpretar las etiquetas numéricas como valores con significado matemático. Esto puede introducir sesgos y afectar negativamente el rendimiento del modelo.

Por ejemplo, si se aplica LabelEncoding a una variable de colores y se asigna Azul=0, Verde=1, Rojo=2, un modelo podría interpretar que Rojo es mayor que Verde, lo cual no tiene sentido en este contexto.

En contraste, el OneHotEncoder evita este problema al crear variables binarias independientes, asegurando que el modelo no suponga ninguna relación de orden o magnitud entre las categorías.

Uso conjunto con ColumnTransformer

En proyectos reales, es común combinar diferentes métodos de codificación dependiendo del tipo de variable categórica. El ColumnTransformer de Scikit-Learn permite aplicar transformaciones específicas a columnas particulares.

Ejemplo de combinación:

from sklearn.compose import ColumnTransformer
from sklearn.preprocessing import OneHotEncoder

# Datos de ejemplo
data = pd.DataFrame({
    'Color': ['Rojo', 'Verde', 'Azul', 'Rojo', 'Azul'],
    'Tamaño': ['Pequeño', 'Mediano', 'Grande', 'Pequeño', 'Mediano'],
    'Precio': [10, 15, 12, 14, 13]
})

# Definir columnas categóricas y numéricas
columnas_categoricas_nominales = ['Color']
columnas_categoricas_ordinales = ['Tamaño']
columnas_numericas = ['Precio']

# Orden para la variable ordinal 'Tamaño'
orden_tamaño = ['Pequeño', 'Mediano', 'Grande']

# Crear el ColumnTransformer
preprocesador = ColumnTransformer(
    transformers=[
        ('ord', OrdinalEncoder(categories=[orden_tamaño]), columnas_categoricas_ordinales),
        ('ohe', OneHotEncoder(drop='first'), columnas_categoricas_nominales)
    ],
    remainder='passthrough'  # Dejar las columnas no especificadas sin cambios
)

# Aplicar transformaciones
datos_transformados = preprocesador.fit_transform(data)

# Obtener nombres de las nuevas columnas
nombres_columnas = (
    columnas_categoricas_ordinales +
    preprocesador.named_transformers_['ohe'].get_feature_names_out(columnas_categoricas_nominales).tolist() +
    columnas_numericas
)

# Crear DataFrame final
data_preprocesada = pd.DataFrame(datos_transformados, columns=nombres_columnas)

print(data_preprocesada)

Salida:

   Tamaño  Color_Rojo  Color_Verde  Precio
0     0.0         1.0          0.0    10.0
1     1.0         0.0          1.0    15.0
2     2.0         0.0          0.0    12.0
3     0.0         1.0          0.0    14.0
4     1.0         0.0          0.0    13.0

En este ejemplo, se ha aplicado OrdinalEncoder a la variable 'Tamaño' siguiendo el orden definido, y OneHotEncoder (con drop='first' para evitar multicolinealidad) a la variable 'Color'. La columna 'Precio' se ha mantenido sin cambios.

Consideraciones al elegir el método de codificación

Al seleccionar el método de codificación adecuado, es esencial considerar el tipo de variable categórica y el algoritmo de aprendizaje que se utilizará:

• Variables nominales (sin orden): Es preferible utilizar OneHotEncoder para evitar la introducción de relaciones numéricas inexistentes.
• Variables ordinales (con orden): OrdinalEncoder permite capturar la relación de orden entre categorías, lo cual puede ser beneficioso para ciertos modelos.
• Modelos basados en árboles: Algoritmos como árboles de decisión o Random Forests pueden manejar etiquetas numéricas sin asumir relaciones lineales, por lo que LabelEncoder o OrdinalEncoder pueden ser adecuados.
• Modelos lineales: Es recomendable usar OneHotEncoder para evitar que el modelo interprete incorrectamente las relaciones entre categorías.

Manejo de valores desconocidos

Tanto LabelEncoder como OrdinalEncoder pueden generar errores si encuentran categorías nuevas en datos de prueba que no fueron vistas durante el entrenamiento. Para manejar esta situación, se pueden utilizar los parámetros handle_unknown='use_encoded_value' y unknown_value en OrdinalEncoder:

# Crear instancia de OrdinalEncoder que maneja valores desconocidos
oe = OrdinalEncoder(handle_unknown='use_encoded_value', unknown_value=-1, categories=[orden_tamaño])

# Ajustar y transformar los datos de entrenamiento
oe.fit(data[['Tamaño']])

# Datos de prueba con una categoría desconocida
datos_nuevos = pd.DataFrame({'Tamaño': ['Extra Grande', 'Pequeño']})

# Transformar los datos de prueba
datos_nuevos['Tamaño_encoded'] = oe.transform(datos_nuevos[['Tamaño']])

print(datos_nuevos)

Salida:

         Tamaño  Tamaño_encoded
0  Extra Grande            -1.0
1       Pequeño             0.0

Aquí, la categoría desconocida 'Extra Grande' se codifica como -1, permitiendo que el modelo identifique valores fuera del conjunto original.

Resumen de las diferencias principales

• LabelEncoder: Útil para codificar una sola variable categórica, asignando etiquetas numéricas sin orden específico. Puede ser problemático para modelos que interpreten los números como valores con significado.
• OrdinalEncoder: Permite codificar múltiples variables categóricas, conservando un orden definido entre las categorías. Es apropiado para variables ordinales.
• OneHotEncoder: Transforma variables categóricas en variables binarias, creando una columna por categoría. Evita introducir relaciones numéricas indebidas y es adecuado para variables nominales.

Ejemplo completo integrando todo

A continuación, se presenta un ejemplo que integra LabelEncoder, OrdinalEncoder y OneHotEncoder en un flujo de trabajo completo:

# Datos de ejemplo con variables mixtas
data = pd.DataFrame({
    'ID': ['A1', 'A2', 'A3', 'A4', 'A5'],
    'Color': ['Rojo', 'Verde', 'Azul', 'Verde', 'Rojo'],
    'Tamaño': ['Pequeño', 'Mediano', 'Grande', 'Grande', 'Pequeño'],
    'Forma': ['Circular', 'Cuadrado', 'Triangular', 'Circular', 'Cuadrado'],
    'Precio': [10, 15, 12, 14, 11]
})

# Codificar la variable 'ID' con LabelEncoder
le = LabelEncoder()
data['ID_encoded'] = le.fit_transform(data['ID'])

# Definir orden para 'Tamaño'
orden_tamaño = ['Pequeño', 'Mediano', 'Grande']

# Crear ColumnTransformer
preprocesador = ColumnTransformer(
    transformers=[
        ('ord', OrdinalEncoder(categories=[orden_tamaño]), ['Tamaño']),
        ('ohe', OneHotEncoder(drop='first'), ['Color', 'Forma'])
    ],
    remainder='passthrough'
)

# Aplicar transformaciones
datos_transformados = preprocesador.fit_transform(data)

# Obtener nombres de las columnas
nombres_ohe = preprocesador.named_transformers_['ohe'].get_feature_names_out(['Color', 'Forma']).tolist()
nombres_totales = ['Tamaño'] + nombres_ohe + ['ID_encoded', 'Precio']

# Crear DataFrame final
data_procesada = pd.DataFrame(datos_transformados, columns=nombres_totales)

print(data_procesada)

Salida:

   Tamaño  Color_Rojo  Color_Verde  Forma_Cuadrado  Forma_Triangular  \
0     0.0         1.0          0.0             0.0               0.0   
1     1.0         0.0          1.0             1.0               0.0   
2     2.0         0.0          0.0             0.0               1.0   
3     2.0         0.0          1.0             0.0               0.0   
4     0.0         1.0          0.0             1.0               0.0   

   ID_encoded  Precio  
0         0.0    10.0  
1         1.0    15.0  
2         2.0    12.0  
3         3.0    14.0  
4         4.0    11.0  

Aquí se ha utilizado LabelEncoder para la variable 'ID', OrdinalEncoder para 'Tamaño' y OneHotEncoder para 'Color' y 'Forma'. Este enfoque híbrido permite aprovechar las ventajas de cada método de codificación según las características de cada variable.