Introducción a la imputación basada en modelos

Proceso para la Imputacion basada en Modelos

Cuando se utiliza un modelo para imputar, en principio no aceptan valores faltantes por lo que el primer paso es imputar los valores faltantes con dummies. Luego se utiliza el modelo y se va iterando hasta que los valores que hemos sustituido con dummies no cambien. Justo alli se llega a una optima imputacion.

• Preparacion de los datos

# preparamos los datos de la variable a imputar

nhanes_model_df= (
    nhanes_df
    .select_columns('height', 'weight', 'gender', 'age')    # seleccionamos columnas
    .sort_values(by='height')   # ordenamos en funcion de height
    #   sustituir los valores faltantes con dummies
    .transform_column(  
        'weight',   # variable de interes
        lambda x: x.ffill(),
        elementwise = False
    )   #   matriz de sombra con el sufijo imp
    .missing.bind_shadow_matrix2(
        True,
        False,
        suffix='_imp',
        only_missing=False   # matriz de sombra para todas las variables
    )
)

nhanes_model_df

• Preparacion del modelo

# para este ejemplo vamos a utilizar la regresion lineal como modelo

height_ols = (
    nhanes_model_df
    .pipe(
        lambda df: smf.ols('height ~ weight + gender + age', data=df)
    )
    .fit()
)

• Generacion de los valores imputados mediante el modelo

# obtener solo las observaciones con valores nulos en la variable height

(
    nhanes_model_df
    .pipe(
        lambda df: df[df.height.isna()]
    )
)

# utilizamos el modelo para generar los valores imputados

ols_imputed_values = (
    nhanes_model_df
    .pipe(
        lambda df: df[df.height.isna()]
    )
    # aplicamos el modelo. Los valores imputados se redondean debido a que son enteros
    .pipe( 
    lambda df: height_ols.predict(df).round()
    )
)

ols_imputed_values

• Sustitucion de los valores imputados en el Dataset

# sustituimos los valores imputados generados con 
# el modelo en la variable asociada

nhanes_model_df.loc[nhanes_model_df.height.isna(), ['height']] = ols_imputed_values

nhanes_model_df

• Visualizacion de los valores imputados

(
    nhanes_model_df
    .missing
    .scatter_imputation_plot(
        x = 'weight',   # variable independiente
        y = 'height'    # variable objetivo
    )
)

La grafica nos muestra la imputacion de la variable height en funcion de la variable weight. Observamos dos bloques de datos lo que podria indicar que se trata de la diferencia en peso entre mujeres y hombres.

El siguiente paso para aprovechar mejor el modelo es repetir todos los pasos anteriores pero en la preparacion de los datos, en vez de utilizar los valores dummies para weight, utilizamos la variable height con los valores imputados por el modelo. De esta manera ahora se busca imputar los valores de la variable weight en vez de los de height que ya han sido imputados.

Imputacion basada en Modelos

Ventajas

• Mejora sobre la imputacion basada en donantes sencilla
• Presenta gran variedad de opciones para imputar. Puedes elegir tecnicas de Machine Learning como puede ser un SVM o tecnicas de Deep Learning como Redes Neuronales.
• Preserva la relacion entre las variables

Desventajas

• Puede subestimar la varianza. Tambien arrastra todos los defecto que presente el modelo.
• Los modelos funcionan mal si las variables observadas y faltantes son independientes.
• Es mas complicado que la imputacion basada en donantes

Lo que entendí del proceso fue:

1. Se ordeno el dataset, se rellenaron los valores de weigth con un ffill() y se anadireon las columnas “_imp”.
2. Se creo height_ols que es un modelo predictivo para la variable height tomando en cuenta weight, gender y age basado en Ordinary Least Squares (OLS, una regrecion lineal).
3. Del dataset se seleccionaron solo las tuplas donde faltaba la altura y se lleno usando el modelo predictivo.
4. Finalmente se llenaron los valores faltantes del dataset original con los valores calculados.

Copien y presten atención a la explicación!!

nhanes_model_df = (
    nhanes_df.select_columns('height','weight','gender','age')
    .sort_values(by='height')
    .transform_column(
        'weight',
        lambda x: x.ffill(),
        elementwise=False
    )
    .missing.bind_shadow_matrix(
        True,
        False,
        suffix='_imp',
        only_missing=False
    )
)
nhanes_model_df

height_ols = (
    nhanes_model_df
    .pipe(lambda df: smf.ols('height ~ weight + gender + age', data=df))
    .fit()
)

ols_imputed_values = (
    nhanes_model_df
    .pipe(
        lambda df: df[df.height.isna()]
    )
    .pipe(
        lambda df: height_ols.predict(df).round()
    )
)
ols_imputed_values

nhanes_model_df.loc[nhanes_model_df.height.isna(), ['height']] = ols_imputed_values
nhanes_model_df

(
    nhanes_model_df.missing.scatter_imputation_plot(
        x='weight',
        y='height'
    )
)

Al menos hasta acá el que menos ha afectado a la curtosis es ffill en estos ejemplos:

Vamos a predecir e imputar los nuevos valores de ‘weight’:

nhanes_model_df2 = nhanes_df.copy(deep=True)

nhanes_model_df2.loc[nhanes_model_df2.height.isna(), 'height'] = ols_imputed_values
nhanes_model_df2

nhanes_model_df2 = (
    nhanes_model_df2
    .select_columns(
        'height',
        'weight',
        'age',
        'gender'
    )
    .missing.bind_shadow_matrix(True, False, suffix='_imp')
)

weight_ols = (
    nhanes_model_df2
    .pipe(
        lambda df: smf.ols('weight ~ height + gender + age', data=df)
    )
    .fit()
)

ols_weight_imputed_values = (
    nhanes_model_df2
    .pipe(
        lambda df: df[df.weight.isna()]
    )
    .pipe(
        lambda df: weight_ols.predict(df).round()
    )
)

ols_weight_imputed_values

nhanes_model_df2.loc[nhanes_model_df2.weight.isna(), 'weight'] = ols_weight_imputed_values
nhanes_model_df2

(
    nhanes_model_df2
    .missing
    .scatter_imputation_plot(
        x='height',
        y='weight'
    )
)

![](