Operaciones con valores faltantes

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

Jeinfferson Bernal G

student•

Aprender otro idioma no es solo aprender diferentes palabras para las mismas cosas, sino aprender otra forma de pensar sobre las cosas

En Python, None no tiene definido operaciones con valores numericos, booleanos… Ademas al comparar los None (==) ó utilizar la funcion is, arroja True
En Numpy, los valores faltantes se representan con nan y tienen definido operaciones con valores numericos ya que es de tipo float. Por otro lado, al comparar los None arroja False es decir, que no son el mismo objeto y al compararlos mediante la funcion is arroja True es decir que un nan esta contenido en otro nana. Tener cuidado
En Pandas, existen varias maneras de representar los valores faltantes (nan, <NA>, None)

Funciones para buscar valores nulos en Pandas

nombre_df.isna()
nombre_df.isnull()

Buscar valores faltantes en una columna del DataFrame

nombre_df.nombre_columna.isnull()

Pablo Alejandro Figueroa

student•

Gracias.:!

Benjamín Cortés

student•

si al importar janitor les devuelve un error 'type'

!pip uninstall pyjanitor --yes

y vuelvan a instalarlo pero agreguenle la versión

!pip install pyjanitor==0.23.1

ahi vulven a importar y ya en teoría les tendría que funcionar <3

Esteban Navarro Díaz

student•

Para la versión de python 3.11 sigue dando problemas la librería pyjanitor. A mi me está sirviendo en python 3.9.7

Noel Felipe Delgado Ortiz

student•

perfecto, me funciono en la terminal, ejecutando pip install pyjanitor==0.23.1

Anabel Chavez Berumen

student•

== >>True cuando son iguales. IS >>True cuando ambos apuntan al mismo objeto.

np.nan == np.nan # is always False! Use special numpy functions instead.

Ian Cristian Ariel Yané

student•

Es correcto, esa linea de código, a mi también me devolvió "True".

Pablo Alejandro Figueroa

student•

gracias..!

Bryan Carvajal

student•

Aproveche para poner en practica lo aprendido en el curso de entornos de trabajos (cookiecutter) para crear la estructura de carpetas y trabajar mis notebooks desde VSC, no tuve problemas como en deepnote

Sebastian Lopez Acero

student•

concuerdo, vengo del mismo curso y ya es intuitivo

Jhon Freddy Tavera Blandon

student•

Las operaciones con valores faltantes se refieren a las que debes tomar al trabajar con datos que contienen valores ausentes o datos acciones faltantes. Es fundamental abordar estos valores de manera adecuada para garantizar la precisión y la integridad de tus análisis y modelos estadísticos. Aquí, explicaré en detalle algunos conceptos claves relacionados con las operaciones de datos faltantes:

1. Valores faltantes (Missing Values):

Son valores que faltan o no están disponibles en un conjunto de datos en una o más ubicaciones. Pueden ser denotados por diferentes convenciones, como "NaN" (Not a Number) en Python o "NULL" en SQL.

2. Tipos de valores faltantes:

Valores faltantes completamente al azar (MCAR):

Ocurren de manera completamente aleatoria y no hay relación entre la falta de datos y ninguna otra variable o razón.

Valores faltantes aleatorios (MAR):

La falta de datos está relacionada con otras variables observadas en el conjunto de datos, pero no con los valores faltantes en sí.

Valores faltantes no aleatorios (MNAR):

La falta de datos está relacionada con los valores faltantes en sí. Esto puede deberse a factores que no están registrados en el conjunto de datos.

3. Exploración de datos faltantes:

Antes de abordar los valores faltantes, es importante realizar un análisis exploratorio para identificar la cantidad y la ubicación de los datos faltantes en tus datos.

4. Tratamiento de valores faltantes:

Hay varias estrategias para tratar los valores faltantes:

Eliminación de filas o columnas:

Puedes eliminar filas o columnas que contengan valores faltantes si la cantidad de datos faltantes es pequeña o si no son críticos para tu análisis.

Imputación:

Implica reemplazar los valores faltantes por estimaciones basadas en otros datos. Puedes utilizar estadísticas como la media, la mediana o la moda para imputar valores faltantes, o incluso modelos de regresión para predecir valores faltantes a partir de datos existentes.

Técnicas avanzadas:

También puedes utilizar técnicas más avanzadas, como la imputación múltiple, para manejar datos faltantes de manera más sofisticada.

5. Impacto en análisis y modelos:

Es importante comprender cómo los valores faltantes pueden afectar tus análisis y modelos. Pueden introducir segundos, disminuir la precisión y afectar la interpretación de los resultados.

6. Imputación de valores faltante

La imputación es el proceso de estimar o reemplazar los valores faltantes con valores calculados.

7. Evaluación del tratamiento de datos faltantes:

Después de tratar los datos faltantes, debes evaluar cómo afecta esto a tu análisis. Esto puede incluir la comparación de resultados antes y después del tratamiento y la consideración de la solidez de tus conclusiones.

8. Documentación y transparencia:

Es fundamental documentar y comunicar claramente cómo has manejado los valores faltantes en tus análisis. Esto asegura la reproducibilidad y la comprensión de tu trabajo por parte de otros.

operaciones con valores faltantes son esenciales en el análisis de datos. Debes identificar, comprender y tratar adecuadamente los valores faltantes para garantizar la calidad y la precisión de tus análisis y modelos. La elección de la estrategia de manejo de datos faltantes dependerá del contexto específico de tus datos y del objetivo de tu análisis.

Pablo Alejandro Figueroa

student•

gracias.:!

jhon velasque

student•

CODIGO DE PANDAS

test_missing_df = pd.DataFrame.from_dict(
    data=dict(
        x=[0, 1, np.nan, np.nan, None],
        y=[0, 1, pd.NA, np.nan, None]
    )
)

Roger Christian Cansaya Olazabal

student•

El curso que faltaba

Tomas Pucutay

student•

Por si alguien no entiende mucho de los presets que coloca para los gráficos:

%matplotlib inline

No es necesario colocarlo ni en Google Colab, ni en Deepnote, ni incluso Visual Studio Code, ya que estos entornos lo tienen por defecto incluido, incluso así es una buena práctica colocarlo. En Jupyter Notebooks los gráficos salen como una ventana emergente, cuando colocas este código aparecen debajo de la celda que lo ejecuta (es decir como siempre lo vemos en Colab o Deepnote)

sns.set(rc = {"figure.figsize": (10, 10)})
sns.set_style("whitegrid")

La documentación de Seaborn indica que seaborn.set podría desaparecer en el futuro y que es un alias para seaborn.set_theme. Por lo que sería más conveniente usar set_theme. Además set_theme es un método general que acepta todo (style, font, context, etc). Dicho esto, las 2 líneas de código se pueden resumir a:

sns.set_theme(style="whitegrid", rc = {"figure.figsize": (10, 10)})

Pablo Alejandro Figueroa

student•

gracias...!!

Miguel Antonio Rojas Martinez

student•

Estoy usando Python 3.10.6 y usando este requirements.txt al menos me deja iniciarpyjanitor==0.26.0missingno==0.5.2numpy==1.26.4matplotlib==3.8.3pandas==2.2.1pyreadr==0.5.0seaborn==0.13.2session-info==1.0.0upsetplot==0.9.0 Estoy apenas empezando, pero debi cambiar las versiones para poder hacerlo. quizas a alguien mas le sirva

pyjanitor==0.26.0
missingno==0.5.2
numpy==1.26.4
matplotlib==3.8.3
pandas==2.2.1
pyreadr==0.5.0
seaborn==0.13.2
session-info==1.0.0
upsetplot==0.9.0

Diego Cesar Lerma Torres

student•

Les dejo el código del archivo pandas-missing-extension corregido para que no anden batallando, porque vengo del futuro y da error en algunas partes

Simplemente vayan al archivo pandas-missing-extension.ipynb y cambien el código que hay allí por esto

import itertools
import pandas as pd
import upsetplot

try:
    del pd.DataFrame.missing
except AttributeError:
    pass

@pd.api.extensions.register_dataframe_accessor("missing")
class MissingMethods:
    def __init__(self, pandas_obj):
        self._obj = pandas_obj

    def number_missing(self) -> int:
        return self._obj.isna().sum().sum()

    def number_complete(self) -> int:
        return self._obj.size - self._obj.missing.number_missing()

    def missing_variable_summary(self) -> pd.DataFrame:
        return self._obj.isnull().pipe(
            lambda df_1: (
                df_1.sum()
                .reset_index(name="n_missing")
                .rename(columns={"index": "variable"})
                .assign(
                    n_cases=len(df_1),
                    pct_missing=lambda df_2: df_2.n_missing / df_2.n_cases * 100,
                )
            )
        )

    def missing_case_summary(self) -> pd.DataFrame:
        return self._obj.assign(
            case=lambda df: df.index,
            n_missing=lambda df: df.apply(
                axis="columns", func=lambda row: row.isna().sum()
            ),
            pct_missing=lambda df: df["n_missing"] / df.shape[1] * 100,
        )[["case", "n_missing", "pct_missing"]]

    def missing_variable_table(self) -> pd.DataFrame:
        return (
            self._obj.missing.missing_variable_summary()
            .value_counts("n_missing")
            .reset_index(name="n_variables")
            .rename(columns={"n_missing": "n_missing_in_variable"})
            .assign(
                pct_variables=lambda df: df.n_variables / df.n_variables.sum() * 100
            )
            .sort_values("pct_variables", ascending=False)
        ) 

    def missing_case_table(self) -> pd.DataFrame():
        return (
            self._obj.missing.missing_case_summary()
            .value_counts("n_missing")
            .reset_index(name="n_cases")
            .rename(columns={"n_missing": "n_missing_in_case"})
            .assign(pct_case=lambda df: df.n_cases / df.n_cases.sum() * 100)
            .sort_values("pct_case", ascending=False)
        )

    def missing_variable_span(self, variable: str, span_every: int) -> pd.DataFrame:
        return (
            self._obj.assign(
                span_counter=lambda df: (
                    np.repeat(a=range(df.shape[0]), repeats=span_every)[: df.shape[0]]
                )
            )
            .groupby("span_counter")
            .aggregate(
                n_in_span=(variable, "size"),
                n_missing=(variable, lambda s: s.isnull().sum()),
            )
            .assign(
                n_complete=lambda df: df.n_in_span - df.n_missing,
                pct_missing=lambda df: df.n_missing / df.n_in_span * 100,
                pct_complete=lambda df: 100 - df.pct_missing,
            )
            .drop(columns=["n_in_span"])
            .reset_index()
        )

    def missing_variable_run(self, variable) -> pd.DataFrame:
        rle_list = self._obj[variable].pipe(
            lambda s: [[len(list(g)), k] for k, g in itertools.groupby(s.isnull())]
        )

        return pd.DataFrame(data=rle_list, columns=["run_length", "is_na"]).replace(
            {False: "complete", True: "missing"}
        )

    def sort_variables_by_missingness(self, ascending = False):

        return (
            self._obj
            .pipe(
                lambda df: (
                    df[df.isna().sum().sort_values(ascending = ascending).index]
                )
            )
        )

    def create_shadow_matrix(
        self,
        true_string: str = "Missing",
        false_string: str = "Not Missing",
        only_missing: bool = False,
    ) -> pd.DataFrame:
        return (
            self._obj
            .isna()
            .pipe(lambda df: df[df.columns[df.any()]] if only_missing else df)
            .replace({False: false_string, True: true_string})
            .add_suffix("_NA")
        )

    def bind_shadow_matrix(
        self,
        true_string: str = "Missing",
        false_string: str = "Not Missing",
        only_missing: bool = False,
    ) -> pd.DataFrame:
        return pd.concat(
            objs=[
                self._obj,
                self._obj.missing.create_shadow_matrix(
                    true_string=true_string,
                    false_string=false_string,
                    only_missing=only_missing
                )
            ],
            axis="columns"
        )

    def missing_scan_count(self, search) -> pd.DataFrame:
        return (
            self._obj.apply(axis="rows", func=lambda column: column.isin(search))
            .sum()
            .reset_index()
            .rename(columns={"index": "variable", 0: "n"})
            .assign(original_type=self._obj.dtypes.reset_index()[0])
        )

    # Plotting functions ---

    def missing_variable_plot(self):
        df = self._obj.missing.missing_variable_summary().sort_values("n_missing")

        plot_range = range(1, len(df.index) + 1)

        plt.hlines(y=plot_range, xmin=0, xmax=df.n_missing, color="black")

        plt.plot(np.array(df.n_missing), plot_range, 'o', color="black")
       
        plt.yticks(plot_range, df.variable)

        plt.grid(axis="y")

        plt.xlabel("Number missing")
        plt.ylabel("Variable")

    def missing_case_plot(self):

        df = self._obj.missing.missing_case_summary()

        sns.displot(data=df, x="n_missing", binwidth=1, color="black")

        plt.grid(axis="x")
        plt.xlabel("Number of missings in case")
        plt.ylabel("Number of cases")

    def missing_variable_span_plot(
        self, variable: str, span_every: int, rot: int = 0, figsize=None
    ):

        (
            self._obj.missing.missing_variable_span(
                variable=variable, span_every=span_every
            ).plot.bar(
                x="span_counter",
                y=["pct_missing", "pct_complete"],
                stacked=True,
                width=1,
                color=["black", "lightgray"],
                rot=rot,
                figsize=figsize,
            )
        )

        plt.xlabel("Span number")
        plt.ylabel("Percentage missing")
        plt.legend(["Missing", "Present"])
        plt.title(
            f"Percentage of missing values\nOver a repeating span of { span_every } ",
            loc="left",
        )
        plt.grid(False)
        plt.margins(0)
        plt.tight_layout(pad=0)

    def missing_upsetplot(self, variables: list[str] = None, **kwargs):

        if variables is None:
            variables = self._obj.columns.tolist()

        return (
            self._obj.isna()
            .value_counts(variables)
            .pipe(lambda df: upsetplot.plot(df, **kwargs))
        )

Amaury Antonio Avila Martinez

student•

Estas son las librerías que se utilizan en el curso.

Janitor. Lo utilizamos para limpieza de datos. Matplotlib. Para la visualización. Missingno. Para visualizar valores faltantes. Numpy y pandas. Para realizar computo científico en Python. Pyreadr. Para leer archivos. Seaborn. Para visualización estadística. Session_info. Para tener un registro de las librerías usadas. Upsetplot. Para realizar gráfico.

Jhon Freddy Tavera Blandon

student•

En resumen, las operaciones con valores faltantes son esenciales en el análisis de datos. Debes identificar, comprender y tratar adecuadamente los valores faltantes para garantizar la calidad y la precisión de tus análisis y modelos. La elección de la estrategia de manejo de datos faltantes dependerá del contexto específico de tus datos y del objetivo de tu análisis.

Iván Roberto Rivas Celeita

student•

detesto deepnote, me quedo mil veces con jupyter.

mundial andrs

student•

Es curso mas nuevo en mis dos años en platzi

david jurado

student•

Da muchos errores al importar las librerias, tanto en deepnote como en vsc alguien sabe solucionar los errores?

DIEGO ALEJANDRO BAUTISTA LINDARTE

student•

Hola muchachos, como están ?, me sale este error al tratar de instalar las librerias: Ejecuto este código:

pip install --upgrade pip
pip install pyjanitor matplotlib==3.5.1 missingno numpy pandas pyreadr seaborn session-info upsetplot==0.6.1

Luego me arroja este error:

ERROR: Could not install packages due to an OSError: [Errno 30] Read-only file system: 'WHEEL'

No sé cual podría ser el inconveniente.

Leandro Tenjo

student•

¿Estás en Notebook o en la Terminal? … Si es en Notebook, agrega un ! antes de cada instruction. Eso debería bastar.

Félix Alberto Uc Hernández

student•

FelixUcTech/Py-Data-Analysis les dejo mi repo, es la carpeta número A04 correspondiente a este curso tengo enriquecida todas las notas de esta clase.

Rodrigo Martinez

student•

Mi momento favorito de la clase 10:15

Pedro Alejandro Rodríguez García

student•

Al inicio me aparecía un error al importar janitor, pero utilizar la siguiente versión resolvió el problema :D

pyjanitor==0.26.0
```pyjanitor==0.26.0

Dennis Ricardo López Morell

student•

Con esto cree mi entorno virtual


\#Crear un entorno llamado detección con python 3.9

conda create --name deteccion python=3.9

\#Para que sea más rápido lo haré con mamba

mamba create --name deteccion python=3.9

\#activar el entorno

conda activate deteccion

\#instalar las dependencias desde requirements.txt

mamba install --file requirements.txt

\#crear archivo requirements.txt si no lo tengo

mamba env export > requirements.txt

Abre un bloc de notas y guarda el siguiente contenido como "requirements.txt"

pyjanitor

missingno

numpy

matplotlib==3.5.1

pandas

pyreadr

seaborn

session-info

upsetplot==0.6.1

jupyter

jupyterlab

PS: Espero funcione bien jajaa saludos!

Dennis Ricardo López Morell

student•

Corrección: mamba env export > requirements.txt

@pd.api.extensions.register_dataframe_accessor("missing")
class MissingMethods:
    def __init__(self, pandas_obj):
        self._obj = pandas_obj

    def number_missing(self) -> int:
        return self._obj.isna().sum().sum()

    def number_complete(self) -> int:
        return self._obj.size - self._obj.missing.number_missing()

    def missing_variable_summary(self) -> pd.DataFrame:
        return self._obj.isnull().pipe(
            lambda df_1: (
                df_1.sum()
                .reset_index(name="n_missing")
                .rename(columns={"index": "variable"})
                .assign(
                    n_cases=len(df_1),
                    pct_missing=lambda df_2: df_2.n_missing / df_2.n_cases * 100,
                )
            )
        )

    def missing_case_summary(self) -> pd.DataFrame:
        return self._obj.assign(
            case=lambda df: df.index,
            n_missing=lambda df: df.apply(
                axis="columns", func=lambda row: row.isna().sum()
            ),
            pct_missing=lambda df: df["n_missing"] / df.shape[1] * 100,
        )[["case", "n_missing", "pct_missing"]]

    def missing_variable_table(self) -> pd.DataFrame:
        return (
            self._obj.missing.missing_variable_summary()
            .value_counts("n_missing")
            .reset_index(name="n_variables")
            .rename(columns={"n_missing": "n_missing_in_variable"})
            .assign(
                pct_variables=lambda df: df.n_variables / df.n_variables.sum() * 100
            )
            .sort_values("pct_variables", ascending=False)
        ) 

    def missing_case_table(self) -> pd.DataFrame():
        return (
            self._obj.missing.missing_case_summary()
            .value_counts("n_missing")
            .reset_index(name="n_cases")
            .rename(columns={"n_missing": "n_missing_in_case"})
            .assign(pct_case=lambda df: df.n_cases / df.n_cases.sum() * 100)
            .sort_values("pct_case", ascending=False)
        )

    def missing_variable_span(self, variable: str, span_every: int) -> pd.DataFrame:
        return (
            self._obj.assign(
                span_counter=lambda df: (
                    np.repeat(a=range(df.shape[0]), repeats=span_every)[: df.shape[0]]
                )
            )
            .groupby("span_counter")
            .aggregate(
                n_in_span=(variable, "size"),
                n_missing=(variable, lambda s: s.isnull().sum()),
            )
            .assign(
                n_complete=lambda df: df.n_in_span - df.n_missing,
                pct_missing=lambda df: df.n_missing / df.n_in_span * 100,
                pct_complete=lambda df: 100 - df.pct_missing,
            )
            .drop(columns=["n_in_span"])
            .reset_index()
        )

    def missing_variable_run(self, variable) -> pd.DataFrame:
        rle_list = self._obj[variable].pipe(
            lambda s: [[len(list(g)), k] for k, g in itertools.groupby(s.isnull())]
        )

        return pd.DataFrame(data=rle_list, columns=["run_length", "is_na"]).replace(
            {False: "complete", True: "missing"}
        )

    def sort_variables_by_missingness(self, ascending = False):

        return (
            self._obj
            .pipe(
                lambda df: (
                    df[df.isna().sum().sort_values(ascending = ascending).index]
                )
            )
        )

    def create_shadow_matrix(
        self,
        true_string: str = "Missing",
        false_string: str = "Not Missing",
        only_missing: bool = False,
    ) -> pd.DataFrame:
        return (
            self._obj
            .isna()
            .pipe(lambda df: df[df.columns[df.any()]] if only_missing else df)
            .replace({False: false_string, True: true_string})
            .add_suffix("_NA")
        )

    def bind_shadow_matrix(
        self,
        true_string: str = "Missing",
        false_string: str = "Not Missing",
        only_missing: bool = False,
    ) -> pd.DataFrame:
        return pd.concat(
            objs=[
                self._obj,
                self._obj.missing.create_shadow_matrix(
                    true_string=true_string,
                    false_string=false_string,
                    only_missing=only_missing
                )
            ],
            axis="columns"
        )

    def missing_scan_count(self, search) -> pd.DataFrame:
        return (
            self._obj.apply(axis="rows", func=lambda column: column.isin(search))
            .sum()
            .reset_index()
            .rename(columns={"index": "variable", 0: "n"})
            .assign(original_type=self._obj.dtypes.reset_index()[0])
        )

    # Plotting functions ---

    def missing_variable_plot(self):
        df = self._obj.missing.missing_variable_summary().sort_values("n_missing")

        plot_range = range(1, len(df.index) + 1)

        plt.hlines(y=plot_range, xmin=0, xmax=df.n_missing, color="black")

        plt.plot(np.array(df.n_missing), plot_range, 'o', color="black")
       
        plt.yticks(plot_range, df.variable)

        plt.grid(axis="y")

        plt.xlabel("Number missing")
        plt.ylabel("Variable")

    def missing_case_plot(self):

        df = self._obj.missing.missing_case_summary()

        sns.displot(data=df, x="n_missing", binwidth=1, color="black")

        plt.grid(axis="x")
        plt.xlabel("Number of missings in case")
        plt.ylabel("Number of cases")

    def missing_variable_span_plot(
        self, variable: str, span_every: int, rot: int = 0, figsize=None
    ):

        (
            self._obj.missing.missing_variable_span(
                variable=variable, span_every=span_every
            ).plot.bar(
                x="span_counter",
                y=["pct_missing", "pct_complete"],
                stacked=True,
                width=1,
                color=["black", "lightgray"],
                rot=rot,
                figsize=figsize,
            )
        )

        plt.xlabel("Span number")
        plt.ylabel("Percentage missing")
        plt.legend(["Missing", "Present"])
        plt.title(
            f"Percentage of missing values\nOver a repeating span of { span_every } ",
            loc="left",
        )
        plt.grid(False)
        plt.margins(0)
        plt.tight_layout(pad=0)

    def missing_upsetplot(self, variables: list[str] = None, **kwargs):

        if variables is None:
            variables = self._obj.columns.tolist()

        return (
            self._obj.isna()
            .value_counts(variables)
            .pipe(lambda df: upsetplot.plot(df, **kwargs))
        )

\#Crear un entorno llamado detección con python 3.9

conda create --name deteccion python=3.9

\#Para que sea más rápido lo haré con mamba

mamba create --name deteccion python=3.9

\#activar el entorno

conda activate deteccion

\#instalar las dependencias desde requirements.txt

mamba install --file requirements.txt

\#crear archivo requirements.txt si no lo tengo

mamba env export > requirements.txt

Operaciones con valores faltantes

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