No tienes acceso a esta clase

¡Continúa aprendiendo! Únete y comienza a potenciar tu carrera

Imputación por interpolación

11/17
Recursos

Aportes 20

Preguntas 0

Ordenar por:

¿Quieres ver más aportes, preguntas y respuestas de la comunidad?

Codigo incluido en libreria missing

    def interpolate_plot(
        self,
        column_name,
        met: str="linear",
        line_color: str = "orange"
        ) -> pd.DataFrame:
        return (
            self._obj.select_columns(column_name)
            .pipe(lambda df: (
                df[column_name].interpolate(method=met).plot(color = line_color, marker = 'o', alpha = 6/9, linestyle = 'dashed'),
                df[column_name].plot(color = '#000000', marker = 'o')
            ))
        )

3. Imputacion por Interpolacion

Consiste en estimar los valores faltantes mediante puntos en el graficos que representan valores completos. La interpolacion tiene distintas formas de realizarse:

  • Por linea recta en cuyo caso es un metodo basado en un Modelo Lineal
  • Por llenado hacia atras o hacia adelante que consiste en rellenar los valores faltantes con los valores completos sucesor o antecesor y es un metodo basado en Donantes.

Ventajas

  • Sencillo de implementar
  • Es muy util para series de tiempo
  • Posee una variabilidad de oociones al alcance. Puedes interpolar de multiples maneras

Desventajas

  • Puede romper las relaciones entre las variables. Depende del metodo de interpolacion a utilizar
  • Puede introducir valores fuera de rango

Interpolacion por llenado

# utilizamos la imputacion por relleno hacia adelante

plt.figure(figsize=(20,10))

(
    airquality_df
    .select_columns('ozone')    # variable de interes
    .pipe(                      # graficamos los puntos del ozono
        lambda df: (
            df.ozone.ffill().plot(
                color='red',
                marker = 'o',
                alpha=6/9,
                linestyle='dashed'
            ),
            df.ozone.plot(
                color='#313638',
                marker='o'
            )
        )
    )
)

Toma el valor del punto anterior y lo rellena hacia adelante. Esta imputacion no sigue el comportamiento de los datos por lo que no es la mas adecuada.

Interpolacion Lineal

# utilizamos el metodo lineal de interpolate()

plt.figure(figsize=(20,10))

(
    airquality_df
    .select_columns('ozone')    # variable de interes
    .pipe(                      # graficamos los puntos del ozono
        lambda df: (
            df.ozone.interpolate(method = 'linear').plot(
                color='red',
                marker = 'o',
                alpha=6/9,
                linestyle='dashed'
            ),
            df.ozone.plot(
                color='#313638',
                marker='o'
            )
        )
    )
)

Genera una linea recta entre dos puntos conocidos para establecer los puntos que son desconocidos. La imputacion lineal si se ajusta al comportamiento de los datos

Interpolacion cuadratica

# utilizamos el metodo cuadratico de interpolate()

plt.figure(figsize=(20,10))

(
    airquality_df
    .select_columns('ozone')    # variable de interes
    .pipe(                      # graficamos los puntos del ozono
        lambda df: (
            df.ozone.interpolate(method = 'quadratic').plot(
                color='red',
                marker = 'o',
                alpha=6/9,
                linestyle='dashed'
            ),
            df.ozone.plot(
                color='#313638',
                marker='o'
            )
        )
    )
)

Establece una relacion cuadratica de interpolacion. A pesar que se ajusta bien en los datos, tiende a crear puntos fuera del comportamiento habitual lo que indica que no es una buena imputacion. Valores de ozonos por debajo de cero

Interpolacion con valores mas cercanos

# utilizamos el metodo cuadsratico de interpolate()

plt.figure(figsize=(20,10))

(
    airquality_df
    .select_columns('ozone')    # variable de interes
    .pipe(                      # graficamos los puntos del ozono
        lambda df: (
            df.ozone.interpolate(method = 'nearest').plot(
                color='red',
                marker = 'o',
                alpha=6/9,
                linestyle='dashed'
            ),
            df.ozone.plot(
                color='#313638',
                marker='o'
            )
        )
    )
)

Utiliza el llenado hacia adelante o hacia atras dependiendo de si el valor conocido es mas cercano hacia la izquierda o derecha del valor faltante para luego imputarlo. No se ajusta al comportamiento de los datos

Le pedí a ChatGPT que me diga qué otros métodos había, para poder probar los mismos y me hizo un ciclo for para poder probarlas todas. Elimine las que ya habíamos visto en el curso, pero el resultado es EXCELENTE. Les dejo el código para que prueben:# Lista de métodos de interpolación para probarinterpolation\_methods = \['polynomial', 'spline', 'pchip', 'akima', 'pad', 'time'] \# Grado para interpolaciones polinómicas y de splinepolynomial\_degree = 2spline\_degree = 3 \# Crear una figura grande para visualizar todos los métodosplt.figure(figsize=(20, 30)) for i, method in enumerate(interpolation\_methods, start=1):    plt.subplot(len(interpolation\_methods), 1, i)    if method in \['polynomial', 'spline']:        (            airquality\_df            .select\_columns(\["ozone"])            .pipe(                lambda df: (                    df.ozone.interpolate(method=method, order=polynomial\_degree if method == 'polynomial' else spline\_degree).plot(color="red", marker="x", linestyle="dashed"),                    df.ozone.plot(color="#313638", marker="o")                )            )        )    else:        (            airquality\_df            .select\_columns(\["ozone"])            .pipe(                lambda df: (                    df.ozone.interpolate(method=method).plot(color="red", marker="x", linestyle="dashed"),                    df.ozone.plot(color="#313638", marker="o")                )            )        )    plt.title(f'Interpolation Method: {method}') plt.tight\_layout()plt.show() ```js # Lista de métodos de interpolación para probar interpolation_methods = ['polynomial', 'spline', 'pchip', 'akima', 'pad', 'time'] # Grado para interpolaciones polinómicas y de spline polynomial_degree = 2 spline_degree = 3 # Crear una figura grande para visualizar todos los métodos plt.figure(figsize=(20, 30)) for i, method in enumerate(interpolation_methods, start=1): plt.subplot(len(interpolation_methods), 1, i) if method in ['polynomial', 'spline']: ( airquality_df .select_columns(["ozone"]) .pipe( lambda df: ( df.ozone.interpolate(method=method, order=polynomial_degree if method == 'polynomial' else spline_degree).plot(color="red", marker="x", linestyle="dashed"), df.ozone.plot(color="#313638", marker="o") ) ) ) else: ( airquality_df .select_columns(["ozone"]) .pipe( lambda df: ( df.ozone.interpolate(method=method).plot(color="red", marker="x", linestyle="dashed"), df.ozone.plot(color="#313638", marker="o") ) ) ) plt.title(f'Interpolation Method: {method}') plt.tight_layout() plt.show() ```

s/Bard:

Pandas.DataFrame.interpolate: Donantes vs. Modelos

En la biblioteca Pandas, la función DataFrame.interpolate ofrece diversas opciones para realizar interpolación de valores faltantes en un DataFrame. A continuación se clasifican según su enfoque principal:

Métodos basados en donantes:

  • method='linear': Interpolación lineal simple entre los dos puntos más cercanos.
  • method='nearest': Asigna el valor del punto más cercano al punto con valor faltante.
  • method='quadratic': Interpolación cuadrática utilizando los dos puntos más cercanos y el siguiente punto más cercano en la misma dirección.
  • method='cubic': Interpolación cúbica utilizando los dos puntos más cercanos y los dos siguientes puntos más cercanos en la misma dirección.
  • method='krogh': Interpolación de Akima, que utiliza una función cúbica a trozos con restricciones de monotonía.
  • method='spline': Interpolación cúbica con splines de B-spline.

Métodos basados en modelos:

  • method='barycentric': Interpolación baricéntrica, que utiliza una ponderación basada en la distancia de los puntos vecinos.
  • method='polynomial': Interpolación polinomial de orden especificado (parámetro ‘order’).
  • method='pchip': Interpolación cúbica monotónica de Hermite con preservación de la forma local.

Otros métodos:

  • method='index': Interpolación lineal usando el índice del DataFrame.
  • method='pad': Rellena los valores faltantes con el valor del borde más cercano (opción ‘ffill’ para relleno hacia adelante, ‘bfill’ para relleno hacia atrás).

Es importante destacar que algunos métodos pueden combinar elementos de ambos enfoques. Por ejemplo, la interpolación cúbica con splines de B-spline (method='spline') se basa en un modelo matemático, pero también utiliza la información de los puntos vecinos.

La elección del método adecuado dependerá de diversos factores, como:

  • Tamaño del conjunto de datos: Los métodos basados en modelos pueden ser más precisos para conjuntos de datos grandes, mientras que los métodos basados en donantes pueden ser más eficientes para conjuntos de datos pequeños.
  • Patrones en los datos: Los métodos basados en modelos pueden ser más adecuados para conjuntos de datos con patrones complejos, mientras que los métodos basados en donantes pueden ser más robustos para conjuntos de datos con ruido.
  • Precisión requerida: Los métodos basados en modelos pueden ofrecer mayor precisión, pero esto puede implicar un mayor costo computacional.

Se recomienda evaluar diferentes métodos y seleccionar el que mejor se adapte a las necesidades específicas de cada caso.

313638, el color magico de Jesus

La \*\*imputación por interpolación\*\* es un método para estimar valores faltantes en un conjunto de datos, particularmente útil en series temporales o cuando se espera que los datos cambien de manera continua o progresiva. Este método utiliza la tendencia y el comportamiento de los valores circundantes para estimar el valor faltante. \### Tipos de interpolación: 1\. \*\*Interpolación lineal\*\*: Es el método más básico. Estima los valores faltantes asumiendo que los datos varían de manera lineal entre los puntos observados. ```python \# Interpolación lineal df\['columna'] = df\['columna'].interpolate(method='linear') ``` 2\. \*\*Interpolación polinómica\*\*: Utiliza un polinomio de grado `n` para ajustar los valores entre los puntos. Es más flexible que la lineal, pero también puede ser más propensa a oscilar en los extremos. ```python \# Interpolación polinómica (grado 2) df\['columna'] = df\['columna'].interpolate(method='polynomial', order=2) ``` 3\. \*\*Interpolación basada en splines\*\*: Utiliza splines cúbicos o de otro grado para suavizar las curvas entre los puntos. Es útil para datos que no siguen un patrón lineal simple, pero que aún deben mantener una curva suave. ```python \# Interpolación cúbica (splines cúbicos) df\['columna'] = df\['columna'].interpolate(method='spline', order=3) ``` 4\. \*\*Interpolación basada en el índice temporal\*\*: Si trabajas con series temporales, puedes interpolar usando los índices temporales. Esto es útil cuando la regularidad temporal es más importante que la relación entre los valores de las columnas. ```python \# Interpolación basada en el índice temporal df\['columna'] = df\['columna'].interpolate(method='time') ``` \### Ejemplo práctico: Imagina un conjunto de datos que registra la temperatura diaria, pero algunos días faltan registros. Usamos interpolación para estimar esos valores faltantes. ```python import pandas as pd import numpy as np \# Crear un DataFrame con fechas y temperaturas data = {'fecha': pd.date\_range('2023-01-01', periods=10), 'temperatura': \[30, np.nan, np.nan, 35, 33, np.nan, 32, 31, np.nan, 30]} df = pd.DataFrame(data) \# Interpolación lineal df\['temperatura\_interpolada'] = df\['temperatura'].interpolate(method='linear') \# Mostrar el resultado print(df) ``` \### Ventajas de la interpolación: \- \*\*Aprovecha el patrón de los datos\*\*: Si los datos siguen una tendencia continua, la interpolación proporciona estimaciones razonables. \- \*\*Flexibilidad\*\*: Puedes usar diferentes métodos de interpolación (lineal, polinómica, spline) para ajustar el método a la naturaleza de los datos. \- \*\*Preserva la estructura temporal\*\*: En series temporales, la interpolación basada en el tiempo permite hacer imputaciones manteniendo el orden cronológico de los datos. \### Desventajas de la interpolación: \- \*\*No es adecuada para todos los tipos de datos\*\*: Si los valores faltantes son el resultado de un proceso no continuo o aleatorio, la interpolación puede introducir sesgos. \- \*\*Oscilaciones\*\*: Métodos más complejos como los polinomios pueden producir oscilaciones inesperadas, especialmente en los extremos de los datos. \- \*\*Asume continuidad\*\*: Funciona mejor cuando se puede suponer que los valores entre los puntos siguen un patrón predecible o continuo. \### Consideraciones: \- Si los valores faltantes son numerosos o consecutivos, la interpolación puede generar estimaciones menos fiables. \- La interpolación es más adecuada para datos numéricos y en su mayoría aplicable a series temporales, aunque también se puede usar en otras estructuras siempre que los datos tengan una secuencia o patrón claro. Este método es útil en muchos casos, pero siempre debes evaluar si las suposiciones de continuidad son razonables para tus datos.

Manejor de outliers?

En df tenemos 2 valores atípicos, y cuando aplicamos bfill() nos “llenamos” de atípicos que distorsionan en mayor medida nuestros estadísticos

Así se comporta la media con los distintos métodos de interpolación en pandas: ![](https://static.platzi.com/media/user_upload/image-26e0b080-ffef-4bfc-b4e7-860b6787af77.jpg)
**Interpolación con el método Akima** ```python from scipy.interpolate import Akima1DInterpolator plt.figure(figsize=(20, 10)) x = airquality_df["ozone"].dropna().index.astype('int64')/10**9 y = airquality_df["ozone"].dropna().values xs=airquality_df["ozone"].index.astype('int64')/10**9 interpolator = Akima1DInterpolator(x, y) interpolated_ozone = interpolator(xs) plt.plot(airquality_df["ozone"].index,interpolated_ozone,color="red", marker="o", alpha=6/9, linestyle="dashed", label="Interpolated") airquality_df["ozone"].plot(color="#313638", marker="o", label="Original") plt.legend() plt.show() ```
**Interpolación con el método Akima** ```python from scipy.interpolate import Akima1DInterpolator plt.figure(figsize=(20, 10)) x = airquality_df["ozone"].dropna().index.astype('int64')/10**9 y = airquality_df["ozone"].dropna().values xs=airquality_df["ozone"].index.astype('int64')/10**9 interpolator = Akima1DInterpolator(x, y) interpolated_ozone = interpolator(xs) plt.plot(airquality_df["ozone"].index,interpolated_ozone,color="red", marker="o", alpha=6/9, linestyle="dashed", label="Interpolated") airquality_df["ozone"].plot(color="#313638", marker="o", label="Original") plt.legend() plt.show() ```![](blob:vscode-webview://1ljp22lsqid2308n85oc1t9t7rnjbk2e2k4hdg9lju21fh3batfa/3564e5f4-be46-4e65-837f-c8caf425e6f5)![](blob:vscode-webview://1ljp22lsqid2308n85oc1t9t7rnjbk2e2k4hdg9lju21fh3batfa/3564e5f4-be46-4e65-837f-c8caf425e6f5)
#### Interpolación con el método Akima```js from scipy.interpolate import Akima1DInterpolator plt.figure(figsize=(20, 10)) x = airquality_df["ozone"].dropna().index.astype('int64')/10**9 y = airquality_df["ozone"].dropna().values xs=airquality_df["ozone"].index.astype('int64')/10**9 interpolator = Akima1DInterpolator(x, y) interpolated_ozone = interpolator(xs) plt.plot(airquality_df["ozone"].index,interpolated_ozone,color="red", marker="o", alpha=6/9, linestyle="dashed", label="Interpolated") airquality_df["ozone"].plot(color="#313638", marker="o", label="Original") plt.legend() plt.show() ```![]()![]()![](https://static.platzi.com/media/user_upload/3564e5f4-be46-4e65-837f-c8caf425e6f5-9e90a776-cf41-4408-9f89-29b9aa7fe055.jpg)![](blob:vscode-webview://1ljp22lsqid2308n85oc1t9t7rnjbk2e2k4hdg9lju21fh3batfa/3564e5f4-be46-4e65-837f-c8caf425e6f5)
```python ```
```python from scipy.interpolate import Akima1DInterpolator plt.figure(figsize=(20, 10)) x = airquality_df["ozone"].dropna().index.astype('int64')/10**9 y = airquality_df["ozone"].dropna().values xs=airquality_df["ozone"].index.astype('int64')/10**9 interpolator = Akima1DInterpolator(x, y) interpolated_ozone = interpolator(xs) plt.plot(airquality_df["ozone"].index,interpolated_ozone,color="red", marker="o", alpha=6/9, linestyle="dashed", label="Interpolated") airquality_df["ozone"].plot(color="#313638", marker="o", label="Original") plt.legend() plt.show() ```from scipy.interpolate import Akima1DInterpolator plt.figure(figsize=(20, 10))x = airquality\_df\["ozone"].dropna().index.astype('int64')/10\*\*9y = airquality\_df\["ozone"].dropna().values   xs=airquality\_df\["ozone"].index.astype('int64')/10\*\*9interpolator = Akima1DInterpolator(x, y)interpolated\_ozone = interpolator(xs) plt.plot(airquality\_df\["ozone"].index,interpolated\_ozone,color="red", marker="o", alpha=6/9, linestyle="dashed", label="Interpolated")airquality\_df\["ozone"].plot(color="#313638", marker="o", label="Original")plt.legend()plt.show()
#### Interpolación con el método Akima```python from scipy.interpolate import Akima1DInterpolator plt.figure(figsize=(20, 10)) x = airquality_df["ozone"].dropna().index.astype('int64')/10**9 y = airquality_df["ozone"].dropna().values xs=airquality_df["ozone"].index.astype('int64')/10**9 interpolator = Akima1DInterpolator(x, y) interpolated_ozone = interpolator(xs) plt.plot(airquality_df["ozone"].index,interpolated_ozone,color="red", marker="o", alpha=6/9, linestyle="dashed", label="Interpolated") airquality_df["ozone"].plot(color="#313638", marker="o", label="Original") plt.legend() plt.show() ```

airquality & ffill() vs bfill()