Imputación por llenado hacia atrás y hacia adelante

Clase 10 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

Carlos Mazzaroli

student•

Le embocamos un apply y listo el polio

(
    nhanes_df
    .select_columns("height", "weight", "gender", "diabetes", "general_health_condition")
    .sort_values(
        by=['gender','diabetes','general_health_condition','weight'],
        ascending=True
    )
    .groupby(["gender", "general_health_condition"], dropna=False)
    .apply(lambda x: x.ffill())
)

Julián Cárdenas

student•

NICEE

Jeinfferson Bernal G

student•

2. Imputacion por llenado hacia atras y hacia adelante (Hot Deck y Cold Deck)

Consiste en sustituir los valores faltantes con valores completos que estan antes o despues.

Ventajas

Rapido y facil de implementar
Los datos imputados no son constantes, van a depender de los valores alrededor (arriba, abajo, a la derecha o a la izquierda).
Existen trucos para evitar romper las relaciones entre variables.

Desventajas

Las relaciones multivariables pueden ser distorsionadas

Jeinfferson Bernal G

student•

Imputacion dentro de Dominios

Para que la imputacion tenga mas sentido debemos considerar las variables categoricas. Podemos tratar las variables categoricas como dominios donde nuestra variable de interes toma solo valores dentro del mismo. Es decir, en cada categoria puede existir un rango distinto de valores para la variable de interes. Por lo tanto, haciendo imputaciones dentro de los dominios puedes conservar la estructura de los datos y las relaciones entre las variables.

Ejemplo de imputacion dentro de dominios

Para este caso, la variable a la que se va a imputar los datos faltantes es a weight

(
    nhanes_df
    # seleccionamos las variables. Hay dos categoricas y tres numericas
    .select_columns('weight', 'height', 'gender', 'diabetes', 'general_health_condition')
    # ordenamos los grupos segun nuestro interes 
    # para este caso, primero el genero, seguido de diabetes, su estado de salud y finalmente la altura
    .sort_values(
        by = ['gender', 'diabetes', 'general_health_condition', 'height'],
        ascending = True
    )# realizamos la imputacion con el metodo transform
    .transform_column(
        'weight',   # variable de interes
        lambda x: x.ffill(),    # imputacion hacia adelante
        elementwise = False     # pasa una serie y no un unico valor
    )
)

De esta manera estamos garantizando que la imputacion esta tomando valores adecuados para cada dominio. Sin embargo, puede ocurrir que al traerse el valor antecesor se obtenga un valor de otro dominio generando ruido en los datos. Para ello se utiliza la funcion groupby lo cual permite agrupar los datos por las variables categoricas y luego ordenarlos por las variables numericas para asi realizar la imputacion y evitar este problema.

David Duque Uribe

student•

Muy útil la recomendación a la hora de hacer la imputación hacia adelante organizar por datos o grupos similares, de esta manera los datos reemplazados se parecen a sus semejantes.

Neicer Vásquez

student•

Aporto a tu comentario con la imagen que hice.

Bryan Castano

student•

Hey Chicos, Muchas Gracias, vuestra comentario y graficas me han aclarado muy bien el tema, ahora l oeitneod y tiene mucho sientido estadistico la agrupacion, es genial cuando te enteras de la verdad detras de lso metodos pd.

José Rodrigo Arana Hi

student•

Un "dominio" se refiere a un grupo específico de observaciones dentro de tus datos que comparten ciertas características o propiedades en común. Estas características pueden ser variables categóricas o cualquier otro criterio que defina una agrupación lógica de datos.

Jeinfferson Bernal G

student•

Ejemplo de Imputacion por llenado hacia atras

(
    nhanes_df   # dataframe
    .select_columns('height', 'weight') # variables numericas
    .fillna(method = 'bfill')
)

Metodo alternativo con Pandas. Llenado hacia atras

# metodo alternativo de Pandas. Llenado hacia atras

(
    nhanes_df                           # dataframe
    .select_columns('height', 'weight') # variables numericas
    #.fillna(method = 'bfill')
    .bfill()                            # metodos de Pandas
)

Jeinfferson Bernal G

student•

Ejemplo de Imputacion por llenado hacia adelante

# los valores faltantes se sustituyen por el valor antecesor

(
    nhanes_df   # dataframe
    .select_columns('height', 'weight') # variables numericas
    .fillna(method = 'ffill')
)

Metodo alternativo con Pandas. Llenado hacia adelante

(
    nhanes_df                           # dataframe
    .select_columns('height', 'weight') # variables numericas
    #.fillna(method = 'ffill')
    .ffill()                            # metodos de Pandas
)

Pablo Alejandro Figueroa

student•

Imputación por llenado hacia atrás y hacia adelante

Definición:

La imputación por llenado hacia atrás y hacia adelante, también conocida como Hot Deck y Cold Deck, es un método simple para imputar valores faltantes en una serie de datos. Consiste en reemplazar los valores faltantes con valores completos que se encuentran antes o después dentro de la misma columna.

Tipos de Imputación por llenado:

Imputación por llenado hacia atrás (Hot Deck): Se reemplaza el valor faltante por el valor completo más cercano que se encuentra antes de él en la misma columna.
Imputación por llenado hacia adelante (Cold Deck): Se reemplaza el valor faltante por el valor completo más cercano que se encuentra después de él en la misma columna.

Ventajas:

Simple y rápido de implementar.
Preserva la distribución original de la variable.
No requiere entrenamiento de modelos.

Desventajas:

Puede introducir sesgo en los datos si los valores no se distribuyen uniformemente.
No tiene en cuenta las relaciones entre variables.
Puede ser impreciso para series de datos con patrones complejos.

Cuándo usar la imputación por llenado:

Cuando el conjunto de datos tiene una pequeña cantidad de valores faltantes.
Cuando la distribución de la variable es uniforme.
Cuando se requiere un método simple y rápido de imputación.

Alternativas a la imputación por llenado:

Imputación por media, mediana o moda: Reemplaza el valor faltante por la media, mediana o moda de la variable.
Imputación por regresión: Se utiliza un modelo de regresión para predecir el valor faltante.
Imputación por MICE (Multiple Imputation by Chained Equations): Se utiliza un conjunto de modelos para imputar los valores faltantes.

Mario Chavez

student•

Mi soloucion al reto

Ordeno por altura y luego por peso porque creo que el peso depende mas de la altura, agrupo por los los datos categoricos manteniendo los nulos, le aplico forward-fill a las columnas de altura y peso.

(
    nhanes_df
    .select_columns('height', 'weight', 'gender', 'diabetes', 'general_health_condition')
    .sort_values(by=['height', 'weight'], ascending=True)
    .groupby(
        by=['gender', 'diabetes', 'general_health_condition'],
        dropna=False,
    )
    .apply(lambda df: df[['height', 'weight']].ffill())
    .reset_index()
)

Pablo Alejandro Figueroa

student•

Alfonso Andres Zapata Guzman

student•

Esta sera la resolucion al reto? creo falto un poquito de claridad sobre lo que se buscaba, o sere yo muy noob.

Yo entendi qee habia que agrupar por las variables categoricas que son genero y condicion general de salud.

Y alli si aplicar el transform_column().

(
    nhanes_df
    .select_columns("height", "weight", "gender", "diabetes", "general_health_condition")
    .groupby(["gender", "general_health_condition"], dropna=False).value_counts(dropna=False)
    .reset_index()
    .transform_column(
        "weight",
        lambda x: x.bfill(),
        elementwise = False
    )
    .transform_column(
        "height",
        lambda x: x.bfill(),
        elementwise = False
    )
    .head(20)
)

Emmanuel Guerra Sánchez

student•

Me dieron estos resultados.

raw = nhanes_df
sorted = el de la clase
grouped_sorted = el del reto
comment = el df del comentario con mas visibilidad

Así hice el reto:

(
    nhanes_df[['height', 'weight', 'gender', 'diabetes','general_health_condition']]
    .groupby(
        ['gender', 'general_health_condition'],
        dropna=False,
    ).apply(lambda df: df.sort_values(
        by=['diabetes', 'height'],
        ascending=True,
    ).transform_column(
        'weight',
        lambda serie: serie.ffill(),
        elementwise=False
    ))
)
```(    nhanes\_df\[\['height', 'weight', 'gender', 'diabetes','general\_health\_condition']]    .groupby(        \['gender', 'general\_health\_condition'],        dropna=False,    ).apply(lambda df: df.sort\_values(        by=\['diabetes', 'height'],        ascending=True,    ).transform\_column(        'weight',        lambda serie: serie.ffill(),        elementwise=False    )))

Neicer Vásquez

student•

Dejo mi aporte y la manera en la que entendí esta clase.

Importancia de ordenar las columnas antes de imputar

<u>Imputación general con ordenación:</u>

<u>Imputación dentro de dominios o subconjuntos:</u>

Mario Alexander Vargas Celis

student•

(
    nhanes_df
    .select_columns("height", "weight", "gender", "diabetes", "general_health_condition")
    .sort_values(
        by = ["gender", "diabetes", "general_health_condition", "weight"],
        ascending = True
    )
    .groupby(["gender", "general_health_condition"], dropna=False)
    .apply(lambda x:x.ffill())
    
)
```(    nhanes\_df    .select\_columns("height", "weight", "gender", "diabetes", "general\_health\_condition")    .sort\_values(        by = \["gender", "diabetes", "general\_health\_condition", "weight"],        ascending = True    )    .groupby(\["gender", "general\_health\_condition"], dropna=False)    .apply(lambda x:x.ffill())    )

Antonio Demarco Bonino

student•

(
    nhanes_df
    .select_columns(["height_inches", "weight_pounds","gender","diabetes","health_condition"])
    .sort_values(
        by = ["gender","diabetes","health_condition","height_inches"],
        ascending = True
    )
    .groupby(["diabetes","gender","health_condition"],dropna = False)
    .apply(lambda x: x.ffill())
)
```(    nhanes\_df    .select\_columns(\["height\_inches", "weight\_pounds","gender","diabetes","health\_condition"])    .sort\_values(        by = \["gender","diabetes","health\_condition","height\_inches"],        ascending = True    )    .groupby(\["diabetes","gender","health\_condition"],dropna = False)    .apply(lambda x: x.ffill()))

Diego Cesar Lerma Torres

student•

Hay que tener en cuenta que, si hacemos groupby y luego aplicamos ffill o bfill, en los grupos, muchas veces al inicio o al final no habrá ningún dato para extender y lo dejará nulo.

Por ejemplo. Si resolvemos el reto mediante un apply:

(
    nhanes_df
    .select_columns('height', 'weight', 'gender', 'diabetes', 'general_health_condition')
    .sort_values(
        by=['gender', 'diabetes', 'general_health_condition','height'],
        ascending=True
    )
    .groupby(['gender', 'general_health_condition', 'height'],
        group_keys=True, 
        dropna=False
    )
    .apply(
        lambda df: df['weight'].ffill()
    )
    .reset_index()
    .isna().sum()
)

Retorna que quedaron 249 valores nulos gender 0 general_health_condition 1360 height 1669 SEQN 0 weight 249 dtype: int64

Si usamos transform:

# Seleccionar las columnas de interés y ordenar
df_modificado = (
    nhanes_df
    .select_columns('height', 'weight', 'gender', 'diabetes', 'general_health_condition')
    .sort_values(by=['gender', 'diabetes', 'general_health_condition', 'height'], ascending=True)
)

# Realizar la imputación. Importante: Aplicamos 'transform' directamente sobre la columna 'weight'.
df_modificado['weight'] = (
    df_modificado
    .groupby(['gender', 'general_health_condition', 'height'], group_keys=True, dropna=False)['weight']
    .transform(lambda x: x.ffill())
)

# Resetear el índice si es necesario y calcular los valores faltantes
df_modificado = df_modificado.reset_index(drop=True)
print(df_modificado.isna().sum())

Queda igual height 1669 weight 249 gender 0 diabetes 0 general_health_condition 1360 dtype: int64

Y si hacemos ffill().bfill() encadenado porque hay un grupo completo de nulos, quedan 2 sin imputar height 1669 weight 2 gender 0 diabetes 0 general_health_condition 1360 dtype: int64

Pablo Alejandro Figueroa

student•

Pablo Alejandro Figueroa

student•

Pablo Alejandro Figueroa

student•

Es opción no resultó mejor que las anteriores:

José Rodrigo Arana Hi

student•

Efectivamente necesitamos un poco más de info para resolver el problema. Recurrí a ChatGPT para un poco más de luz, he aquí el código para lo más cercano que pude de lo que pedía el profesor:

(
    nhanes_df
    .select_columns('height', 'weight', 'gender', 'diabetes', 'general_health_condition')
    .groupby(
        [
            'gender',
            'diabetes',
            'general_health_condition',
            'height'
            # 'weight'
        ],
        dropna=False,
        as_index=False
        )
    # .apply(lambda df: df.sort_values('weight').ffill())

    .apply(lambda df: df.sort_values(['weight']).ffill())
    # .reset_index(drop=True)
    # .query('weight.isna()')
    # .loc[730:740].head(35)
    # .transform_column(
    #     'weight',
    #     lambda x: x.fillna(method='ffill'),
    #     elementwise=False
    #     )
    
)

(
    nhanes_df
    .select_columns("height", "weight", "gender", "diabetes", "general_health_condition")
    .sort_values(
        by=['gender','diabetes','general_health_condition','weight'],
        ascending=True
    )
    .groupby(["gender", "general_health_condition"], dropna=False)
    .apply(lambda x: x.ffill())
)

(
    nhanes_df
    # seleccionamos las variables. Hay dos categoricas y tres numericas
    .select_columns('weight', 'height', 'gender', 'diabetes', 'general_health_condition')
    # ordenamos los grupos segun nuestro interes 
    # para este caso, primero el genero, seguido de diabetes, su estado de salud y finalmente la altura
    .sort_values(
        by = ['gender', 'diabetes', 'general_health_condition', 'height'],
        ascending = True
    )# realizamos la imputacion con el metodo transform
    .transform_column(
        'weight',   # variable de interes
        lambda x: x.ffill(),    # imputacion hacia adelante
        elementwise = False     # pasa una serie y no un unico valor
    )
)

# metodo alternativo de Pandas. Llenado hacia atras

(
    nhanes_df                           # dataframe
    .select_columns('height', 'weight') # variables numericas
    #.fillna(method = 'bfill')
    .bfill()                            # metodos de Pandas
)

(
    nhanes_df                           # dataframe
    .select_columns('height', 'weight') # variables numericas
    #.fillna(method = 'ffill')
    .ffill()                            # metodos de Pandas
)

(
    nhanes_df
    .select_columns('height', 'weight', 'gender', 'diabetes', 'general_health_condition')
    .sort_values(by=['height', 'weight'], ascending=True)
    .groupby(
        by=['gender', 'diabetes', 'general_health_condition'],
        dropna=False,
    )
    .apply(lambda df: df[['height', 'weight']].ffill())
    .reset_index()
)

(
    nhanes_df
    .select_columns("height", "weight", "gender", "diabetes", "general_health_condition")
    .groupby(["gender", "general_health_condition"], dropna=False).value_counts(dropna=False)
    .reset_index()
    .transform_column(
        "weight",
        lambda x: x.bfill(),
        elementwise = False
    )
    .transform_column(
        "height",
        lambda x: x.bfill(),
        elementwise = False
    )
    .head(20)
)

(
    nhanes_df[['height', 'weight', 'gender', 'diabetes','general_health_condition']]
    .groupby(
        ['gender', 'general_health_condition'],
        dropna=False,
    ).apply(lambda df: df.sort_values(
        by=['diabetes', 'height'],
        ascending=True,
    ).transform_column(
        'weight',
        lambda serie: serie.ffill(),
        elementwise=False
    ))
)
```(    nhanes\_df\[\['height', 'weight', 'gender', 'diabetes','general\_health\_condition']]    .groupby(        \['gender', 'general\_health\_condition'],        dropna=False,    ).apply(lambda df: df.sort\_values(        by=\['diabetes', 'height'],        ascending=True,    ).transform\_column(        'weight',        lambda serie: serie.ffill(),        elementwise=False    )))

(
    nhanes_df
    .select_columns("height", "weight", "gender", "diabetes", "general_health_condition")
    .sort_values(
        by = ["gender", "diabetes", "general_health_condition", "weight"],
        ascending = True
    )
    .groupby(["gender", "general_health_condition"], dropna=False)
    .apply(lambda x:x.ffill())
    
)
```(    nhanes\_df    .select\_columns("height", "weight", "gender", "diabetes", "general\_health\_condition")    .sort\_values(        by = \["gender", "diabetes", "general\_health\_condition", "weight"],        ascending = True    )    .groupby(\["gender", "general\_health\_condition"], dropna=False)    .apply(lambda x:x.ffill())    )

(
    nhanes_df
    .select_columns(["height_inches", "weight_pounds","gender","diabetes","health_condition"])
    .sort_values(
        by = ["gender","diabetes","health_condition","height_inches"],
        ascending = True
    )
    .groupby(["diabetes","gender","health_condition"],dropna = False)
    .apply(lambda x: x.ffill())
)
```(    nhanes\_df    .select\_columns(\["height\_inches", "weight\_pounds","gender","diabetes","health\_condition"])    .sort\_values(        by = \["gender","diabetes","health\_condition","height\_inches"],        ascending = True    )    .groupby(\["diabetes","gender","health\_condition"],dropna = False)    .apply(lambda x: x.ffill()))

(
    nhanes_df
    .select_columns('height', 'weight', 'gender', 'diabetes', 'general_health_condition')
    .sort_values(
        by=['gender', 'diabetes', 'general_health_condition','height'],
        ascending=True
    )
    .groupby(['gender', 'general_health_condition', 'height'],
        group_keys=True, 
        dropna=False
    )
    .apply(
        lambda df: df['weight'].ffill()
    )
    .reset_index()
    .isna().sum()
)

# Seleccionar las columnas de interés y ordenar
df_modificado = (
    nhanes_df
    .select_columns('height', 'weight', 'gender', 'diabetes', 'general_health_condition')
    .sort_values(by=['gender', 'diabetes', 'general_health_condition', 'height'], ascending=True)
)

# Realizar la imputación. Importante: Aplicamos 'transform' directamente sobre la columna 'weight'.
df_modificado['weight'] = (
    df_modificado
    .groupby(['gender', 'general_health_condition', 'height'], group_keys=True, dropna=False)['weight']
    .transform(lambda x: x.ffill())
)

# Resetear el índice si es necesario y calcular los valores faltantes
df_modificado = df_modificado.reset_index(drop=True)
print(df_modificado.isna().sum())

(
    nhanes_df
    .select_columns('height', 'weight', 'gender', 'diabetes', 'general_health_condition')
    .groupby(
        [
            'gender',
            'diabetes',
            'general_health_condition',
            'height'
            # 'weight'
        ],
        dropna=False,
        as_index=False
        )
    # .apply(lambda df: df.sort_values('weight').ffill())

    .apply(lambda df: df.sort_values(['weight']).ffill())
    # .reset_index(drop=True)
    # .query('weight.isna()')
    # .loc[730:740].head(35)
    # .transform_column(
    #     'weight',
    #     lambda x: x.fillna(method='ffill'),
    #     elementwise=False
    #     )
    
)

Imputación por llenado hacia atrás y hacia adelante

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