Imputación por KNN en Python

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

Jeinfferson Bernal G

student•

Ordenamiento por cantidad de variables faltantes

Ordenar los datos por la cantidad de valiables faltantes nos da cierto rigor al momento de la imputacion. Esto se logra comenzando con definir las distancias entre valores existentes para luego predecir o imputar valores que no existen repitiendo el proceso paso a paso hasta lograr la imputacion completa de los datos. Algunos algoritmos implementan esta tecnica por defecto.

Imputacion por KNN al ordenas las variables segun su cantidad de valores faltantes de forma ascendente

# imputador con knn
knn_imputer = sklearn.impute.KNNImputer()

# copia del df                        ordenamos las variables por la cantidad de missing de forma ascendente
nhanes_df_knn = nhanes_transformed_df.missing.sort_variables_by_missingness(ascending=True).copy(deep=True)

# agregamos los valores imputados al nuevo df         ajustamos los datos ordenados por la cantidad de variables faltantes                                                                              redondeamos valores   
nhanes_df_knn.iloc[:, :] = knn_imputer.fit_transform(nhanes_transformed_df.missing.sort_variables_by_missingness(ascending=True).copy(deep=True)).round()

nhanes_df_knn

Visualizacion mediante un scatterplot

(   # matriz de sombra
    pd.concat(
        [
            nhanes_df_knn,
            nhanes_df.missing.create_shadow_matrix2(True, False, suffix='_imp', only_missing=True)
        ],
        axis=1
    )   # visualizacion mediantes un scatterplot de dos variables numericas
    .missing.scatter_imputation_plot(
        x = 'height',
        y = 'weight'
    )
)

Aunque ambas imputaciones son similares, puede darse el caso dependiendo del software que aplicando este truco te ayude a conseguir mejores rendimientos en el conjunto de datos

Julián Cárdenas

student•

Nice summary like always you do

Pablo Alejandro Figueroa

student•

Gracias Jeinfferson un lujo..!

Jeinfferson Bernal G

student•

Imputacion por KNN en Python

Utilizamos el dataframe con los datos categoricos transformados en numeros

nhanes_transformed_df

Creamos el imputador con el algoritmo de knn

# imputador con knn
knn_imputer = sklearn.impute.KNNImputer()

Creamos una copia del dataframe con los datos transformados

nhanes_df_knn = nhanes_transformed_df.copy(deep=True)

Imputamos los valores faltantes

# agregamos los valores al nuevo df                  sobreescribimos        redondeamos valores   
nhanes_df_knn.iloc[:, :] = knn_imputer.fit_transform(nhanes_transformed_df).round()

nhanes_df_knn

Julián Cárdenas

student•

👏 :)

Pablo Alejandro Figueroa

student•

Gracias Jeinfferson otro lujo..!

Jeinfferson Bernal G

student•

Visualizacion de la imputacion por KNN

Creamos la matriz de sombra y luego graficamos mediante un scattterplot

(   # matriz de sombra
    pd.concat(
        [
            nhanes_df_knn,
            nhanes_df.missing.create_shadow_matrix2(True, False, suffix='_imp', only_missing=True)
        ],
        axis=1
    )   # visualizacion mediantes un scatterplot de dos variables numericas
    .missing.scatter_imputation_plot(
        x = 'height',
        y = 'weight'
    )
)

Julián Cárdenas

student•

👏

Catriel Perez

student•

hasta el min 7 es el mismo video que la clase 12

Alejandro Pedrosa Calleja

student•

nice try

Bryan Carvajal

student•

no lo crean, vean el video completo 😃

Pablo Alejandro Figueroa

student•

Sorted or not sorted..?

Me parece que es lo mismo:

Mario Alexander Vargas Celis

student•

La **imputación por KNN** en Python se puede realizar de manera efectiva utilizando la clase KNNImputer de la librería scikit-learn. Esta herramienta es útil para reemplazar los valores faltantes basándose en las observaciones más cercanas en términos de distancia entre puntos.

### Pasos para implementar KNNImputer en Python:

1. **Instalación de las dependencias necesarias** (si aún no las tienes instaladas):

```bash

pip install scikit-learn pandas

```

2. **Imputación por KNN** con un ejemplo práctico.

#### Ejemplo paso a paso:


import numpy as np

import pandas as pd

from sklearn.impute import KNNImputer



\# Crear un DataFrame con valores faltantes

data = {'A': \[1, 2, np.nan, 4, 5],

&#x20;       'B': \[5, np.nan, np.nan, 3, 2],

&#x20;       'C': \[7, 8, 9, 10, 11]}



df = pd.DataFrame(data)



\# Mostrar el DataFrame original con valores faltantes

print("DataFrame original:")

print(df)



\# Crear un objeto KNNImputer con K=2 (número de vecinos más cercanos)

imputer = KNNImputer(n\_neighbors=2)



\# Imputar los valores faltantes utilizando KNN

df\_imputed = pd.DataFrame(imputer.fit\_transform(df), columns=df.columns)



\# Mostrar el DataFrame después de la imputación

print("\nDataFrame imputado por KNN:")

print(df\_imputed)

### Explicación del código:

1. **DataFrame con valores faltantes**: Creamos un DataFrame con algunas celdas vacías (representadas por np.nan).

2. **KNNImputer**: Inicializamos el objeto KNNImputer con 2 vecinos más cercanos (n\_neighbors=2). Puedes ajustar este valor dependiendo de cuántos vecinos desees utilizar.

3. **Imputación**: Aplicamos el método fit\_transform() para realizar la imputación de los valores faltantes.

4. **Resultados**: Visualizamos el DataFrame con los valores imputados.

### Salida esperada:


DataFrame original:

&#x20;    A    B   C

0  1.0  5.0   7

1  2.0  NaN   8

2  NaN  NaN   9

3  4.0  3.0  10

4  5.0  2.0  11



DataFrame imputado por KNN:

&#x20;    A    B     C

0  1.0  5.0   7.0

1  2.0  4.0   8.0

2  3.0  4.0   9.0

3  4.0  3.0  10.0

4  5.0  2.0  11.0

### Consideraciones adicionales:

- **Escalado de los datos**: Si los datos tienen escalas muy diferentes, es recomendable normalizarlos antes de aplicar KNNImputer para que las variables no dominen en el cálculo de las distancias.

```python

from sklearn.preprocessing import StandardScaler

scaler = StandardScaler()

df_scaled = scaler.fit_transform(df)

# Aplicar KNN después de escalar los datos

df_imputed_scaled = pd.DataFrame(imputer.fit_transform(df_scaled), columns=df.columns)

```

- **Elección del número de vecinos (\( K \))**: El número de vecinos a utilizar puede variar según el tipo de datos y la cantidad de valores faltantes. Generalmente, se prueba con distintos valores de \( K \) y se evalúa cuál proporciona mejores resultados para el conjunto de datos.

La imputación por KNN es útil cuando los valores faltantes están relacionados con otras observaciones cercanas en el espacio de características, proporcionando una forma eficiente de imputar datos faltantes sin introducir sesgos arbitrarios.

Paola Alapizco

student•

🤔 Creo que uno de los puntos importantes a destacar de este modulo, es la distribución que siguen los valores faltantes una vez imputados respecto a la distribución de los valores completos.

Valor único que utiliza un valor estadístico (media, moda o mediana) de la variable (columna) para rellenar los valores faltantes.

Donde la distribución de los valores completos es mucho más aplanada (valores muy dispersos respecto de la media), mientras que los valores faltantes al haber sido imputados con el valor de la media tienen una distribución/forma leptocúrtica donde los valores se concentran al rededor de la media. Es obvio al haber sido rellenados con este valor 😅.

Llenado hacia adelante, utiliza el último valor conocido antes del valor faltante para rellenarlo.

Llenado hacia atrás, utiliza el primer valor conocido después del valor faltante para rellenarlo.

En ambos casos los valores imputados se dispersan de manera uniforme entre los datos completos, mientras que la distribución de los valores faltantes imputados es mucho más aplanada y con los valores más dispersos respecto de la media en comparación con la distribución de los valores completos.

ffill()

bfill()

K-vecinos más cercanos, el cuál imputa el valor de la media de esos vecinos más próximos al valor faltante, al realizar el proceso de imputación con este algoritmo obtenemos una distribución de los valores faltantes más parecida a la distribución de los valores completos.

A diferencia del llenado hacia adelante y hacia atrás, los valores imputados son más próximos entre si.

Federico Mario

student•

En vez de usar un Ordinal encoder que asigna valores aleatoriamente, no sería mejor utilizar el método replace y darle un valor mas razonable a cada categoría? Ej:

Excellent... . 4
Very good ..3
Good .. .. . 2
Fair or... .. .1
Poor?... .. ..0

Mauricio Estrada

student•

Pero si haces eso, ¿no tendrías que conocer siempre todas tus categorías?

Federico Mario

student•

Si, es correcto, pero en este caso, se pueden conocer fácilmente aplicando la función unique() de pandas.

Mauro Benito Montoya Arenas

student•

¿Y cual es la distancia y cant. de vecinos que usaremos?. No explico nada de eso

Mario Chavez

student•

Si corres help(sklearn.impute.KNNImputer()) te da la documentacion del metodo donde dice que como default utiliza los 5 vecinos mas cercanos y la distancia pues sera la mas corta dependiendo de los vecions.

Valentina Cobo Paz

student•

Depende de tus datos, para la distancia, por ejemplo la Euclidiana se utiliza normalmente para datos numéricos y es sensible a la diferencia de escala y puede ser útil normalizar antes los datos. La D Manhattan tambien se usa para datos numpericos, sobretodo si las dimensiones son más importantes que las distancias absolutas. Podrías revisar mas distancias y cuales se ajustan a los datos que vas a usar.

La cantidad de vecinos (k) puedes sacarla usando validación cruzada. divides el conjunto de datos en test y train, defines un rango de k, para cada valor de k, realiza la imputación de datos faltantes en el conjunto de entrenamiento y evalúa el rendimiento en el conjunto de validación. La evaluación puede hacerse comparando métricas como la media cuadrática del error (MSE) o el error absoluto medio (MAE) para datos numéricos, o precisión, recall, F1-score para datos categóricos.

Mauricio Hurtado

student•

Para evaluar la corrección de la imputación con KNN, puedes seguir estos pasos:

Comparación con los valores reales: Si tienes un conjunto de datos donde los valores originales son conocidos, compara las imputaciones KNN con estos valores para calcular métricas de error como RMSE (Root Mean Square Error).
Visualización: Utiliza gráficos para comparar la distribución de los datos originales y los datos imputados. Un histograma puede ayudar a visualizar si la imputación mantiene la forma de la distribución.
Validación cruzada: Realiza validación cruzada en tu modelo para comprobar cómo se comporta la imputación en diferentes subconjuntos del conjunto de datos.
Análisis de sensibilidad: Cambia los parámetros de K (número de vecinos) y observa si la imputación varía significativamente. Esto puede indicar la estabilidad del método.
Evaluar con otros métodos: Compara KNN con otras técnicas de imputación (media, mediana, MICE) para ver cuál produce resultados más precisos y coherentes.

Estas técnicas te ayudarán a determinar la efectividad de tu imputación con KNN.

Andrés Cardona

student•

Alguien tiene el archivo con la función de scatter_imputation_plot()? en el que yo tengo no está la función y no me funciona.

Pablo Alejandro Figueroa

student•

    def scatter_imputation_plot(
        self, x, y, imputation_suffix="_imp", show_marginal=False, **kwargs
    ):

        x_imputed = f"{ x }{ imputation_suffix }"
        y_imputed = f"{ y }{ imputation_suffix }"

        plot_func = sns.scatterplot if not show_marginal else sns.jointplot

        return (
            self._obj[[x, y, x_imputed, y_imputed]]
            .assign(is_imputed=lambda df: df[x_imputed] | df[y_imputed])
            .pipe(lambda df: (plot_func(data=df, x=x, y=y, hue="is_imputed", **kwargs)))
        )

Andrés Cardona

student•

Gracias Pablo!!

Andres Sanchez

student•

13. Imputación por KNN en Python

knn_imputer = sklearn.impute.KNNImputer()

nhanes_df_knn = nhanes_transformed_df.missing.sort_variables_by_missingness(ascending=True).copy(deep=True)

nhanes_df_knn.iloc[:, :] = knn_imputer.fit_transform(nhanes_transformed_df.missing.sort_variables_by_missingness(ascending=True)).round()
nhanes_df_knn.head(20)

(
    pd.concat(
        [
            nhanes_df_knn,
            nhanes_df.missing.create_shadow_matrix(True, False, suffix='_imp',only_missing=True)
        ],
        axis=1
    )
     .missing.scatter_imputation_plot(
         x='height',
         y='weight',
     )   
        
)

Pablo Alejandro Figueroa

student•

Gracias..!

# imputador con knn
knn_imputer = sklearn.impute.KNNImputer()

# copia del df                        ordenamos las variables por la cantidad de missing de forma ascendente
nhanes_df_knn = nhanes_transformed_df.missing.sort_variables_by_missingness(ascending=True).copy(deep=True)

# agregamos los valores imputados al nuevo df         ajustamos los datos ordenados por la cantidad de variables faltantes                                                                              redondeamos valores   
nhanes_df_knn.iloc[:, :] = knn_imputer.fit_transform(nhanes_transformed_df.missing.sort_variables_by_missingness(ascending=True).copy(deep=True)).round()

nhanes_df_knn

(   # matriz de sombra
    pd.concat(
        [
            nhanes_df_knn,
            nhanes_df.missing.create_shadow_matrix2(True, False, suffix='_imp', only_missing=True)
        ],
        axis=1
    )   # visualizacion mediantes un scatterplot de dos variables numericas
    .missing.scatter_imputation_plot(
        x = 'height',
        y = 'weight'
    )
)

(   # matriz de sombra
    pd.concat(
        [
            nhanes_df_knn,
            nhanes_df.missing.create_shadow_matrix2(True, False, suffix='_imp', only_missing=True)
        ],
        axis=1
    )   # visualizacion mediantes un scatterplot de dos variables numericas
    .missing.scatter_imputation_plot(
        x = 'height',
        y = 'weight'
    )
)

import numpy as np

import pandas as pd

from sklearn.impute import KNNImputer

\# Crear un DataFrame con valores faltantes

data = {'A': \[1, 2, np.nan, 4, 5],

&#x20;       'B': \[5, np.nan, np.nan, 3, 2],

&#x20;       'C': \[7, 8, 9, 10, 11]}

df = pd.DataFrame(data)

\# Mostrar el DataFrame original con valores faltantes

print("DataFrame original:")

print(df)

\# Crear un objeto KNNImputer con K=2 (número de vecinos más cercanos)

imputer = KNNImputer(n\_neighbors=2)

\# Imputar los valores faltantes utilizando KNN

df\_imputed = pd.DataFrame(imputer.fit\_transform(df), columns=df.columns)

\# Mostrar el DataFrame después de la imputación

print("\nDataFrame imputado por KNN:")

print(df\_imputed)

DataFrame original:

&#x20;    A    B   C

1.0  5.0   7

2.0  NaN   8

NaN  NaN   9

4.0  3.0  10

5.0  2.0  11

DataFrame imputado por KNN:

&#x20;    A    B     C

1.0  5.0   7.0

2.0  4.0   8.0

3.0  4.0   9.0

4.0  3.0  10.0

5.0  2.0  11.0

    def scatter_imputation_plot(
        self, x, y, imputation_suffix="_imp", show_marginal=False, **kwargs
    ):

        x_imputed = f"{ x }{ imputation_suffix }"
        y_imputed = f"{ y }{ imputation_suffix }"

        plot_func = sns.scatterplot if not show_marginal else sns.jointplot

        return (
            self._obj[[x, y, x_imputed, y_imputed]]
            .assign(is_imputed=lambda df: df[x_imputed] | df[y_imputed])
            .pipe(lambda df: (plot_func(data=df, x=x, y=y, hue="is_imputed", **kwargs)))
        )

knn_imputer = sklearn.impute.KNNImputer()

nhanes_df_knn = nhanes_transformed_df.missing.sort_variables_by_missingness(ascending=True).copy(deep=True)

nhanes_df_knn.iloc[:, :] = knn_imputer.fit_transform(nhanes_transformed_df.missing.sort_variables_by_missingness(ascending=True)).round()
nhanes_df_knn.head(20)

(
    pd.concat(
        [
            nhanes_df_knn,
            nhanes_df.missing.create_shadow_matrix(True, False, suffix='_imp',only_missing=True)
        ],
        axis=1
    )
     .missing.scatter_imputation_plot(
         x='height',
         y='weight',
     )   
        
)

Imputación por KNN en Python

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?