Amplía tu conjunto de herramientas para explorar valores faltantes

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

Bryan Carvajal

student•

Solucion planteada por el profe:

def missing_mosaic_plot(
        self,
        target_var: str,
        x_categorical_var: str,
        y_categorical_var: str,
        ax = None
    ):
        return (
            self._obj
            .assign(
                **{target_var: lambda df: df.weight.isna().replace([True, False], ["NA", "!NA"])}
            )
            .groupby(
                [x_categorical_var, y_categorical_var, target_var],
                dropna=False,
                as_index=True,
            )
            .size()
            .pipe(
                lambda df: mosaic(
                    data=df,
                    properties=lambda key: {"color": "r" if "NA" in key else "gray"},
                    ax=ax,
                    horizontal=True,
                    axes_label=True,
                    title="",
                    labelizer=lambda key: "",
                )
            )
        )

Julián Cárdenas

student•

Gracias !

Pablo Alejandro Figueroa

student•

Andres Sanchez

student•

5. Amplía tu conjunto de herramientas para explorar valores faltantes

fig, ax = plt.subplots(figsize=(10,10))

(
    nhanes_df
    .select_columns('weight','general_health_condition','gender')
    .assign(
        weight = lambda df: df.weight.isna().replace([True,False],['NA','!NA'])
    )
    .groupby(
        ['gender','general_health_condition','weight'],
        dropna=False,
        as_index = True
    )
    .size()
    .pipe(
        lambda df: mosaic(
            data = df,
            properties=lambda key: {'color':'r' if 'NA' in key else 'gray'},
            horizontal=True,
            axes_label=True,
            title='',
            labelizer=lambda key: '',
            ax = ax
        )
    )
);

José Rodrigo Arana Hi

student•

yo lo hice directo en el notebook, comparé el codigo y es similar. Noten que el código del profe en pandas_missing_extension tienen un detalle: cambien el nombre de la columna 'weight' por el parámetro definido en la función. **{target_var: lambda df: df.weight.isna().replace([True, False], ["NA", "!NA"])}

Aquí mi código:

def missing_mosaic_plot(df, cat1, cat2, var):
    fig, ax = plt.subplots(figsize=(10,10))
    
    my_mosaic = (
            df
            [[cat1, cat2, var]]
            .assign(
                **{
                    var: lambda df: df[var].isna().replace([False, True], ['!NA', 'NA'])
                }    
            )
            .groupby(
                [
                    cat1,
                    cat2,
                    var
                ],
                dropna=False,
                as_index=True
            )
            .size()
            .pipe(
                lambda df: mosaic(
                    df,
                    properties=lambda key: {
                        'color': 'r' if 'NA' in key else 'c'
                    },
                    horizontal=True,
                    axes_label=True,
                    title='',
                    labelizer=lambda key: '',
                    ax= ax
                )
            )
        )

    # plt.show()

    return my_mosaic

missing_mosaic_plot(nhanes_df, 'gender','general_health_condition', 'pulse')

Mario Alexander Vargas Celis

student•

Para explorar y manejar valores faltantes de manera efectiva, es crucial ampliar las herramientas y técnicas que tienes a tu disposición. Aquí te dejo algunas herramientas y enfoques útiles que puedes implementar:

### 1. **Visualización de valores faltantes**:

Existen varias librerías en Python que permiten visualizar valores faltantes de manera intuitiva:

- **Matplotlib y Seaborn**: Úsalos para crear gráficos de calor o gráficos de barras que te permitan identificar la cantidad de valores faltantes.

```python

import seaborn as sns

import matplotlib.pyplot as plt

sns.heatmap(df.isnull(), cbar=False)

plt.show()

```

- **Missingno**: Una librería especializada en la visualización de datos faltantes.

```python

import missingno as msno

# Visualización básica

msno.matrix(df)

# Visualización de dendograma para identificar patrones de valores faltantes correlacionados

msno.dendrogram(df)

```

### 2. **Matriz de sombras**:

Una técnica avanzada que permite crear una matriz binaria donde 1 indica la presencia de un valor y 0 indica su ausencia. Esto permite analizar las correlaciones entre la presencia de valores faltantes en diferentes variables.

```python

import pandas as pd

# Matriz de sombras

shadow_matrix = df.isnull().astype(int)

```

Esta técnica puede ser útil para identificar si la falta de datos en una columna está correlacionada con la falta de datos en otra.

### 3. **Correlación de nulidad**:

Explorar la relación entre valores faltantes en diferentes columnas es clave para entender el origen de los valores faltantes. Esto se puede hacer usando la función pandas.DataFrame.corr() para calcular la correlación entre la matriz de nulidad.

```python

# Calcular la correlación entre valores faltantes

nullity_corr = df.isnull().corr()

```

También puedes calcular correlaciones específicas con valores faltantes usando el método pairwise deletion o la imputación de valores como último recurso.

### 4. **Imputación de valores faltantes**:

Hay múltiples enfoques que puedes usar para imputar valores faltantes:

- **Imputación por la media/mediana/moda**: Fácil de implementar, pero puede sesgar los resultados.

```python

df['column'].fillna(df['column'].mean(), inplace=True)

```

- **Imputación usando métodos más avanzados**:

- **K-Nearest Neighbors (KNN)**: Este método utiliza las observaciones más cercanas para imputar valores faltantes.

- **Iterative Imputer**: Realiza imputaciones iterativas en las columnas del conjunto de datos utilizando un modelo de regresión.

```python

from sklearn.impute import KNNImputer

imputer = KNNImputer(n_neighbors=5)

df_imputed = imputer.fit_transform(df)

```

### 5. **Análisis de patrones de valores faltantes**:

Identificar patrones en los datos faltantes te ayudará a elegir la estrategia adecuada. Existen tres tipos de valores faltantes:

- **MCAR (Missing Completely at Random)**: No hay patrón.

- **MAR (Missing at Random)**: Los valores faltantes dependen de otras variables.

- **MNAR (Missing Not at Random)**: Los valores faltantes dependen de la propia variable con valores ausentes.

Usando herramientas de visualización como **Missingno** y análisis estadístico, puedes descubrir estos patrones.

### 6. **Funciones adicionales de pyjanitor**:

pyjanitor expande las capacidades de pandas con funciones específicas para limpieza, incluidas aquellas que exponen valores faltantes implícitos:

```python

import janitor

df = df.complete()

```

Puedes utilizar janitor para completar los valores implícitos y exponer relaciones entre variables.

### 7. **Uso de máscaras para filtrar y analizar valores faltantes**:

Puedes utilizar máscaras booleanas para filtrar filas y columnas con valores faltantes y hacer un análisis más detallado.

```python

missing_mask = df.isnull()

missing_columns = df.columns[missing_mask.any()]

```

### Conclusión

Ampliar tu conjunto de herramientas para manejar valores faltantes implica una combinación de **visualización**, **análisis estadístico** y **métodos de imputación** avanzados. Utilizar bibliotecas como **Seaborn**, **Missingno**, **pyjanitor**, junto con las funciones integradas de **Pandas**, te permitirá explorar los datos de manera más efectiva y tomar decisiones informadas sobre cómo manejar valores faltantes.

José Pablo Cabrera Romo

student•

Este es mi código del reto, funcional en Notebook, teniendo en cuenta que faltarían modificaciones ya que aún no se ha registrado como un accessor de DataFrame y no tiene acceso directo a self._obj.

def missing_mosaic_plot(
        self,
        categorical_variable_1: str,
        categorical_variable_2: str,
        missing_data_variable, str,
):

    fig, ax = plt.subplots(figsize = (15, 10))

    (
        self
        .select_columns(f"{missing_data_variable}", f"{categorical_variable_1}", f"{categorical_variable_2}")
        .assign(
            weight = lambda df : df[f"{missing_data_variable}"].isna().replace([True, False], ["NA", "¡NA"])
        )
        .groupby(
            [f"{categorical_variable_1}", f"{categorical_variable_2}", f"{missing_data_variable}"],
            dropna = False,
            as_index = True
        )
        .size()
        .pipe(
            lambda df : mosaic(
                data = df,
                properties = lambda key : {"color":"r" if "NA" in key else "gray"},
                horizontal = True,
                axes_label = True,
                title = " ",
                
                labelizer = lambda key: " ",
                ax = ax
            )
        )

    ) ;

Jeinfferson Bernal G

student•

Muy interesante el Grafico de Mosaico. Nos permite visualizar datos categoricos multivariantes de forma precisa e informativa.

Francisco Javier Castillo Castillo

student•

Aca mi humilde aporte:


def create_mosaic_plot(df, var1, var2, var3, figsize=(10,10)):
    """
    Crea un diagrama de mosaico para visualizar la relación entre tres variables,
    resaltando los valores faltantes.
    
    Parámetros:
    -----------
    df : pandas.DataFrame
        DataFrame de entrada
    var1 : str
        Primera variable (se usará para agrupar)
    var2 : str
        Segunda variable (se usará para agrupar)
    var3 : str
        Tercera variable para verificar valores faltantes
    figsize : tuple, opcional
        Tamaño de la figura, por defecto es (10,10)
        
    Retorna:
    --------
    matplotlib.figure.Figure
        La figura creada
    """
    fig, ax = plt.subplots(figsize=figsize)
    
    (df.select_columns(var1, var2, var3)
        .assign(
            var3 = lambda df: df[var3].isna().replace({True: "NA", False: "!NA"})
        )
        .groupby(
            [var1, var2, "var3"],
            dropna=False,
            as_index=True
        )
        .size()
        .pipe(
            lambda df: mosaic(
                data=df,
                properties=lambda key: {"color": "r" if "NA" in key else "gray"},
                horizontal=True,
                axes_label=True,
                labelizer=lambda key: "",
                ax=ax
            )
        )
    )
    
    return fig

create_mosaic_plot(nhanes_df, "gender", "general_health_condition", "weight")

Rubén Téllez Gerardo

student•

Esta fue mi clase más difícil en toda mi carrera, no por otra cosa si no porque no estaba haciendo la codificación correctamente y la documentación ni la IA eran de ayuda. Lo que me hizo alejarme un mes de todo esto (después de varios meses de intenso estudio). Hoy por fin logré progresar.

Si algo puedo dejar a los que pasen por aquí, es que no se rindan, aún si cometieron el error de alejarse de todo tanto tiempo como yo, siempre es posible corregir nuestros errores aunque tengamos que pagar el precio (en mi caso haber perdido tiempo y lo que este cuesta).

Pablo Alejandro Figueroa

student•

pandas.DataFrame.groupby

dropna: bool, default True

as_index: bool, default True

Pablo Alejandro Figueroa

student•

Clase 04 - Tratamiento de datos faltantes

https://www.youtube.com/watch?v=NtAX81IuiNY Universidad de Buenos Aires

def missing_mosaic_plot(
        self,
        target_var: str,
        x_categorical_var: str,
        y_categorical_var: str,
        ax = None
    ):
        return (
            self._obj
            .assign(
                **{target_var: lambda df: df.weight.isna().replace([True, False], ["NA", "!NA"])}
            )
            .groupby(
                [x_categorical_var, y_categorical_var, target_var],
                dropna=False,
                as_index=True,
            )
            .size()
            .pipe(
                lambda df: mosaic(
                    data=df,
                    properties=lambda key: {"color": "r" if "NA" in key else "gray"},
                    ax=ax,
                    horizontal=True,
                    axes_label=True,
                    title="",
                    labelizer=lambda key: "",
                )
            )
        )

fig, ax = plt.subplots(figsize=(10,10))

(
    nhanes_df
    .select_columns('weight','general_health_condition','gender')
    .assign(
        weight = lambda df: df.weight.isna().replace([True,False],['NA','!NA'])
    )
    .groupby(
        ['gender','general_health_condition','weight'],
        dropna=False,
        as_index = True
    )
    .size()
    .pipe(
        lambda df: mosaic(
            data = df,
            properties=lambda key: {'color':'r' if 'NA' in key else 'gray'},
            horizontal=True,
            axes_label=True,
            title='',
            labelizer=lambda key: '',
            ax = ax
        )
    )
);

def missing_mosaic_plot(df, cat1, cat2, var):
    fig, ax = plt.subplots(figsize=(10,10))
    
    my_mosaic = (
            df
            [[cat1, cat2, var]]
            .assign(
                **{
                    var: lambda df: df[var].isna().replace([False, True], ['!NA', 'NA'])
                }    
            )
            .groupby(
                [
                    cat1,
                    cat2,
                    var
                ],
                dropna=False,
                as_index=True
            )
            .size()
            .pipe(
                lambda df: mosaic(
                    df,
                    properties=lambda key: {
                        'color': 'r' if 'NA' in key else 'c'
                    },
                    horizontal=True,
                    axes_label=True,
                    title='',
                    labelizer=lambda key: '',
                    ax= ax
                )
            )
        )

    # plt.show()

    return my_mosaic

missing_mosaic_plot(nhanes_df, 'gender','general_health_condition', 'pulse')

def missing_mosaic_plot(
        self,
        categorical_variable_1: str,
        categorical_variable_2: str,
        missing_data_variable, str,
):

    fig, ax = plt.subplots(figsize = (15, 10))

    (
        self
        .select_columns(f"{missing_data_variable}", f"{categorical_variable_1}", f"{categorical_variable_2}")
        .assign(
            weight = lambda df : df[f"{missing_data_variable}"].isna().replace([True, False], ["NA", "¡NA"])
        )
        .groupby(
            [f"{categorical_variable_1}", f"{categorical_variable_2}", f"{missing_data_variable}"],
            dropna = False,
            as_index = True
        )
        .size()
        .pipe(
            lambda df : mosaic(
                data = df,
                properties = lambda key : {"color":"r" if "NA" in key else "gray"},
                horizontal = True,
                axes_label = True,
                title = " ",
                
                labelizer = lambda key: " ",
                ax = ax
            )
        )

    ) ;

def create_mosaic_plot(df, var1, var2, var3, figsize=(10,10)):
    """
    Crea un diagrama de mosaico para visualizar la relación entre tres variables,
    resaltando los valores faltantes.
    
    Parámetros:
    -----------
    df : pandas.DataFrame
        DataFrame de entrada
    var1 : str
        Primera variable (se usará para agrupar)
    var2 : str
        Segunda variable (se usará para agrupar)
    var3 : str
        Tercera variable para verificar valores faltantes
    figsize : tuple, opcional
        Tamaño de la figura, por defecto es (10,10)
        
    Retorna:
    --------
    matplotlib.figure.Figure
        La figura creada
    """
    fig, ax = plt.subplots(figsize=figsize)
    
    (df.select_columns(var1, var2, var3)
        .assign(
            var3 = lambda df: df[var3].isna().replace({True: "NA", False: "!NA"})
        )
        .groupby(
            [var1, var2, "var3"],
            dropna=False,
            as_index=True
        )
        .size()
        .pipe(
            lambda df: mosaic(
                data=df,
                properties=lambda key: {"color": "r" if "NA" in key else "gray"},
                horizontal=True,
                axes_label=True,
                labelizer=lambda key: "",
                ax=ax
            )
        )
    )
    
    return fig

create_mosaic_plot(nhanes_df, "gender", "general_health_condition", "weight")

Amplía tu conjunto de herramientas para explorar valores faltantes

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?