Feature Engineering para Machine Learning: Tecnicas y Preguntas de Entrevista 2026

El feature engineering determina el rendimiento final de cualquier modelo de machine learning. Los datos crudos rara vez llegan en un formato que los algoritmos puedan aprovechar directamente — transformarlos en variables significativas es lo que conecta la recoleccion de datos con la precision del modelo.

Estrategias de codificacion categorica para modelos de ML

La mayoria de los algoritmos de machine learning requieren entradas numericas. Las variables categoricas — etiquetas de texto como "alto", "medio", "bajo" o nombres de paises — necesitan convertirse en numeros que el modelo pueda procesar. La estrategia de codificacion afecta directamente el rendimiento y la interpretabilidad del modelo.

Tres tecnicas de codificacion cubren la gran mayoria de escenarios reales: label encoding para datos ordinales, one-hot encoding para categorias nominales, y target encoding para variables con alta cardinalidad.

# encoding_strategies.py
import pandas as pd
from sklearn.preprocessing import LabelEncoder, OneHotEncoder
from sklearn.compose import ColumnTransformer

df = pd.DataFrame({
    "size": ["small", "medium", "large", "medium", "small"],
    "color": ["red", "blue", "green", "red", "blue"],
    "price": [10, 25, 40, 22, 12]
})

# Label encoding for ordinal feature (size has natural order)
le = LabelEncoder()
df["size_encoded"] = le.fit_transform(df["size"])  # large=0, medium=1, small=2

# One-hot encoding for nominal feature (color has no order)
ct = ColumnTransformer(
    transformers=[
        ("onehot", OneHotEncoder(drop="first", sparse_output=False), ["color"])
    ],
    remainder="passthrough"  # Keep other columns unchanged
)
result = ct.fit_transform(df[["color", "price"]])
# Produces: color_green, color_red columns (blue dropped as reference)

El label encoding funciona para variables ordinales donde el orden numerico coincide con el orden de las categorias. El one-hot encoding evita que el modelo infiera relaciones ordinales falsas entre categorias nominales. El parametro drop="first" previene la trampa de la variable dummy al eliminar una columna redundante.

Escalado de variables: StandardScaler vs MinMaxScaler vs RobustScaler

Los algoritmos basados en distancia (KNN, SVM, K-Means) y los optimizadores de gradiente descendente tratan todas las variables por igual. Una columna de salario con rango entre 30,000 y 200,000 dominaria una columna de anos de experiencia con rango entre 0 y 40 si no se aplica escalado.

La eleccion del escalador depende de la distribucion de los datos y la sensibilidad a valores atipicos.

# feature_scaling.py
import numpy as np
from sklearn.preprocessing import StandardScaler, MinMaxScaler, RobustScaler

# Simulated dataset: salary with outliers
data = np.array([[35000], [42000], [55000], [67000], [450000]])  # 450k is an outlier

# StandardScaler: mean=0, std=1 (sensitive to outliers)
standard = StandardScaler().fit_transform(data)
# Result: [-0.72, -0.68, -0.60, -0.53, 2.53] — outlier distorts the scale

# MinMaxScaler: maps to [0, 1] (very sensitive to outliers)
minmax = MinMaxScaler().fit_transform(data)
# Result: [0.0, 0.017, 0.048, 0.077, 1.0] — most values crushed near zero

# RobustScaler: uses median and IQR (robust to outliers)
robust = RobustScaler().fit_transform(data)
# Result: [-0.77, -0.5, 0.0, 0.46, 15.38] — outlier isolated, core data preserved

StandardScaler se adapta a la mayoria de los casos — modelos lineales, redes neuronales y PCA esperan variables estandarizadas. MinMaxScaler es adecuado para funciones de activacion acotadas (sigmoide, tanh) y normalizacion de pixeles en imagenes. RobustScaler debe ser la opcion predeterminada cuando existen valores atipicos en el dataset, como se documenta en la guia de preprocesamiento de scikit-learn.

Transformaciones matematicas para distribuciones sesgadas

Las variables sesgadas violan el supuesto de normalidad de los modelos lineales e inflan la influencia de los valores extremos. Las transformaciones logaritmicas, de raiz cuadrada y Box-Cox comprimen la cola de las distribuciones sesgadas, acercandolas a la normalidad.

# skew_transformations.py
import numpy as np
from sklearn.preprocessing import PowerTransformer

# Right-skewed income data (common in real datasets)
income = np.array([[25000], [32000], [41000], [55000], [72000],
                   [150000], [320000], [890000]])

# Log transform: simple, effective for right-skewed data
log_income = np.log1p(income)  # log1p handles zero values safely

# Box-Cox: finds optimal power parameter automatically
pt = PowerTransformer(method="box-cox")  # Requires strictly positive values
income_boxcox = pt.fit_transform(income)
print(f"Optimal lambda: {pt.lambdas_[0]:.3f}")  # Shows learned parameter

# Yeo-Johnson: works with zero and negative values too
pt_yj = PowerTransformer(method="yeo-johnson")
income_yj = pt_yj.fit_transform(income)

PowerTransformer con Box-Cox o Yeo-Johnson aprende automaticamente el parametro optimo de transformacion. Yeo-Johnson maneja valores cero y negativos, lo que lo convierte en la opcion mas segura por defecto. Siempre es recomendable verificar la distribucion resultante con un grafico Q-Q o la prueba de Shapiro-Wilk para confirmar que la transformacion mejoro la normalidad.

Seleccion de variables: eliminar ruido antes del entrenamiento

Mas variables no siempre significan mejores predicciones. Las variables irrelevantes o redundantes introducen ruido, aumentan el tiempo de entrenamiento y provocan sobreajuste — especialmente en datasets de alta dimensionalidad donde la cantidad de variables se aproxima o supera la cantidad de muestras.

Existen tres categorias de metodos de seleccion de variables: metodos de filtro (pruebas estadisticas), metodos de envoltura (evaluacion basada en modelo) y metodos embebidos (integrados en el proceso de entrenamiento).

# feature_selection.py
from sklearn.datasets import make_classification
from sklearn.feature_selection import (
    SelectKBest, f_classif,  # Filter method
    SequentialFeatureSelector,  # Wrapper method
    SelectFromModel  # Embedded method
)
from sklearn.ensemble import RandomForestClassifier
from sklearn.linear_model import LassoCV

# Dataset: 20 features, only 5 are informative
X, y = make_classification(
    n_samples=1000, n_features=20,
    n_informative=5, n_redundant=3, random_state=42
)

# Filter: ANOVA F-test selects top k features by statistical significance
selector_filter = SelectKBest(f_classif, k=8)
X_filtered = selector_filter.fit_transform(X, y)
print(f"Selected features: {selector_filter.get_support(indices=True)}")

# Embedded: L1 regularization (Lasso) zeros out irrelevant feature weights
lasso = LassoCV(cv=5, random_state=42).fit(X, y)
selector_embedded = SelectFromModel(lasso, prefit=True)
X_lasso = selector_embedded.transform(X)
print(f"Lasso kept {X_lasso.shape[1]} features out of {X.shape[1]}")

Los metodos de filtro (ANOVA, chi-cuadrado, informacion mutua) se ejecutan rapido pero evaluan las variables de forma independiente — no capturan interacciones entre variables. Los metodos embebidos como la regularizacion Lasso realizan la seleccion durante el entrenamiento, produciendo modelos dispersos que generalizan mejor. Para una comprension mas profunda de los algoritmos detras de estos modelos, la guia de algoritmos de machine learning cubre los fundamentos matematicos.

Construccion de pipelines listos para produccion con ColumnTransformer

Distribuir los pasos de preprocesamiento en celdas aisladas de un notebook genera flujos de trabajo fragiles y no reproducibles. Las clases Pipeline y ColumnTransformer de scikit-learn encapsulan todo el proceso de feature engineering en un unico objeto serializable que previene la fuga de datos durante la validacion cruzada.

# production_pipeline.py
import pandas as pd
from sklearn.pipeline import Pipeline
from sklearn.compose import ColumnTransformer
from sklearn.impute import SimpleImputer
from sklearn.preprocessing import StandardScaler, OneHotEncoder
from sklearn.ensemble import GradientBoostingClassifier
from sklearn.model_selection import cross_val_score

# Define column groups by type
numeric_features = ["age", "income", "credit_score"]
categorical_features = ["education", "employment_type", "region"]

# Numeric pipeline: impute missing values, then scale
numeric_pipeline = Pipeline([
    ("imputer", SimpleImputer(strategy="median")),  # Median resists outliers
    ("scaler", StandardScaler())
])

# Categorical pipeline: impute missing, then one-hot encode
categorical_pipeline = Pipeline([
    ("imputer", SimpleImputer(strategy="most_frequent")),
    ("encoder", OneHotEncoder(handle_unknown="ignore", sparse_output=False))
])

# Combine into a single preprocessor
preprocessor = ColumnTransformer([
    ("num", numeric_pipeline, numeric_features),
    ("cat", categorical_pipeline, categorical_features)
])

# Full pipeline: preprocessing + model in one object
full_pipeline = Pipeline([
    ("preprocessor", preprocessor),
    ("classifier", GradientBoostingClassifier(n_estimators=200, random_state=42))
])

# Cross-validation applies preprocessing correctly within each fold
scores = cross_val_score(full_pipeline, X, y, cv=5, scoring="roc_auc")
print(f"AUC: {scores.mean():.3f} +/- {scores.std():.3f}")

El pipeline garantiza que las estadisticas de imputacion, los parametros de escalado y los mapeos de codificacion se calculen unicamente con los datos de entrenamiento dentro de cada fold de validacion cruzada. Ejecutar full_pipeline.fit(X_train, y_train) seguido de full_pipeline.predict(X_test) aplica transformaciones identicas sin fuga de informacion. El pipeline completo se puede serializar con joblib.dump() para su despliegue en produccion.

Feature engineering automatizado con Featuretools

El feature engineering manual funciona bien para datasets estructurados con unas pocas docenas de columnas. Los datasets relacionales que abarcan multiples tablas — transacciones vinculadas a clientes vinculados a comercios — requieren enfoques automatizados para explorar sistematicamente las combinaciones de variables.

Featuretools implementa Deep Feature Synthesis (DFS), un algoritmo que recorre las relaciones entre entidades y aplica primitivas de transformacion y agregacion para generar cientos de variables candidatas de forma automatica.

# automated_feature_engineering.py
import featuretools as ft
import pandas as pd

# Define entities from relational tables
customers = pd.DataFrame({
    "customer_id": [1, 2, 3],
    "signup_date": pd.to_datetime(["2024-01-15", "2024-03-22", "2024-06-01"]),
    "region": ["US", "EU", "APAC"]
})

transactions = pd.DataFrame({
    "txn_id": range(1, 8),
    "customer_id": [1, 1, 1, 2, 2, 3, 3],
    "amount": [50, 120, 30, 200, 85, 340, 15],
    "category": ["food", "tech", "food", "tech", "travel", "food", "tech"]
})

# Create an EntitySet with relationships
es = ft.EntitySet(id="retail")
es = es.add_dataframe(dataframe=customers, dataframe_name="customers",
                      index="customer_id", time_index="signup_date")
es = es.add_dataframe(dataframe=transactions, dataframe_name="transactions",
                      index="txn_id")
es = es.add_relationship("customers", "customer_id",
                         "transactions", "customer_id")

# DFS generates features: COUNT, MEAN, MAX, STD of transactions per customer
feature_matrix, feature_defs = ft.dfs(
    entityset=es, target_dataframe_name="customers",
    max_depth=2,  # Controls complexity of generated features
    trans_primitives=["month", "weekday"],  # Transformation primitives
    agg_primitives=["count", "mean", "std", "max"]  # Aggregation primitives
)
print(f"Generated {len(feature_defs)} features from 2 tables")

DFS produce variables como MEAN(transactions.amount), STD(transactions.amount) y COUNT(transactions) — agregaciones que un data scientist crearia manualmente pero en una fraccion del tiempo. El parametro max_depth controla la complejidad de las variables: profundidad 2 produce agregaciones anidadas como STD(transactions.MONTH(signup_date)).

Preguntas frecuentes de feature engineering en entrevistas de data science

Las entrevistas de data science en 2026 evaluan tanto la comprension teorica como la implementacion practica del feature engineering. Las siguientes preguntas aparecen con frecuencia en procesos de seleccion de empresas tecnologicas de todos los tamanos.

P: Como se maneja una variable categorica con mas de 10,000 valores unicos?

Las categoricas de alta cardinalidad no pueden usar one-hot encoding — generaria 10,000 columnas dispersas. Las estrategias efectivas incluyen: target encoding (con validacion cruzada adecuada para evitar fuga de datos), frequency encoding (reemplazar categorias por su conteo de apariciones), hashing (usar HashingVectorizer para mapear categorias en un espacio de tamano fijo), y capas de embedding en redes neuronales.

P: En que casos NO se deben escalar las variables?

Los modelos basados en arboles (Random Forest, XGBoost, LightGBM) son invariantes a transformaciones monotonicas de las variables. El escalado agrega computo innecesario sin afectar las divisiones del arbol. Los modelos basados en distancia y las redes neuronales siempre requieren escalado.

P: Cual es la diferencia entre seleccion de variables y reduccion de dimensionalidad?

La seleccion de variables conserva un subconjunto de variables originales — las variables seleccionadas mantienen su interpretabilidad. La reduccion de dimensionalidad (PCA, t-SNE, UMAP) crea nuevas variables sinteticas como combinaciones lineales o no lineales de las originales. Los componentes de PCA maximizan la varianza explicada pero pierden interpretabilidad directa. La eleccion correcta depende de si la explicabilidad del modelo es un requisito del proyecto.

P: Como se detecta y maneja la multicolinealidad?

Un Factor de Inflacion de la Varianza (VIF) superior a 5-10 indica multicolinealidad problematica. Las matrices de correlacion capturan relaciones por pares pero no detectan dependencias entre multiples variables. Las soluciones incluyen eliminar una de las variables correlacionadas, combinarlas (PCA sobre el subconjunto correlacionado), o utilizar regularizacion (Ridge/Lasso) que maneja la colinealidad internamente.

Para practicar con las bibliotecas de manipulacion de datos en Python esenciales para el feature engineering, la guia de Python para data science cubre flujos de trabajo con NumPy, Pandas y scikit-learn en detalle.

Conclusion

• Codificar las variables categoricas de forma intencional: label encoding para datos ordinales, one-hot para nominales, target encoding (dentro de folds de CV) para variables de alta cardinalidad
• Escalar las variables segun los requerimientos del modelo: StandardScaler para modelos lineales y redes neuronales, omitir el escalado para modelos basados en arboles
• Aplicar transformaciones de potencia (PowerTransformer) para reducir el sesgo antes de alimentar algoritmos que asumen normalidad
• Seleccionar variables sistematicamente usando metodos de filtro para velocidad, metodos embebidos (Lasso) para precision, y siempre validar con validacion cruzada
• Encapsular todo el preprocesamiento en Pipeline + ColumnTransformer de scikit-learn para prevenir fuga de datos y garantizar reproducibilidad
• Automatizar la generacion de variables con Featuretools DFS para datasets relacionales que abarcan multiples tablas
• Practicar la explicacion de decisiones de feature engineering en terminos de negocio — los entrevistadores evaluan tanto la habilidad tecnica como la claridad en la comunicacion