Cómo crear un detector de imputación automática de valores en Machine Learning
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?