Interpolação e imputação avançada
Use interpolate() para um preenchimento suave baseado no tempo e entenda quando é apropriado usar imputação pela média ou pela mediana.
Interpolação e imputação avançada é uma aula grátis de Pandas & NumPy Academy no CoddyKit. Esta é a aula 4 de 4. Você pode ler a aula completa abaixo gratuitamente — depois pratica ao vivo no navegador com um editor de código integrado e um tutor de IA 24/7. Faz parte do caminho de aprendizado de Pandas & NumPy Academy, e seu progresso é sincronizado entre a web e o app CoddyKit. O curso de Pandas & NumPy Academy inclui 4 aulas no total.
Quando a interpolação é melhor que fillna()
O preenchimento para frente e o preenchimento para trás transportam o valor conhecido mais próximo sem considerar a tendência dos dados. A interpolação estima valores ausentes supondo uma transição suave entre valores conhecidos — por exemplo, se a temperatura era de 20 °C na segunda-feira e 30 °C na sexta-feira, a interpolação estima 25 °C para quarta-feira. Isso produz imputações mais realistas para sinais que mudam suavemente, como dados de sensores, preços ou contagens populacionais.
import pandas as pd
import numpy as np
df = pd.DataFrame({
'day': [1, 2, 3, 4, 5],
'temp': [20.0, np.nan, np.nan, np.nan, 30.0]
})
# Linear interpolation fills gaps smoothly
df['temp_interp'] = df['temp'].interpolate(method='linear')
print(df)
# day temp temp_interp
# 0 1 20.0 20.0
# 1 2 NaN 22.5
# 2 3 NaN 25.0
# 3 4 NaN 27.5
# 4 5 30.0 30.0Métodos de interpolate()
O Pandas interpolate() oferece suporte a vários métodos. Os mais comuns são 'linear' (igualmente espaçado entre os valores conhecidos), 'time' (considera intervalos de tempo desiguais quando um DatetimeIndex é definido), 'polynomial' (ajusta uma curva polinomial e exige um argumento order) e 'spline' (polinômio suave definido por partes). Linear é o padrão mais seguro; métodos de ordem superior podem causar sobreajuste em lacunas pequenas.
import pandas as pd
import numpy as np
s = pd.Series([0, np.nan, np.nan, 8.0])
print('linear:', s.interpolate('linear').tolist())
# [0.0, 2.6666..., 5.3333..., 8.0]
print('polynomial(2):', s.interpolate('polynomial', order=2).tolist())
# [0.0, 2.222..., 5.111..., 8.0]Interpolação time com DatetimeIndex
Quando sua Series tem um DatetimeIndex com intervalos de tempo desiguais (por exemplo, apenas dias úteis, sem fins de semana), method='time' interpola proporcionalmente ao tempo realmente decorrido, e não apenas pela posição. Isso é mais preciso do que a interpolação linear, que trata cada linha como igualmente espaçada, independentemente da lacuna no calendário.
import pandas as pd
import numpy as np
# Unequal gaps: Jan 1, Jan 3, Jan 10
idx = pd.to_datetime(['2024-01-01', '2024-01-03', '2024-01-10'])
s = pd.Series([100.0, np.nan, 170.0], index=idx)
# linear treats gaps as equal (position-based)
print(s.interpolate('linear').tolist()) # [100.0, 135.0, 170.0]
# time accounts for actual day count
# Jan 1 to Jan 3 = 2 days, Jan 1 to Jan 10 = 9 days
# fraction: 2/9 of the way from 100 to 170
print(s.interpolate('time').tolist()) # [100.0, 115.55..., 170.0]Limitação da extensão da interpolação
Assim como ffill(), interpolate() aceita um parâmetro limit para restringir quantas posições NaN consecutivas serão preenchidas. Os NaN restantes além do limite continuam ausentes. Isso impede que a interpolação atravesse lacunas muito longas, nas quais o valor verdadeiro poderia ser qualquer um — lacunas longas devem ser sinalizadas para análise manual.
import pandas as pd
import numpy as np
s = pd.Series([1.0, np.nan, np.nan, np.nan, np.nan, 10.0])
# Only fill the first 2 NaN positions
filled = s.interpolate('linear', limit=2)
print(filled.tolist())
# [1.0, 2.8, 4.6, NaN, NaN, 10.0]Escolha entre imputação pela média e pela mediana
A imputação pela média e pela mediana é simples, mas envolve compromissos importantes. A mean é sensível a valores discrepantes — alguns valores muito grandes a elevam, tornando-a um preenchimento inadequado para uma distribuição assimétrica à direita, como renda ou preços de imóveis. A median é resistente a valores discrepantes e é a melhor escolha para colunas assimétricas. Use a média apenas quando seus dados forem aproximadamente simétricos e não tiverem valores discrepantes extremos.
import pandas as pd
import numpy as np
# Skewed income data with an outlier
income = pd.Series([30000, 35000, 32000, 1_000_000, np.nan])
print('Mean: ', income.mean()) # ~274000 — pulled by outlier
print('Median:', income.median()) # ~33500 — robust choice
# Prefer median for skewed data
filled = income.fillna(income.median())
print(filled.tolist())
# [30000, 35000, 32000, 1000000, 33500.0]Conceito de imputação KNN
A imputação por K-Vizinhos Mais Próximos (KNN) substitui um valor ausente pela média (ou média ponderada) das k linhas mais semelhantes, medida pela distância entre as características não ausentes. Essa é uma estratégia multivariada — ela usa informações de outras colunas para orientar o preenchimento, o que é mais preciso do que a imputação pela média de uma única coluna quando as características são correlacionadas.
O KNNImputer do Scikit-learn integra-se diretamente a matrizes NumPy e DataFrames do Pandas.
import pandas as pd
import numpy as np
from sklearn.impute import KNNImputer
df = pd.DataFrame({
'age': [25, 35, np.nan, 45],
'income': [50000, 70000, 60000, np.nan]
})
imputer = KNNImputer(n_neighbors=2)
df_imputed = pd.DataFrame(
imputer.fit_transform(df),
columns=df.columns
)
print(df_imputed.round(1))
# age income
# 0 25.0 50000.0
# 1 35.0 70000.0
# 2 30.0 60000.0 <- filled from neighbours
# 3 45.0 65000.0 <- filled from neighboursImputação múltipla com IterativeImputer
A imputação múltipla é considerada o padrão-ouro para lidar com dados ausentes em pesquisas estatísticas. O IterativeImputer do Scikit-learn implementa uma abordagem MICE (Imputação Múltipla por Equações Encadeadas): ele modela cada coluna com valores ausentes como uma função das outras colunas, repetindo a imputação até que os valores convirjam. Isso capta melhor as relações entre características do que estratégias de uma única coluna.
import pandas as pd
import numpy as np
from sklearn.experimental import enable_iterative_imputer # noqa
from sklearn.impute import IterativeImputer
df = pd.DataFrame({
'x1': [1, 2, np.nan, 4, 5],
'x2': [2, np.nan, 6, 8, 10],
'y': [3, 5, 7, np.nan, 11]
})
imp = IterativeImputer(max_iter=10, random_state=0)
df_filled = pd.DataFrame(imp.fit_transform(df), columns=df.columns)
print(df_filled.round(2))Colunas indicadoras de dados ausentes
Em vez de ocultar o fato de que um valor foi imputado, é uma boa prática adicionar uma coluna indicadora binária que sinalize quais linhas tinham valores ausentes antes da imputação. Isso permite que os modelos posteriores aprendam com o próprio padrão de ausência — às vezes, o fato de um valor estar ausente é tão preditivo quanto o próprio valor.
import pandas as pd
import numpy as np
df = pd.DataFrame({'salary': [50000, np.nan, 70000, np.nan, 90000]})
# Add indicator before filling
df['salary_was_missing'] = df['salary'].isna().astype(int)
# Then fill
df['salary'] = df['salary'].fillna(df['salary'].median())
print(df)
# salary salary_was_missing
# 0 50000.0 0
# 1 70000.0 1
# 2 70000.0 0
# 3 70000.0 1
# 4 90000.0 0Imputação e vazamento de dados
Uma regra crítica nos fluxos de trabalho de aprendizado de máquina: calcule as estatísticas de imputação (média, mediana, moda) apenas no conjunto de treinamento e depois aplique os mesmos valores ao conjunto de teste. Calcular estatísticas no conjunto de dados completo antes da divisão causa vazamento de dados — o modelo vê indiretamente os dados de teste durante o treinamento, inflando as estimativas de desempenho. Sempre ajuste os imputadores aos dados de treinamento e transforme tanto os dados de treinamento quanto os de teste.
import pandas as pd
import numpy as np
from sklearn.impute import SimpleImputer
from sklearn.model_selection import train_test_split
df = pd.DataFrame({'feature': [1, 2, np.nan, 4, np.nan, 6, 7, 8]})
train, test = train_test_split(df, test_size=0.25, random_state=0)
# Fit ONLY on training data
imp = SimpleImputer(strategy='mean')
train['feature'] = imp.fit_transform(train[['feature']])
# Transform test using training statistics
test['feature'] = imp.transform(test[['feature']])
print('Train mean used:', imp.statistics_[0])Comparação visual de estratégias de imputação
Depois de aplicar vários métodos de imputação, compare o efeito representando graficamente a distribuição das colunas original e imputada lado a lado. Uma boa imputação deve preservar, da forma mais próxima possível, o formato (média, variância e assimetria) da distribuição original. A imputação pela média estreita a distribuição; KNN e MICE tendem a preservá-la melhor.
import pandas as pd
import numpy as np
import matplotlib.pyplot as plt
np.random.seed(0)
original = np.random.exponential(scale=5, size=200)
with_nan = original.copy()
with_nan[np.random.choice(200, 40, replace=False)] = np.nan
s = pd.Series(with_nan)
fig, axes = plt.subplots(1, 2, figsize=(10, 4))
s.dropna().hist(ax=axes[0], bins=20, title='Original (no NaN)')
s.fillna(s.mean()).hist(ax=axes[1], bins=20, title='Mean-imputed')
plt.tight_layout()
plt.savefig('imputation_comparison.png')
print('Saved comparison chart')Escolha da estratégia de imputação adequada
Não existe uma estratégia de imputação universalmente melhor — a escolha certa depende do contexto. Use mean/median para casos univariados simples com poucos valores ausentes. Use ffill/bfill para séries temporais com tendências estáveis. Use KNN ou IterativeImputer quando as características forem correlacionadas e você quiser aproveitar essas relações. Use constantes do domínio (por exemplo, 0 para ausente, -1 para desconhecido) quando o valor ausente tiver um significado claro para o negócio. Sempre documente sua escolha.
# Decision guide (no runnable code)
#
# Missing < 5% AND data is MCAR? -> Mean/median fill is fine
# Time series with stable trend? -> ffill() with limit
# Features are correlated? -> KNNImputer or IterativeImputer
# Categorical column? -> Mode fill or 'Unknown' sentinel
# Going into ML model? -> Add indicator column + fill
# Research / publication quality? -> Multiple imputation (MICE)
print('Strategy selected based on context')Verificação rápida
Teste sua compreensão sobre interpolação e imputação avançada.
Resumo da lição
Nesta lição, você aprendeu que: interpolate() estima valores ausentes supondo uma tendência suave entre valores conhecidos, method='time' lida com intervalos desiguais em DatetimeIndex e estratégias avançadas, como KNNImputer e IterativeImputer, usam outras colunas para orientar os preenchimentos. Sempre adicione colunas indicadoras antes da imputação e ajuste as estatísticas apenas no conjunto de treinamento para evitar vazamento de dados. A seguir, examinaremos e converteremos os tipos de dados das colunas do DataFrame.
Perguntas Frequentes
A aula “Interpolação e imputação avançada” é grátis?
Sim — o texto completo de “Interpolação e imputação avançada” é grátis para ler aqui na web. Para praticá-la interativamente (um editor de código integrado e um tutor de IA 24/7) e desbloquear o restante do curso de Pandas & NumPy Academy, atualize para CoddyKit PRO. O curso de Pandas & NumPy Academy inclui 4 aulas no total.
O que vou aprender em “Interpolação e imputação avançada”?
Use interpolate() para um preenchimento suave baseado no tempo e entenda quando é apropriado usar imputação pela média ou pela mediana. Você pratica Pandas & NumPy Academy com código prático que executa diretamente no navegador, e um tutor de IA 24/7 responde suas dúvidas enquanto trabalha na aula.
Preciso ter experiência prévia para começar Pandas & NumPy Academy?
Nenhuma experiência prévia é necessária. Pandas & NumPy Academy no CoddyKit é estruturado para alunos iniciantes até avançados, então você pode começar aqui ou desde o início e aprender no seu ritmo. Esta é a aula 4 de 4.
Quanto tempo leva a aula “Interpolação e imputação avançada”?
A maioria das aulas CoddyKit leva cerca de 5–10 minutos. Cada uma é compacta e interativa, então você faz progresso constante e retoma exatamente de onde parou entre web e app.
Posso escrever e executar código nesta aula de Pandas & NumPy Academy?
Sim. Cada aula de Pandas & NumPy Academy inclui um editor de código integrado, então você escreve e executa código real direto no navegador e recebe feedback de IA instantaneamente — nenhuma configuração local necessária.
Todas as aulas deste curso
- Detectando valores ausentes
- Removendo valores ausentes
- Preenchendo valores ausentes
- Interpolação e imputação avançada