Visualización de valores faltantes en dos variables

Clase 15 de 21 • Curso de Manejo de Datos Faltantes: Detección y Exploración

Jeinfferson Bernal G

student•

Codigo de la funcion que permite completar los datos faltante para poder graficar el scatterplot

# funcion que añade valores aleatorios a las variables con valores faltantes
# para visualizarlos en un eje
def column_fill_with_dummies(
    column: pd.Series,
    proportion_below: float=0.10, #Proporcion de los datos en la grafica 
    jitter: float=0.075,  # evita el asolapamiento de los puntos en la grafica
    seed: int=42, #semilla para la aleatoriedad
) -> pd.Series: # la funcion retorna una serie

    #Copiar las columnas del dataframe
    column = column.copy(deep=True)

    #Extraer los valores de las variables
    missing_mask = column.isna() # matriz de booleanos
    number_missing_values = missing_mask.sum() #conteo de valores faltantes
    column_range = column.max() - column.min() #rango de las variables

    # shift data
    column_shift = column.min() - column.min() * proportion_below

    # crear un poco de ruido alrededor de los puntos 
    np.random.seed(seed)
    column_jitter = (np.random.rand(number_missing_values) - 2) * column_range * jitter

    #Guardar los nuevos datos aleatorios
    column[missing_mask] = column_shift + column_jitter

    return column

Ian Cristian Ariel Yané

student•

No se como aria sin tus resúmenes al final de cada vídeo

Jeinfferson Bernal G

student•

Visualizacion de valores faltantes en dos variables

Permite visualizar y comparar dos variables cuando a ambas le faltan valores. Un grafico muy util para este tipo de comparaciones son los scatterplot

Para este ejemplo, los puntos azules indican que existe valores tanto para la temperatura como para la humedad. Los puntos rojos indican que solo hay valores para una de las variables y no para la otra. Este tipo de grafica nos ayuda a conocer donde estan agrupados los valores faltantes respecto a otras variables y se grafican fuera de la presencia de los puntos reales para que no introduzcan ruido.

Ademas podemos incluir otro tipo de graficos como los boxplot que nos ayudan a compara la distribucion de los datos de las variables con la distribucion de los datos faltantes y a visualizar si se estan acumulando en un espacio del scatterplot

Este tipo de analisis es importante porque al realizar un EDA sobre los datos faltantes queremos saber si estos siguen una relacion, una tendencia, un comportamiento caracteristico que podamos rellenar segun su variabilidad.

José Fernando Aguilar Arredondo

student•

El sentido de la vida, el universo y todo lo demás: El número 42

Juan Jose Sepulveda Calderon

student•

No había captado la referencia hasta que vi el artículo de Wikipedia 😄

Ian Cristian Ariel Yané

student•

Claramente el profe tiene un IQ destacable!!, hace rato me aparece el libro de esa saga en los recomendados.. Sera que llego la hora de ver su resumen ?!!!

Carlos Mazzaroli

student•

la función column_fill_with dummies debería ir en la carpeta de los utils? 👀

Juan Jose Sepulveda Calderon

student•

Referencia a la guía del autoestopista galáctico 👀

Daniel Andres Rojas Paredes

student•

no me quedo claro el proposito y la naturaleza de la funcion missing _mask utilizada en la clase.?

Nestor Colmenarez

student•

El concepto de semilla no me quedo claro? que es lo que estamos creando alli?

Diego Cesar Lerma Torres

student•

Dejo mi solución al reto: Función nullity_scatterplot```js def nullity_scatterplot( self, x:str, y:str, **kwargs ): """Recieves a DataFrame and 2 strings with the names of the columns to be used as x and y. Plots a nullity scatterplot"""

    return(
        self._obj.select_dtypes(
                exclude='category'
            )
            .pipe(
                lambda df : df[df.columns[df.isna().any()]]
            )
            .missing.bind_shadow_matrix(true_string=True, false_string=False)
            .apply(
                lambda column: column if "_NA" in column.name else column.missing.column_fill_with_dummies(
                    proportion_below=0.05, 
                    jitter=0.075)
            )
            .assign(
                nullity = lambda df:df[x+'_NA'] | df[y+'_NA']
            )
            .pipe(
                lambda df:(
                    sns.scatterplot(
                        data=df, 
                        x=x,
                        y=y,
                        hue='nullity'
                    )
                )
            )
    )


Entonces la implementaríamos al final del archivo de la siguiente manera:
```js
@pd.api.extensions.register_series_accessor("missing")
class MissingSeriesMethods:
    def __init__(self, pandas_obj):
        self._obj = pandas_obj

    def column_fill_with_dummies(
        self,
        proportion_below: float = 0.10,
        jitter: float = 0.075,
        seed: int = 42
    ) -> pd.Series:
        """Fills a column with missing values with dummies, to be used in a scatterplot"""

        # We don't need to copy the original series because we're not modifying it in place
        # We're going to create a new series for the dummy data

        # Extract values metadata
        missing_mask = self._obj.isna()
        number_missing_values = missing_mask.sum()
        column_range = self._obj.max() - self._obj.min()

        # Shift data
        column_shift = self._obj.min() - self._obj.min() * proportion_below

        # Create the "jitter" (noise) to be added around the points
        np.random.seed(seed)
        column_jitter = (np.random.rand(number_missing_values) - 2) * column_range * jitter

        # Create new series for dummy data with the same index as the missing values in the original series
        dummy_data = pd.Series(column_shift + column_jitter, index=self._obj[missing_mask].index)

        # Return a series combining original and dummy data
        return self._obj.fillna(dummy_data)

Iván Roberto Rivas Celeita

student•

la semilla de aleatoridad permite que el experimento se puede volver a reproducir bajo las mismas condiciones. Puede ser cualquier 42 o cualquier numero

Julián Cárdenas

student•

def column_fill_with_dummies(
    column: pd.Series,
    proportion_below: float=0.10,
    jitter: float=0.075,
    seed: int=42
) -> pd.Series:

    column = column.copy(deep=True)

    # Extract values metadata.
    missing_mask = column.isna()
    number_missing_values = missing_mask.sum()
    column_range = column.max() - column.min()

    # Shift data
    column_shift = column.min() - column.min() * proportion_below

    # Create the "jitter" (noise) to be added around the points.
    np.random.seed(seed)
    column_jitter = (np.random.rand(number_missing_values) - 2) * column_range * jitter

    # Save new dummy data.
    column[missing_mask] = column_shift + column_jitter

    return column

jhon velasque

student•

def colum_fill_dummies(
    column:pd.Series,  # La columna que se debe procesar
    proportion_bellow:float =0.10,  # Porcentaje para determinar el valor mínimo
    jitter:float=0.075,  # Valor para crear "jitter" en los valores dummies
    seed:int=42  # Semilla para la función de números aleatorios
) -> pd.Series:  # La función devuelve una columna "Series" de pandas
    # Copiar la columna de entrada
    column=column.copy(deep=True)
    
    # Obtener máscara de valores faltantes y número de valores faltantes
    missing_mask=column.isna()
    number_missing_values=missing_mask.sum()
    
    # Calcular el rango de valores de la columna
    column_range=column.max()-column.min()
    
    # Calcular el valor mínimo de la columna con el porcentaje especificado
    column_shift=column.min()-column.min()*proportion_bellow
    
    # Crear "jitter" utilizando números aleatorios y el rango de la columna
    np.random.seed(seed)
    column_jitter=(np.random.rand(number_missing_values)-2)*column_range*jitter
    
    # Reemplazar valores faltantes con valores dummies creados
    column[missing_mask]=column_shift+column_jitter
    
    # Devolver la columna modificada
    return column

Mario Alexander Vargas Celis

student•

Para visualizar los valores faltantes en dos variables de un conjunto de datos, puedes usar varias técnicas que permiten comparar la relación entre las dos variables y cómo los valores faltantes están distribuidos entre ellas. A continuación te muestro algunas técnicas comunes para visualizar esta información.

### 1. Gráfico de Dispersión con Colores que Indiquen los Valores Faltantes

Puedes crear un gráfico de dispersión para comparar dos variables, usando colores diferentes para mostrar si alguno de los puntos tiene valores faltantes en alguna de las variables.


import pandas as pd

import seaborn as sns

import matplotlib.pyplot as plt



\# Crear un DataFrame de ejemplo con valores faltantes

data = {'Variable1': \[1, 2, None, 4, 5, 6, 7, None, 9, 10],

&#x20;       'Variable2': \[5, None, 7, None, 9, 10, None, 12, 13, 14]}

df = pd.DataFrame(data)



\# Crear una nueva columna que identifique si hay valores faltantes en alguna de las dos variables

df\['Missing'] = df.isnull().any(axis=1)



\# Visualizar con un gráfico de dispersión

plt.figure(figsize=(8, 6))

sns.scatterplot(x='Variable1', y='Variable2', hue='Missing', data=df, palette='coolwarm')

plt.title('Valores Faltantes en Dos Variables')

plt.show()

### 2. Gráfico de Mapa de Calor para Mostrar Correlación de Faltantes

Otra técnica es un mapa de calor que indica la correlación de valores faltantes entre dos o más variables, permitiendo ver si los valores faltantes en una variable coinciden con los faltantes en otra.


import seaborn as sns

import matplotlib.pyplot as plt

import pandas as pd



\# Crear un DataFrame de ejemplo con valores faltantes

data = {'Variable1': \[1, None, 3, 4, 5, None, 7, 8, 9, None],

&#x20;       'Variable2': \[None, 2, 3, None, 5, 6, None, 8, None, 10]}

df = pd.DataFrame(data)



\# Visualización de valores faltantes con un mapa de calor

plt.figure(figsize=(6, 4))

sns.heatmap(df.isnull(), cmap='coolwarm', cbar=False, yticklabels=False)

plt.title('Mapa de Calor de Valores Faltantes en Dos Variables')

plt.show()

### 3. Gráfico de Barras Apiladas

Otra opción es usar un gráfico de barras apiladas para visualizar la proporción de valores faltantes en dos variables. Esto permite ver claramente qué porcentaje de los datos está presente o ausente.


import pandas as pd

import seaborn as sns

import matplotlib.pyplot as plt



\# Crear un DataFrame de ejemplo con valores faltantes

data = {'Variable1': \[1, 2, None, 4, 5, None, 7, 8, 9, 10],

&#x20;       'Variable2': \[None, 2, 3, None, 5, None, 7, 8, None, 10]}

df = pd.DataFrame(data)



\# Contar valores faltantes y no faltantes

missing\_counts = df.isnull().sum()

present\_counts = len(df) - missing\_counts



\# Crear DataFrame para el gráfico

bar\_df = pd.DataFrame({'Missing': missing\_counts, 'Present': present\_counts})



\# Gráfico de barras apiladas

bar\_df.T.plot(kind='bar', stacked=True, color=\['red', 'green'])

plt.title('Valores Faltantes en Dos Variables')

plt.xlabel('Variables')

plt.ylabel('Conteo')

plt.show()

### Descripción:

1. **Gráfico de Dispersión**: Permite ver la relación entre dos variables, con los puntos coloreados según si tienen o no valores faltantes.

2. **Mapa de Calor**: Muestra de manera visual qué celdas del DataFrame tienen valores faltantes, utilizando colores.

3. **Gráfico de Barras Apiladas**: Da una vista general de cuántos valores faltantes y presentes hay para cada variable.

Estas visualizaciones ayudan a entender mejor cómo se distribuyen los valores faltantes entre las dos variables, lo que es crucial antes de aplicar técnicas de imputación o limpieza.

¿Te gustaría más ejemplos o alguna ampliación sobre alguno de estos métodos?

# funcion que añade valores aleatorios a las variables con valores faltantes
# para visualizarlos en un eje
def column_fill_with_dummies(
    column: pd.Series,
    proportion_below: float=0.10, #Proporcion de los datos en la grafica 
    jitter: float=0.075,  # evita el asolapamiento de los puntos en la grafica
    seed: int=42, #semilla para la aleatoriedad
) -> pd.Series: # la funcion retorna una serie

    #Copiar las columnas del dataframe
    column = column.copy(deep=True)

    #Extraer los valores de las variables
    missing_mask = column.isna() # matriz de booleanos
    number_missing_values = missing_mask.sum() #conteo de valores faltantes
    column_range = column.max() - column.min() #rango de las variables

    # shift data
    column_shift = column.min() - column.min() * proportion_below

    # crear un poco de ruido alrededor de los puntos 
    np.random.seed(seed)
    column_jitter = (np.random.rand(number_missing_values) - 2) * column_range * jitter

    #Guardar los nuevos datos aleatorios
    column[missing_mask] = column_shift + column_jitter

    return column

    return(
        self._obj.select_dtypes(
                exclude='category'
            )
            .pipe(
                lambda df : df[df.columns[df.isna().any()]]
            )
            .missing.bind_shadow_matrix(true_string=True, false_string=False)
            .apply(
                lambda column: column if "_NA" in column.name else column.missing.column_fill_with_dummies(
                    proportion_below=0.05, 
                    jitter=0.075)
            )
            .assign(
                nullity = lambda df:df[x+'_NA'] | df[y+'_NA']
            )
            .pipe(
                lambda df:(
                    sns.scatterplot(
                        data=df, 
                        x=x,
                        y=y,
                        hue='nullity'
                    )
                )
            )
    )

Entonces la implementaríamos al final del archivo de la siguiente manera:
```js
@pd.api.extensions.register_series_accessor("missing")
class MissingSeriesMethods:
    def __init__(self, pandas_obj):
        self._obj = pandas_obj

    def column_fill_with_dummies(
        self,
        proportion_below: float = 0.10,
        jitter: float = 0.075,
        seed: int = 42
    ) -> pd.Series:
        """Fills a column with missing values with dummies, to be used in a scatterplot"""

        # We don't need to copy the original series because we're not modifying it in place
        # We're going to create a new series for the dummy data

        # Extract values metadata
        missing_mask = self._obj.isna()
        number_missing_values = missing_mask.sum()
        column_range = self._obj.max() - self._obj.min()

        # Shift data
        column_shift = self._obj.min() - self._obj.min() * proportion_below

        # Create the "jitter" (noise) to be added around the points
        np.random.seed(seed)
        column_jitter = (np.random.rand(number_missing_values) - 2) * column_range * jitter

        # Create new series for dummy data with the same index as the missing values in the original series
        dummy_data = pd.Series(column_shift + column_jitter, index=self._obj[missing_mask].index)

        # Return a series combining original and dummy data
        return self._obj.fillna(dummy_data)

def column_fill_with_dummies(
    column: pd.Series,
    proportion_below: float=0.10,
    jitter: float=0.075,
    seed: int=42
) -> pd.Series:

    column = column.copy(deep=True)

    # Extract values metadata.
    missing_mask = column.isna()
    number_missing_values = missing_mask.sum()
    column_range = column.max() - column.min()

    # Shift data
    column_shift = column.min() - column.min() * proportion_below

    # Create the "jitter" (noise) to be added around the points.
    np.random.seed(seed)
    column_jitter = (np.random.rand(number_missing_values) - 2) * column_range * jitter

    # Save new dummy data.
    column[missing_mask] = column_shift + column_jitter

    return column

def colum_fill_dummies(
    column:pd.Series,  # La columna que se debe procesar
    proportion_bellow:float =0.10,  # Porcentaje para determinar el valor mínimo
    jitter:float=0.075,  # Valor para crear "jitter" en los valores dummies
    seed:int=42  # Semilla para la función de números aleatorios
) -> pd.Series:  # La función devuelve una columna "Series" de pandas
    # Copiar la columna de entrada
    column=column.copy(deep=True)
    
    # Obtener máscara de valores faltantes y número de valores faltantes
    missing_mask=column.isna()
    number_missing_values=missing_mask.sum()
    
    # Calcular el rango de valores de la columna
    column_range=column.max()-column.min()
    
    # Calcular el valor mínimo de la columna con el porcentaje especificado
    column_shift=column.min()-column.min()*proportion_bellow
    
    # Crear "jitter" utilizando números aleatorios y el rango de la columna
    np.random.seed(seed)
    column_jitter=(np.random.rand(number_missing_values)-2)*column_range*jitter
    
    # Reemplazar valores faltantes con valores dummies creados
    column[missing_mask]=column_shift+column_jitter
    
    # Devolver la columna modificada
    return column

import pandas as pd

import seaborn as sns

import matplotlib.pyplot as plt

\# Crear un DataFrame de ejemplo con valores faltantes

data = {'Variable1': \[1, 2, None, 4, 5, 6, 7, None, 9, 10],

&#x20;       'Variable2': \[5, None, 7, None, 9, 10, None, 12, 13, 14]}

df = pd.DataFrame(data)

\# Crear una nueva columna que identifique si hay valores faltantes en alguna de las dos variables

df\['Missing'] = df.isnull().any(axis=1)

\# Visualizar con un gráfico de dispersión

plt.figure(figsize=(8, 6))

sns.scatterplot(x='Variable1', y='Variable2', hue='Missing', data=df, palette='coolwarm')

plt.title('Valores Faltantes en Dos Variables')

plt.show()

import seaborn as sns

import matplotlib.pyplot as plt

import pandas as pd

\# Crear un DataFrame de ejemplo con valores faltantes

data = {'Variable1': \[1, None, 3, 4, 5, None, 7, 8, 9, None],

&#x20;       'Variable2': \[None, 2, 3, None, 5, 6, None, 8, None, 10]}

df = pd.DataFrame(data)

\# Visualización de valores faltantes con un mapa de calor

plt.figure(figsize=(6, 4))

sns.heatmap(df.isnull(), cmap='coolwarm', cbar=False, yticklabels=False)

plt.title('Mapa de Calor de Valores Faltantes en Dos Variables')

plt.show()

import pandas as pd

import seaborn as sns

import matplotlib.pyplot as plt

\# Crear un DataFrame de ejemplo con valores faltantes

data = {'Variable1': \[1, 2, None, 4, 5, None, 7, 8, 9, 10],

&#x20;       'Variable2': \[None, 2, 3, None, 5, None, 7, 8, None, 10]}

df = pd.DataFrame(data)

\# Contar valores faltantes y no faltantes

missing\_counts = df.isnull().sum()

present\_counts = len(df) - missing\_counts

\# Crear DataFrame para el gráfico

bar\_df = pd.DataFrame({'Missing': missing\_counts, 'Present': present\_counts})

\# Gráfico de barras apiladas

bar\_df.T.plot(kind='bar', stacked=True, color=\['red', 'green'])

plt.title('Valores Faltantes en Dos Variables')

plt.xlabel('Variables')

plt.ylabel('Conteo')

plt.show()

Visualización de valores faltantes en dos variables

Introducción a los valores faltantes

¿Por qué explorar y lidiar con valores faltantes?

Operaciones con valores faltantes

Conociendo datasets para manejo de datos faltantes

Ejecución de Notebooks en Deepnote con %run

Extendiendo la API de Pandas

Tabulación de valores faltantes

Visualización de valores faltantes

Manipulación inicial de valores faltantes

Codificación de valores faltantes

Conversión de valores faltantes implícitos en explícitos

Exponer filas faltantes implícitas en explícitas

Tipos de valores faltantes

MCAR, MAR, MNAR en Python

Búsqueda de relaciones de valores faltantes

Matriz de sombras: shadow matrix

Visualización de valores faltantes en una variable

Visualización de valores faltantes en dos variables

Scatterplot con valores faltantes

Correlación de nulidad

Tratamiento de valores faltantes

Eliminación de valores faltantes: pairwise y listwise

Imputación básica de datos

Bonus: visualización múltiple de imputaciones

Cierre de curso

Continúa aprendiendo sobre el manejo de valores faltantes