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

Cómo crear un detector de imputación automática de valores en Machine Learning

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

Aprender a identificar automáticamente dónde imputar valores en conjuntos de datos es útil para mantener pipelines robustos y evitar imputaciones inadecuadas. Este tutorial muestra cómo crear un detector que sugiere el método de imputación por columna (mean/median/mode/model) usando Python y scikit-learn.

Pré-requisitos

  • Python 3.8+ instalado
  • Bibliotecas: pandas, scikit-learn, numpy
  • Conocimientos básicos de pandas y scikit-learn

Passo 1: Entender o problema e a estratégia

El objetivo es construir un clasificador que, para cada columna con valores faltantes, recomiende un método de imputación: mean (media), median (mediana), mode (moda) o model (usar un modelo predictivo). Esto es útil cuando trabajamos con muchos conjuntos de datos/columnas y queremos automatizar la elección de imputación basada en características de la columna.

Passo 2: Criar um conjunto de treino sintético

Vamos generar columnas sintéticas con diferentes propiedades (numéricas simétricas, numéricas sesgadas, categóricas, con outliers) y definir la mejor imputación por regla. Esto sirve como etiqueta para entrenar el 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 un RandomForestClassifier para predecir la etiqueta (mean/median/mode/model). En esta versión no incluimos la opción 'model' para simplificar; eso puede añadirse con criterios más avanzados.

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 función recibe un DataFrame real, calcula las mismas características por columna y aplica el clasificador para sugerir la imputación. Muestra también un ejemplo de aplicación con SimpleImputer cuando la recomendación sea 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 imputación simple conforme recomendación (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 el clasificador tiene buena precisión con classification_report y verifica las recomendaciones impresas. En datos de ejemplo, las columnas numéricas simétricas deberían recomendar mean, las sesgadas median y las categóricas mode. Verifica también que el DataFrame imputed no tiene valores NaN.

Conclusão

Este detector automático de imputación ayuda a estandarizar decisiones en pipelines ETL y a reducir elecciones manuales. Próximos pasos: añadir una etiqueta 'model' cuando una columna exija regresión/classificación para imputar, usar validación cruzada para afinar el clasificador e integrar en el Pipeline de scikit-learn. Consejo: prueba el detector en conjuntos reales y compara el impacto de las elecciones de imputación en el rendimiento del modelo final — ¿qué técnica cambia más las métricas?