Cursos Empresas Blog Live Conf Eventos Precios

Ejecución de Notebooks en Deepnote con %run

Curso de Manejo de Datos Faltantes: Detección y Exploración

Contenido del curso

Introducción a los valores faltantes

Manipulación inicial de valores faltantes

Búsqueda de relaciones de valores faltantes

Tratamiento de valores faltantes

Cierre de curso

21
Continúa aprendiendo sobre el manejo de valores faltantes
03:21 min

Tomar examen

¡Hola! Te doy la bienvenida a este pequeño tutorial para conocer cómo ejecutar las funciones de una Jupyter Notebook dentro de otra en Deepnote.

Por una actualización de Deepnote notarás que ahora las Notebooks están separadas de los archivos (Files).

Por esta actualización tendrás que subir la notebook al sistema de archivos de Deepnote, para poder ejecutarla dentro de otra notebook utilizando la magia %run.

Tendrás que hacer lo anterior en tu proyecto de Deepnote del curso, ya que utilizaremos una notebook llamada pandas-missing-extension.ipynb dentro de nuestra notebook principal para utilizar métodos predefinidos en ella. Por ahora, no te preocupes por el contenido de esa notebook, en la siguiente clase hablaremos de ello. 🤗

Sigue estos pasos para subir tu notebook como archivo (File) a Deepnote:

Ve a la sección de NOTEBOOKS del proyecto de Deepnote.

Da clic en los tres puntos sobre la notebook pandas-missing-extension y da clic sobre Export as .ipynb. Esto descargará la notebook a tu computadora.

Después da clic en en el signo de + en la sección FILES y sube la notebook pandas-missing-extension.ipynb que descargaste en el paso anterior en la opción Upload File.
Repite los pasos 1-3 cada vez que desees subir la notebook pandas-missing-extension.ipynb a la sección FILES. dentro de tu proyecto en Deepnote.
Para terminar, ejecuta la siguiente línea dentro de la notebook exploration-missing-values o live-exploration-missing-values para cargar las funciones de la notebbok pandas-missing-extension.ipynb y poder utilizarlas.

¡Nos vemos en la próxima clase! Conoceremos cómo funciona la notebook donde extendemos Pandas para manejar valores faltantes! 🤓✨

Ejecución de Notebooks en Deepnote con %run

Diego Cesar Lerma Torres

Estudiante

Hace 2 años

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))
        )

Eduardo Barea

Estudiante

Hace 2 años

Gracias, compañero.

Ejecución de Notebooks en Deepnote con %run

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