Como criar um detector de imputação automática de valores em Machine Learning
Aprender a identificar automaticamente onde imputar valores em conjuntos de dados é útil para manter pipelines robustos e evitar imputações inadequadas. Este tutorial mostra como criar um detector que sugere o método de imputação por coluna (mean/median/mode/model) usando Python e scikit-learn.
Pré-requisitos
- Python 3.8+ instalado
- Bibliotecas: pandas, scikit-learn, numpy
- Conhecimentos básicos de pandas e scikit-learn
Passo 1: Entender o problema e a estratégia
O objetivo é construir um classificador que, para cada coluna com valores em falta, recomende um método de imputação: mean (média), median (mediana), mode (moda) ou model (usar um modelo preditivo). Isto é útil quando trabalhamos com muitos conjuntos de dados/colunas e queremos automatizar a escolha de imputação baseada em características da coluna.
Passo 2: Criar um conjunto de treino sintético
Vamos gerar colunas sintéticas com diferentes propriedades (numéricas simétricas, numéricas enviesadas, categóricas, com outliers) e definir a melhor imputação por regra. Isto serve como rótulo para treinar o detector.
import numpy as np
import pandas as pd
from sklearn.utils import shuffle
def gen_numeric(size, dist='normal'):
if dist=='normal':
return np.random.normal(loc=0, scale=1, size=size)
if dist=='skew':
return np.random.exponential(scale=1, size=size)
if dist=='outlier':
x = np.random.normal(size=size)
x[:int(size*0.02)] = x[:int(size*0.02)] * 20
return x
def gen_categorical(size, n_cat=3):
return np.random.choice([f'c{i}' for i in range(n_cat)], size=size)
ROWS=500
X=[]
y=[]
for _ in range(400):
typ = np.random.choice(['normal','skew','outlier','cat'])
if typ=='cat':
col = gen_categorical(ROWS, n_cat=np.random.randint(2,6))
# best imput: mode
label='mode'
s = pd.Series(col)
features={'dtype':'cat','n_unique':s.nunique(),'freq_top':s.value_counts(normalize=True).iloc[0]}
else:
col = gen_numeric(ROWS, dist=typ)
s = pd.Series(col)
# decide best imput: mean if near-normal, median if skewed/outliers
skew = s.skew()
if abs(skew) < 0.5:
label='mean'
elif abs(skew) < 2:
label='median'
else:
label='median'
features={'dtype':'num','mean':s.mean(),'median':s.median(),'std':s.std(),'skew':skew}
# introduce missingness pattern
mask = np.random.rand(ROWS) < 0.1
s[mask]=np.nan
# compute summary features for detector
feat = {
'pct_missing': s.isna().mean(),
'n_unique': s.nunique(dropna=True),
}
if features['dtype']=='num':
feat.update({
'mean': features['mean'], 'median': features['median'], 'std': features['std'], 'skew': features['skew']
})
else:
feat.update({'freq_top': features['freq_top']})
X.append(feat)
y.append(label)
df = pd.DataFrame(X).fillna(0)
labels = pd.Series(y)
# shuffle
df, labels = shuffle(df, labels, random_state=42)
Passo 3: Treinar um classificador simples para recomendar imputação
Usamos um RandomForestClassifier para prever a etiqueta (mean/median/mode/model). Nesta versão não incluímos a opção 'model' para simplificar; isso pode ser adicionada com critérios mais avançados.
from sklearn.ensemble import RandomForestClassifier
from sklearn.model_selection import train_test_split
from sklearn.metrics import classification_report
X_train, X_test, y_train, y_test = train_test_split(df, labels, test_size=0.2, random_state=42)
clf = RandomForestClassifier(n_estimators=100, random_state=42)
clf.fit(X_train, y_train)
pred = clf.predict(X_test)
print(classification_report(y_test, pred))
Passo 4: Criar uma função prática que aplica a recomendação
Esta função recebe um DataFrame real, calcula as mesmas características por coluna e aplica o classificador para sugerir a imputação. Mostra também um exemplo de aplicação com SimpleImputer quando a recomendação for mean/median/mode.
from sklearn.impute import SimpleImputer
def column_features(series):
s = series
feat = {
'pct_missing': s.isna().mean(),
'n_unique': s.nunique(dropna=True)
}
if pd.api.types.is_numeric_dtype(s):
feat.update({'mean': s.mean(), 'median': s.median(), 'std': s.std(), 'skew': s.skew()})
else:
top = s.value_counts(normalize=True).iloc[0] if s.dropna().size>0 else 0
feat.update({'mean':0,'median':0,'std':0,'skew':0,'freq_top':top})
return feat
def recommend_imputation(df, clf):
recs = {}
for col in df.columns:
feat = column_features(df[col])
# align columns
f_df = pd.DataFrame([feat]).fillna(0)
pred = clf.predict(f_df)[0]
recs[col]=pred
return recs
# Exemplo de aplicação
sample = pd.DataFrame({
'A': np.append(np.random.normal(size=95), [np.nan]*5),
'B': np.append(np.random.exponential(size=95), [np.nan]*5),
'C': np.append(np.random.choice(['x','y','z'], size=95), [np.nan]*5)
})
recs = recommend_imputation(sample, clf)
print(recs)
# Aplicar imputação simples conforme recomendação (mean/median/mode)
imputed = sample.copy()
for col, method in recs.items():
if method in ('mean','median'):
strategy = method
imp = SimpleImputer(strategy=strategy)
imputed[col] = imp.fit_transform(imputed[[col]])
elif method=='mode':
imp = SimpleImputer(strategy='most_frequent')
imputed[col] = imp.fit_transform(imputed[[col]])
else:
# fallback: median
imp = SimpleImputer(strategy='median')
imputed[col] = imp.fit_transform(imputed[[col]])
Verificar o resultado
Confirma que o classificador tem boa precisão com classification_report e verifica as recomendações impressas. Em dados de exemplo, as colunas numéricas simétricas devem recomendar mean, as enviesadas median e as categóricas mode. Verifica também que o DataFrame imputed não tem valores NaN.
Conclusão
Este detector automático de imputação ajuda a padronizar decisões em pipelines ETL e a reduzir escolhas manuais. Próximos passos: adicionar uma etiqueta 'model' quando uma coluna exigir regressão/classificação para imputar, usar validação cruzada para afinar o classificador e integrar no Pipeline do scikit-learn. Dica: testa o detector em conjuntos reais e compara o impacto das escolhas de imputação na performance do modelo final — qual técnica altera mais as métricas?