Tratamiento de variables categóricas para imputación: codificación ordinal

Clase 6 de 17 • Curso de Manejo de Datos Faltantes: Imputación

Contenido del curso

Problemática de valores faltantes

Imputación basada en el donante

Imputación basada en modelos

Conclusión

Tomar examen

Comentarios

Miguel Ángel Acosta Rocha

student•

Siento que estas clases han sido full técnicas y cargadas... nada fácil

Luis Cerén

student•

Hace falta un cursito previo de janitor

Eugenio Schiavoni

student•

Es verdad eso, pero explican muchas cosas muy útiles que cuando uno no las sabe pierde mucho tiempo programando algo que ya existe y lo hace mejor que uno ! Hay que ir con calma, tener buenas bases en estadística, probabilidad y cálculo en general, y lo mas importante practicar mucho!!

Carlos Mazzaroli

student•

me hubiera servido la codificación ordinal en el curso de EDA 🐠

Jeinfferson Bernal G

student•

Tratamiento de Variables categoricas para imputacion: Codificacion Ordinal

La mayor parte de las variables categoricas son cadenas de textos y por tanto realizar operaciones con ellas no es trivial. Es asi como surge la necesidad de convertir o codificar las cadenas de texto a numeros de manera que los algoritmos puedan entenderlos o asociarlos

Codificacion Ordinal

Consiste en mapear cada elemento unico de texto a un numero entero. Una vez realizada la codificacion podemos comenzar el proceso de imputacion introduciendo los datos a un algoritmo de imputacion

Alfonso Andres Zapata Guzman

student•

from sklearn import preprocessing

nhanes_transformed_df_aazg = nhanes_df.copy(deep=True)

label_encoder = preprocessing.LabelEncoder()

encoder_gender = label_encoder.fit_transform(nhanes_transformed_df_aazg.gender)
nhanes_transformed_df_aazg.gender = encoder_gender

nhanes_transformed_df_aazg.head()

Alfonso Andres Zapata Guzman

student•

En cuanto a las diferencias OrdinalEncoder y la LabelEncoder implementación , la respuesta aceptada menciona la forma de los datos:

OrdinalEncoder es para datos 2D con la forma(n_samples, n_features) LabelEncoder es para datos 1D con la forma(n_samples,)

Esteban Navarro Díaz

student•

Hay que actualizar el código para el método get_features_names_out(). No aparece en la versión más reciente de sklearn.

Andres Sanchez

student•

6. Tratamiento de variables categóricas para imputación: codificación ordinal

La mayor parte de las variables categóricas son cadenas de texto.
Realizar operaciones con cadenas de texto NO es trivial.
Surge la necesidad de convertir o codificar las cadenas de texto a números.

Codificación ordinal

Asignarle un valor numérico a cada categoría
Siempre antes de encodear hacerle una copia al df

nhanes_transformed_df = (
    pd.DataFrame(
        categorical_tranformer.fit_transform(nhanes_df),
        columns=categorical_tranformer.get_feature_names_out(),
        index = nhanes_df.index
    )
    .rename_columns(
        function = lambda x: x.removeprefix('ordinalencoder__')
    )
        .rename_columns(
        function = lambda x: x.removeprefix('remainder__'))
) # Apply categorical transformer to the data
nhanes_transformed_df.head()

Pablo Alejandro Figueroa

student•

genial, gracias!

Jeinfferson Bernal G

student•

Aplicando la Codificacion Oordinal a todas las Variables de NHANES

Obtener las variables de tipo objeto y category

nhanes_df.select_dtypes(include=[object, 'category'])

Obtener solo los nombres de las variables con valores de tipo object y category y guardarlos

categorical_columns = nhanes_df.select_dtypes(include=[object, 'category']).columns

categorical_columns

--> Index(['general_health_condition', 'gender'], dtype='object')

Utiliza una funcion de sklearn para componer instrucciones de transformacion para los datos y guarda las transformaciones.

categorical_transformer = sklearn.compose.make_column_transformer(
    #   transformador                         variables a transformar
    (sklearn.preprocessing.OrdinalEncoder(), categorical_columns),
    remainder='passthrough' # permite omitir las demas variables para que no las transforme
)

categorical_transformer

Crea un nuevo dataframe con los datos transformados.

(
    pd.DataFrame(
        categorical_transformer.fit_transform(nhanes_df)
    )
)

Agrega los nombres de las variables nuevamente

nhanes_transformed_df = (
    pd.DataFrame(
        categorical_transformer.fit_transform(nhanes_df),
        columns=categorical_transformer.get_feature_names_out(),
        index=nhanes_df.index   # vuelve a los indices del dataframe original
    )
    .rename_columns(
        function = lambda x: x.removeprefix('ordinalencoder__')
    )
    .rename_columns(
        function = lambda x: x.removeprefix('remainder__')
    )
)

nhanes_transformed_df

Sergio Véliz

student•

Con el siguiente código pueden obtener las clases de sus variables categóricas del DataFrame que se generó en el minuto 13:30

# Obtener el transformer
print('Transformers: ', categorical_transformer.transformers_, end='\n\n\n')

# Del transformer obtener las categorías y significados de los numeros generados
print('Categorias o clases: ', categorical_transformer.transformers_[0][1].categories_)

Pablo Alejandro Figueroa

student•

gracias..!

Jeinfferson Bernal G

student•

Ejemplo de Codificacion Ordinal mediante una Lista

Dado un conjunto de datos con dos caracteristicas, encontraremos los valores unicos por caracteristica y los transformaremos utilizando una codificacion ordinal

X = [['Male'], ['Female'], ['Female']]
X

--> [['Male'], ['Female'], ['Female']]

Creamos un encoder para agrupar la informacion y codificarla

encoder = sklearn.preprocessing.OrdinalEncoder()

Codificamos la lista anterior

encoder.fit_transform(X)

--> array([[1.],
	       [0.],
	       [0.]])

El hombre quedo con la codificacion 1 y la mujer con 0. Para cuando hay muchas categorias utilizamos el metodos categories_

encoder.categories_

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

Calcular la inversa de la transformacion de manera que si hay un 1 aparezca un hombre y si hay un 0 aparezca una mujer

encoder.inverse_transform([[1],[1],[0]])

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

Roberth Mafla

student•

Siento que hay un error cuando explica la codificación ordinal, la codificación ordinal se utilizan cuando las categorías siguen un orden, por ejemplo una calificación que sea, bajo, medio, alto. De lo contrario en el caso de los animales es nominal.

Mario Alexander Vargas Celis

student•

El tratamiento de variables categóricas para imputación es un paso importante en la limpieza de datos, ya que la mayoría de los métodos de imputación (como la media, la mediana o incluso modelos más avanzados como KNN o regresiones) requieren que las variables categóricas estén codificadas numéricamente.

La **codificación ordinal** es una técnica que convierte las categorías en números de manera que las categorías tengan un orden lógico, pero sin implicar una relación de magnitud precisa entre las categorías.

### ¿Qué es la codificación ordinal?

La **codificación ordinal** se utiliza cuando las categorías de una variable tienen un orden inherente. Un ejemplo común es una variable de satisfacción con las opciones: "Bajo", "Medio", "Alto". El orden es claro, y se puede representar con números como 1, 2, y 3, donde 1 representa "Bajo" y 3 representa "Alto".

Este tipo de codificación es ideal para variables categóricas ordinales, en las que las categorías pueden ordenarse de manera lógica.

### Pasos para la imputación con codificación ordinal:

1. **Identificación de las variables ordinales**: Primero, debes identificar las variables categóricas que tienen un orden lógico entre sus categorías. Por ejemplo:

- Nivel educativo (Primaria, Secundaria, Universitaria).

- Tamaño de una empresa (Pequeña, Mediana, Grande).

2. **Codificación ordinal**: Convertir las categorías en valores numéricos que respeten el orden inherente. Para hacer esto, puedes usar la función OrdinalEncoder de sklearn o codificar manualmente.

```python

from sklearn.preprocessing import OrdinalEncoder

import pandas as pd

# Ejemplo de datos categóricos

data = {'Nivel_Educativo': ['Primaria', 'Secundaria', 'Universitaria', None]}

df = pd.DataFrame(data)

# Definir el orden de las categorías

encoder = OrdinalEncoder(categories=[['Primaria', 'Secundaria', 'Universitaria']])

# Codificar

df['Nivel_Educativo_Cod'] = encoder.fit_transform(df[['Nivel_Educativo']])

print(df)

```

Salida:

```

Nivel_Educativo Nivel_Educativo_Cod

0 Primaria 0.0

1 Secundaria 1.0

2 Universitaria 2.0

3 None NaN

```

3. **Imputación**: Una vez que la variable ha sido codificada ordinalmente, puedes aplicar métodos de imputación estándar. Por ejemplo, imputar los valores faltantes utilizando la media o mediana en lugar de dejar los valores como NaN.

```python

from sklearn.impute import SimpleImputer

# Imputar la mediana en los valores faltantes

imputer = SimpleImputer(strategy='median')

df['Nivel_Educativo_Imputado'] = imputer.fit_transform(df[['Nivel_Educativo_Cod']])

print(df)

```

Salida:

```

Nivel_Educativo Nivel_Educativo_Cod Nivel_Educativo_Imputado

0 Primaria 0.0 0.0

1 Secundaria 1.0 1.0

2 Universitaria 2.0 2.0

3 None NaN 1.0

```

En este caso, el valor faltante se ha reemplazado por la mediana.

### Beneficios de la codificación ordinal

1. **Imputación más precisa**: Al conservar el orden inherente de las categorías, la imputación de los valores faltantes será más precisa, ya que métodos como la media o la mediana pueden mantener la lógica de las relaciones entre las categorías.

2. **Modelos más robustos**: Los modelos de Machine Learning y las técnicas estadísticas suelen funcionar mejor con datos numéricos, y la codificación ordinal facilita el uso de estos modelos para variables categóricas.

3. **Evita la codificación arbitraria**: En lugar de usar números sin sentido o hacer una codificación "one-hot" que puede introducir complejidad innecesaria, la codificación ordinal refleja el orden real de las categorías.

### Cuándo no usar codificación ordinal

No todas las variables categóricas deben ser codificadas ordinalmente. **Solo** debes aplicar esta técnica si las categorías tienen un **orden lógico**. Si las categorías no tienen un orden, deberías usar otras técnicas como la **codificación "one-hot"** o **frecuencial**.

### Conclusión

La codificación ordinal es una técnica efectiva cuando necesitas imputar valores faltantes en variables categóricas con un orden implícito. La clave es respetar el orden de las categorías, para luego poder aplicar métodos de imputación y análisis que te proporcionen resultados precisos y consistentes.

Mauricio Escobar

student•

alternativa para el buen janitor:

Por medio de una función anónima (lambda) haremos un split, tomando como referencia al "__" quedándonos con la segunda parte[1] de dicho split.

Ejemplo: prefijo_nombre (nos quedamos con "nombre")

#(5) df con cols transformadas
df_transformed = pd.DataFrame(data= transformed_data,
                              columns = categorical_transformer_ord.get_feature_names_out(),
                              index= df_nh_copy.index)

#(6) extraer el prefijo de las columnas: "ordinalencoder__" y "remainder__"
df_transformed = df_transformed.rename(columns= lambda x: x.split('__')[1] if '__' in x else x)

Miguel Carvajal

student•

Le cambió la voz?

José Alejandro Montes Juarez

student•

Considero que el maestro si va un poco rapido, pero tambien hay que entender que para este punto ya debemos saber las bases que estan en otros cursos. A mi se me dificulto mucho la clase anterior y esta pero justo el curso que menciono en la anterior, no lo he cursado

Alejandro Senger

student•

No me pude volver a concentrar en el video hasta que busque imagenes de la Turritopsis nutricola jajajaja

Antonio Demarco Bonino

student•

No tiene nada que ver con el curso pero si son curiosos como yo acá les dejo lo que es una "Turritopsis nutricula": 'es una especie de hidrozoo hidroideo de la familia Oceanidae con un ciclo de vida en el que se revierte a pólipo después de llegar a su maduración sexual. Es uno de los casos conocidos de metazoo capaz de revertir su edad adulta a una edad sexualmente inmadura de forma individual. Otros animales biológicamente inmortales incluyen la medusa Laodicea undulata y Aurelia, así como la medusa del mismo género Turritopsis dohrnii. Es capaz de realizarlo a través de un proceso celular de transdiferenciación. Teóricamente, este ciclo puede repetirse indefinidamente, presentándose como biológicamente inmortal.'

Es una especie de medusa, de esas que capturaba Bob Esponja.

Nixon Rolando García Ramírez

student•

Y otra cosa, segun la documentacion de skearn, ya el comando

encoder = sklearn.preprocessing.OrdinalEncoder()

no funciona para eso lo que se debe realizar es

from sklearn import preprocessing

encoder = preprocessing.OrdinalEncoder()

Eso es lo que dice la documentacion, y a mi me funciono asi, ya si a alguien le funciona de la primera forma no hay problema.

Pueden buscar Skearn 6.3. Preprocesamiento de datos

Pablo Alejandro Figueroa

student•

gracias!

Nixon Rolando García Ramírez

student•

Algo curioso que me paso al momento de importar la libreria sklearn , es que me salia que no me aparecia, no se ejecutaba nada, cuando entre a la documentacion de sklearn , me entere que primero tenian que:

use

pip3 install scikit-learn

en lugar de

pip3 install sklearn

reemplace sklearn por scikit-learn en sus archivos de requisitos de pip (requirements.txt, setup.cfg, Pipfile, etc...) si una de sus dependencias usa el paquete sklearn, sería genial si se toma un tiempo para rastrear qué paquete usa sklearn en lugar de scikit-learn e informarlo a su rastreador de problemas.

Ya despues uno puede importar sklern de forma normal y con el mismo nombre

import sklearn

Lo comento pr si alguien esta siguiendo el ejercicio en otra aplicacion diferente a DeepNote.

Pablo Alejandro Figueroa

student•

gracias--!

Darrien Sequera

student•

Es importante acotar que para el mejor aprovechamiento del curso, hay que tener las bases de sklearn, lo cual no está en los requisitos del curso.

Eugenio Schiavoni

student•

Estaba haciendo un algoritmo justamente para hacer esto, estaba seguro que ya existía, que bien Platzi y que bien Sklearn!!

from sklearn import preprocessing

nhanes_transformed_df_aazg = nhanes_df.copy(deep=True)

label_encoder = preprocessing.LabelEncoder()

encoder_gender = label_encoder.fit_transform(nhanes_transformed_df_aazg.gender)
nhanes_transformed_df_aazg.gender = encoder_gender

nhanes_transformed_df_aazg.head()

nhanes_transformed_df = (
    pd.DataFrame(
        categorical_tranformer.fit_transform(nhanes_df),
        columns=categorical_tranformer.get_feature_names_out(),
        index = nhanes_df.index
    )
    .rename_columns(
        function = lambda x: x.removeprefix('ordinalencoder__')
    )
        .rename_columns(
        function = lambda x: x.removeprefix('remainder__'))
) # Apply categorical transformer to the data
nhanes_transformed_df.head()

categorical_transformer = sklearn.compose.make_column_transformer(
    #   transformador                         variables a transformar
    (sklearn.preprocessing.OrdinalEncoder(), categorical_columns),
    remainder='passthrough' # permite omitir las demas variables para que no las transforme
)

categorical_transformer

nhanes_transformed_df = (
    pd.DataFrame(
        categorical_transformer.fit_transform(nhanes_df),
        columns=categorical_transformer.get_feature_names_out(),
        index=nhanes_df.index   # vuelve a los indices del dataframe original
    )
    .rename_columns(
        function = lambda x: x.removeprefix('ordinalencoder__')
    )
    .rename_columns(
        function = lambda x: x.removeprefix('remainder__')
    )
)

nhanes_transformed_df

# Obtener el transformer
print('Transformers: ', categorical_transformer.transformers_, end='\n\n\n')

# Del transformer obtener las categorías y significados de los numeros generados
print('Categorias o clases: ', categorical_transformer.transformers_[0][1].categories_)

#(5) df con cols transformadas
df_transformed = pd.DataFrame(data= transformed_data,
                              columns = categorical_transformer_ord.get_feature_names_out(),
                              index= df_nh_copy.index)

#(6) extraer el prefijo de las columnas: "ordinalencoder__" y "remainder__"
df_transformed = df_transformed.rename(columns= lambda x: x.split('__')[1] if '__' in x else x)

Tratamiento de variables categóricas para imputación: codificación ordinal

Problemática de valores faltantes

El problema de trabajar con valores faltantes

Proceso de análisis y limpieza de datos

Visualizar y eliminar valores faltantes

Implicaciones de los distintos tipos de valores faltantes

Amplía tu conjunto de herramientas para explorar valores faltantes