Imputación por interpolación

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

Bryan Carvajal

student•

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

Jeinfferson Bernal G

student•

Muy buen aporte. Gracias

Pablo Alejandro Figueroa

student•

Gracias..!!

Jeinfferson Bernal G

student•

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.

Jeinfferson Bernal G

student•

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

Julián Cárdenas

student•

👏

Pablo Alejandro Figueroa

student•

Gracias..!

Jeinfferson Bernal G

student•

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

Julián Cárdenas

student•

👏 Nice

Pablo Alejandro Figueroa

student•

Genial.! muchas gracias..!

Jeinfferson Bernal G

student•

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

Jeinfferson Bernal G

student•

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

Antonio Demarco Bonino

student•

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

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

Valentina Cobo Paz

student•

Gracias Antonio, interesante el ejercicio!

Pablo Alejandro Figueroa

student•

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.

Ian Cristian Ariel Yané

student•

313638, el color magico de Jesus

Mario Alexander Vargas Celis

student•

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.


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

&#x20;       '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.

Pablo Alejandro Figueroa

student•

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

Valentina Cobo Paz

student•

Gracias!!

Fabricio González Guasque

student•

La imputación por interpolación es un método utilizado para estimar valores faltantes en un conjunto de datos al calcular puntos intermedios en una secuencia de datos. Este enfoque utiliza los valores existentes y puede ser lineal o no lineal, dependiendo de la relación entre los datos. Es eficaz cuando hay datos estructurados en series temporales o distribuciones continuas, permitiendo así una mejor estimación que métodos simples como la media o la moda. Este tipo de imputación es especialmente útil en análisis de datos en contextos donde los datos siguen patrones específicos.

Emmanuel Guerra Sánchez

student•

Así se comporta la media con los distintos métodos de interpolación en pandas:

Angel Martínez

student•

Interpolación con el método Akima

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

Angel Martínez

student•

Interpolación con el método Akima

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)

Angel Martínez

student•

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

Angel Martínez

student•

Angel Martínez

student•

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

Angel Martínez

student•

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)

Pablo Alejandro Figueroa

student•

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

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

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

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

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

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

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

&#x20;       '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)

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

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

Imputación por interpolación

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?