Tratamiento de variables categóricas para imputación: one-hot encoding

7. Tratamiento de variables categóricas para imputación: one-hot encoding

5-10-20 categorias → Ordinal encoding

100-1000-2000-3000 categorias → One Hot Encoding

1. Ordinal Encoder:
   El OrdinalEncoder se utiliza cuando existe un orden o jerarquía natural entre las categorías de una variable categórica. Esto significa que las categorías tienen una relación de orden y se pueden asignar valores numéricos que reflejen este orden. Algunos ejemplos de variables categóricas donde se puede aplicar el OrdinalEncoder son:
   • Niveles de educación: como “Primaria”, “Secundaria”, “Universidad”, donde hay un orden lógico de menor a mayor nivel educativo.
   • Evaluaciones de rendimiento: como “Bajo”, “Medio”, “Alto”, donde hay una escala ordinal de bajo a alto rendimiento.
2. One-Hot Encoder:
   El OneHotEncoder se utiliza cuando no existe un orden o jerarquía natural entre las categorías de una variable categórica, y se desea crear variables binarias para cada categoría. Esto permite representar cada categoría como una columna independiente, donde un valor de 1 indica la presencia de esa categoría y un valor de 0 indica la ausencia. Algunos ejemplos de variables categóricas donde se puede aplicar el OneHotEncoder son:
   • Colores: como “Rojo”, “Verde”, “Azul”, donde cada color se representa como una columna separada en el conjunto de datos codificado en caliente.
   • Países: como “Estados Unidos”, “Canadá”, “México”, donde cada país se representa como una columna separada indicando su presencia o ausencia.

One - Hot Encoding

Consiste en crear una matriz de unos y ceros donde el 1 representa la presencia de una caracteristica o categoria de la variable de interes y 0 la ausencia de la misma. La lista se convierte en un formato ancho de manera que cada columna representa un elemento unico de nuesta categoria.

Existen dos metodos para generar un one hot encoding: pandas.get_dummies() y sklearn.preprocessing.OneHotEncoder()

Metodo con Sklearn

• Creamos el transformador

#              funcion para construir los transformadores requeridos
transformer = sklearn.compose.make_column_transformer(
    # transformacion ordinal                  variable categorica
    (sklearn.preprocessing.OrdinalEncoder(), ['gender']),
    # transformacion one hot                  variable categorica
    (sklearn.preprocessing.OneHotEncoder(), ['general_health_condition']),
    remainder='passthrough' # omision de la transformacion de las demas variables
)

• Dataframe con los valores transformados

nhanes_transformed_df2 = (
    pd.DataFrame(
        transformer.fit_transform(nhanes_df),
        columns=transformer.get_feature_names_out(),
        index=nhanes_df.index   # indices del dataframe original
    )
    .rename_columns(
        function = lambda x: x.removeprefix('ordinalencoder__')
    )
    .rename_columns(
        function = lambda x: x.removeprefix('remainder__')
    )
    .rename_columns(
       function = lambda x: x.removeprefix('onehotencoder__')
    )
)

nhanes_transformed_df2

• Acceder a las categorias de health

(
    transformer
    .named_transformers_
    .get('onehotencoder')
    .categories_
)

--> [array(['Excellent', 'Fair or', 'Good', 'Poor?', 'Very good', nan],
       dtype=object)]

• Extraer solo una categoria

# Para este caso extraer Good

(
    transformer
    .named_transformers_
    .get('onehotencoder')
    .inverse_transform(
        X = [[0,0,1,0,0,0]]     # vector que representa la categoria Good
    )
)

--> array([['Good']], dtype=object)

¿Cuál método debería de utilizar?

Depende mucho del contexto en el que nos encontremos trabajando:

• Si tengo 5, 10 o más categorías, quizá un Ordinal Encoding sería la opción, en la que establecemos un número para cada una de ellas.
• Si tengo 100 o más categorías, quizá un OneHot Encoding sería una mejor opción, porque voy a tener una categoría por cada columna. Cada una va a tener 1 y 0, entonces el peso de estas variables va a ser el mismo. El inconveniente en este caso es que vas a necesitar crear una nueva columna para cada instancia de tu variable, por lo que requerirás mucho espacio. Esto se puede solventar utilizando matrices especiales matrices sparse.

Dependiendo de tus recursos y métodos que utilices puede ser viable o no.

skelearn.preprocessing.OneHotEncoder()

Requiere:

1. Crear el transformador

2. Aplicar el transformador al conjunto de datos (recrear el conjunto de datos)

Las ventajas:

1. Se puede obtener un array con las categorías que hayan sido codificadas.

2. Es posible recuperar un array con las inversas de las transformaciones realizadas.

Metodo con Pandas

# Metodo de Pandas

(
    nhanes_transformed_df2  # dataframe
    .select_columns('general_health_condition') # variable categorica
    .pipe(pd.get_dummies) 
)

• El problema con el metodo Pandas

(
    nhanes_transformed_df2  # dataframe
    .select_columns('general_health_condition') # variable categorica
    .head(10)
    .pipe(pd.get_dummies) 
)

Al considerar solo las primeras 10 observaciones no toma en cuenta las demas categorias, solo las que estan contenidas en las primeras 10. Por otro lado, no considera una columna para los valores faltantes. Es util para representar los datos de manera rapida pero para fines practicos donde se requiera operaciones, inversas o entrenar un modelo con unas mismas dimensiones no funciona

El tratamiento de variables categóricas mediante \*\*One-Hot Encoding\*\* es una técnica común en el preprocesamiento de datos. Convierte las variables categóricas en varias columnas binarias, donde cada columna representa una categoría única, asignando un valor de `1` cuando la categoría está presente y `0` cuando no lo está. Este método evita el problema de orden implícito que puede ocurrir al usar codificación ordinal en variables categóricas sin una jerarquía natural. \### Proceso de One-Hot Encoding 1\. \*\*Selecciona las variables categóricas\*\* que deseas codificar. 2\. \*\*Aplica One-Hot Encoding\*\* para convertirlas en columnas binarias. 3\. \*\*Asegúrate de que el resto de las columnas no categóricas\*\* (si existen) pasen sin modificaciones o se procesen adecuadamente. \### Ejemplo en Python usando `pandas` y `sklearn` \#### Paso 1: Importar bibliotecas ```python import pandas as pd from sklearn.compose import ColumnTransformer from sklearn.preprocessing import OneHotEncoder ``` \#### Paso 2: Crear un conjunto de datos de ejemplo ```python \# Crear un DataFrame con una variable categórica data = { 'gender': \['Male', 'Female', 'Female', 'Male'], 'age': \[23, 45, 31, 22], 'income': \[50000, 60000, 65000, 45000] } df = pd.DataFrame(data) ``` \#### Paso 3: Aplicar One-Hot Encoding a la variable categórica ```python \# Definir la transformación con OneHotEncoder categorical\_transformer = ColumnTransformer( transformers=\[ ('cat', OneHotEncoder(), \['gender']) # Aplicar One-Hot Encoding a la columna 'gender' ], remainder='passthrough' # El resto de las columnas permanecen sin cambios ) \# Transformar el DataFrame transformed\_df = pd.DataFrame(categorical\_transformer.fit\_transform(df)) \# Cambiar los nombres de las columnas para que sean más comprensibles transformed\_df.columns = \['gender\_Female', 'gender\_Male', 'age', 'income'] print(transformed\_df) ``` \### Salida esperada: | gender\_Female | gender\_Male | age | income | |:-------------:|:-----------:|:---:|:------:| | 0 | 1 | 23 | 50000 | | 1 | 0 | 45 | 60000 | | 1 | 0 | 31 | 65000 | | 0 | 1 | 22 | 45000 | \### Consideraciones adicionales: \- \*\*One-Hot Encoding\*\* es particularmente útil cuando no existe una relación de orden entre las categorías. \- Si tienes muchas categorías, este método puede aumentar significativamente el número de columnas, lo cual es algo a tener en cuenta al trabajar con grandes volúmenes de datos.

Aqui les dejo unas clases de Platzi en donde se habla del procesamiento de variables categoricas (como el One Hot)

• Pipeline de procesamiento de datos para variables categoricas

• Procesamiento para variables categóricas con Python
  

pandas.get_dummies()

Tiene dos limitaciones:

1. Si se selecciona un numero determinado de columnas donde no aparezcan algunos valores, entonces la matriz o tabla ancha tampoco va a tener esos valores (utilizaría menos información de la disponible en el df original).
2. No hay una columna que indique si hay valores faltantes en la variable, porque resultan enmascarados por los ceros de la matriz o tabla ancha.

En conclusión: para fines prácticos de análisis de datos: por ejemplo, hacer operaciones, hacer inversas o entrenar un modelo, no es una opción para hacer la codificación (encoding) de variables categóricas.

Muy buena esta clase!!!