(+351) 21 24 10006  ·  info@bconcepts.pt
Carnaxide, Lisboa

Como criar um detector de imputação automática de valores em Machine Learning

João Barros 16 de November de 2026 5 min de leitura

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?