Siento que estas clases han sido full técnicas y cargadas… nada fácil
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
Tratamiento de variables categóricas para imputación: codificación ordinal
Tratamiento de variables categóricas para imputación: one-hot encoding
Métodos de imputación de valores faltantes
Imputación basada en el donante
Imputación por media, mediana y moda
Imputación por llenado hacia atrás y hacia adelante
Imputación por interpolación
Imputación por KNN
Imputación por KNN en Python
Imputación basada en modelos
Introducción a la imputación basada en modelos
Imputaciones Múltiples por Ecuaciones Encadenadas (MICE)
Conclusión
Transformación inversa de los datos
¿Cómo continuar practicando?
No tienes acceso a esta clase
¡Continúa aprendiendo! Únete y comienza a potenciar tu carrera
Si ya tienes una cuenta,
Tratamiento de variables categóricas para imputación: codificación ordinal
6/17Recursos
Aportes 17
Preguntas 1
Ordenar por:
me hubiera servido la codificación ordinal en el curso de EDA 🐠
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
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()
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()
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
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_)
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)
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.
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")
```python
#(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)
```
Le cambió la voz?
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.
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.
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
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.
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.
Estaba haciendo un algoritmo justamente para hacer esto, estaba seguro que ya existía, que bien Platzi y que bien Sklearn!!
¿Quieres ver más aportes, preguntas y respuestas de la comunidad?