Top 25 Preguntas de Entrevista de Data Science en 2026

Las entrevistas de data science en 2026 van mucho más allá de las definiciones textuales. Los equipos de contratación evalúan el razonamiento estadístico, las decisiones en ingeniería de características, la evaluación de modelos más allá de la exactitud y la capacidad de traducir problemas de negocio en pipelines analíticos. Esta guía cubre 25 preguntas que aparecen de forma recurrente en entrevistas para científicos de datos en empresas de todos los tamaños, desde startups hasta corporaciones tecnológicas de primer nivel.

Probabilidad y Fundamentos Estadísticos

P1: Se lanza una moneda 10 veces y cae cara 8 veces. ¿La moneda está sesgada?

La respuesta intuitiva es "sí", pero el enfoque riguroso aplica una prueba binomial. Bajo la hipótesis nula (moneda justa, p=0.5), la probabilidad de obtener 8 o más caras en 10 lanzamientos es aproximadamente 5.5%, cifra que no está por debajo del umbral de significancia estándar del 5%. No es posible declarar que la moneda está sesgada con un nivel alfa de 0.05.

# binomial_test.py
from scipy import stats

# Two-sided binomial test: is the coin fair?
result = stats.binomtest(k=8, n=10, p=0.5, alternative='two-sided')
print(f"p-value: {result.pvalue:.4f}")  # 0.1094 (two-sided)
print(f"Reject H0 at alpha=0.05? {result.pvalue < 0.05}")  # False

Esta pregunta evalúa si el candidato recurre a la intuición o aplica una prueba de hipótesis formal. Los entrevistadores suelen preguntar a continuación sobre errores de Tipo I y Tipo II, y sobre el tamaño de muestra necesario para detectar un sesgo de p=0.7 con una potencia estadística del 80%.

P2: Explique la diferencia entre los enfoques bayesiano y frecuentista de la inferencia.

La inferencia frecuentista trata los parámetros como valores fijos pero desconocidos. Un intervalo de confianza del 95% significa que, si el experimento se repitiera muchas veces, el 95% de los intervalos calculados contendría el verdadero parámetro. La inferencia bayesiana trata los parámetros como variables aleatorias con distribuciones a priori, actualizando las creencias mediante el teorema de Bayes para obtener distribuciones a posteriori. Un intervalo de credibilidad del 95% significa que, dado los datos observados y la distribución a priori, existe un 95% de probabilidad de que el parámetro se encuentre en ese intervalo.

# bayesian_vs_frequentist.py
import numpy as np
from scipy import stats

# Frequentist: confidence interval for a mean
data = np.array([23.1, 25.4, 22.8, 24.9, 23.7, 25.1, 24.3])
ci = stats.t.interval(0.95, df=len(data)-1, loc=np.mean(data), scale=stats.sem(data))
print(f"95% CI (frequentist): [{ci[0]:.2f}, {ci[1]:.2f}]")

# Bayesian: posterior with conjugate prior (Normal-Normal)
prior_mean, prior_var = 24.0, 4.0  # prior belief
data_mean, data_var = np.mean(data), np.var(data, ddof=1) / len(data)
# Posterior parameters (conjugate update)
post_var = 1 / (1/prior_var + 1/data_var)
post_mean = post_var * (prior_mean/prior_var + data_mean/data_var)
post_ci = stats.norm.interval(0.95, loc=post_mean, scale=np.sqrt(post_var))
print(f"95% credible interval (Bayesian): [{post_ci[0]:.2f}, {post_ci[1]:.2f}]")

La diferencia práctica es relevante en entrevistas: los métodos bayesianos incorporan conocimiento de dominio a través de las distribuciones a priori, lo cual resulta valioso cuando los datos son escasos. Los métodos frecuentistas imponen menos suposiciones, pero requieren muestras más grandes para una inferencia confiable.

P3: ¿Cuándo falla el Teorema Central del Límite y por qué importa en ciencia de datos?

El TCL garantiza que las medias muestrales convergen a una distribución normal conforme n crece, pero solo cuando la población tiene varianza finita. Las distribuciones de colas pesadas (Cauchy, Pareto con alfa menor o igual a 2) violan este supuesto. En la práctica, esto afecta el modelado de retornos financieros, el análisis de tráfico de red y cualquier dominio con valores extremos pronunciados. En estos casos, la mediana o la media recortada se convierten en estimadores más robustos.

Ingeniería de Características y Preparación de Datos

P4: ¿Cómo afectan los valores faltantes al entrenamiento de modelos y qué estrategias existen más allá de la imputación simple?

Los mecanismos de datos faltantes determinan la estrategia correcta. MCAR (Faltante Completamente al Azar) permite la eliminación por lista sin introducir sesgo. MAR (Faltante al Azar) se beneficia de la imputación múltiple o de enfoques basados en modelos. MNAR (Faltante No al Azar) requiere modelar explícitamente el mecanismo de ausencia desde la perspectiva del dominio.

# missing_data_strategies.py
import pandas as pd
from sklearn.impute import KNNImputer, SimpleImputer
from sklearn.experimental import enable_iterative_imputer
from sklearn.impute import IterativeImputer

df = pd.DataFrame({
    'age': [25, 30, None, 45, None, 38],
    'income': [50000, None, 70000, 90000, 60000, None],
    'score': [85, 90, 78, None, 88, 92]
})

# Strategy 1: KNN imputation (preserves local structure)
knn_imp = KNNImputer(n_neighbors=2)
df_knn = pd.DataFrame(knn_imp.fit_transform(df), columns=df.columns)

# Strategy 2: Iterative imputation (MICE-like, models each feature)
iter_imp = IterativeImputer(max_iter=10, random_state=42)
df_iter = pd.DataFrame(iter_imp.fit_transform(df), columns=df.columns)

# Strategy 3: Add missingness indicator (preserves signal in the pattern)
df['income_missing'] = df['income'].isna().astype(int)
print(df_knn.round(1))

El punto clave que los entrevistadores buscan: el patrón de ausencia en sí mismo puede ser informativo. Agregar columnas indicadoras binarias para las características faltantes a menudo mejora el rendimiento del modelo, especialmente en árboles de decisión con gradiente boosting.

P5: Explique el target encoding y cuándo supera al one-hot encoding.

El one-hot encoding crea una columna binaria dispersa por cada categoría. Para características de alta cardinalidad (códigos postales, IDs de usuario, SKUs de productos), esto expande explosivamente la dimensionalidad. El target encoding reemplaza cada categoría con la media de la variable objetivo para esa categoría, produciendo una única columna numérica densa.

# target_encoding.py
import pandas as pd
import numpy as np
from sklearn.model_selection import KFold

def target_encode_kfold(df, col, target, n_splits=5):
    """Target encoding with K-fold regularization to prevent leakage."""
    encoded = pd.Series(index=df.index, dtype=float)
    global_mean = df[target].mean()
    kf = KFold(n_splits=n_splits, shuffle=True, random_state=42)

    for train_idx, val_idx in kf.split(df):
        # Compute means only from training fold
        means = df.iloc[train_idx].groupby(col)[target].mean()
        encoded.iloc[val_idx] = df.iloc[val_idx][col].map(means)

    # Fill categories unseen in training fold with global mean
    encoded.fillna(global_mean, inplace=True)
    return encoded

df = pd.DataFrame({
    'city': ['Paris', 'Lyon', 'Paris', 'Marseille', 'Lyon', 'Paris',
             'Marseille', 'Lyon', 'Paris', 'Marseille'],
    'hired': [1, 0, 1, 0, 1, 1, 0, 0, 1, 1]
})
df['city_encoded'] = target_encode_kfold(df, 'city', 'hired')
print(df[['city', 'city_encoded', 'hired']])

El enfoque con K-fold previene la fuga de datos calculando las medias del objetivo únicamente sobre las muestras fuera del fold de entrenamiento. Sin esta regularización, el target encoding sobreajusta severamente en conjuntos de datos pequeños.

Conceptos Fundamentales de Machine Learning

P6: ¿Qué es el balance sesgo-varianza y cómo se manifiesta en los modelos basados en árboles?

El sesgo mide el error sistemático: qué tan lejos están las predicciones del valor verdadero en promedio. La varianza mide la sensibilidad al conjunto de entrenamiento: cuánto cambian las predicciones ante distintas muestras. Un árbol de decisión profundo tiene bajo sesgo pero alta varianza: memoriza los datos de entrenamiento. Un random forest reduce la varianza mediante el agregado bootstrap (bagging) mientras mantiene el sesgo bajo. Los árboles con gradient boosting reducen el sesgo iterativamente ajustando los residuos, pero con riesgo de aumentar la varianza sin una regularización adecuada (tasa de aprendizaje, profundidad máxima, submuestreo).

P7: ¿Por qué la exactitud falla como métrica para conjuntos de datos desbalanceados? ¿Qué alternativas existen?

En un conjunto de datos con 95% de muestras negativas y 5% positivas, un modelo que predice siempre "negativo" alcanza el 95% de exactitud siendo completamente inútil. Las curvas de precisión-recall, el F1-score y el área bajo la curva de precisión-recall (AUPRC) capturan mejor el rendimiento sobre la clase minoritaria. Para tareas de ranking, el AUC-ROC funciona bien porque evalúa la capacidad de discriminación en todos los umbrales posibles.

# imbalanced_metrics.py
from sklearn.metrics import (
    classification_report, precision_recall_curve,
    average_precision_score, roc_auc_score
)
import numpy as np

# Simulated predictions on imbalanced data
np.random.seed(42)
y_true = np.array([0]*950 + [1]*50)  # 95/5 imbalance
y_scores = np.random.beta(2, 5, 1000)  # predicted probabilities
y_scores[y_true == 1] += 0.3  # positive class scores slightly higher
y_scores = np.clip(y_scores, 0, 1)
y_pred = (y_scores > 0.5).astype(int)

print(classification_report(y_true, y_pred, digits=3))
print(f"ROC AUC: {roc_auc_score(y_true, y_scores):.3f}")
print(f"Average Precision (AUPRC): {average_precision_score(y_true, y_scores):.3f}")

La pregunta de seguimiento frecuente es: "¿Cómo elige entre precisión y recall?" La respuesta depende del costo relativo de los falsos positivos frente a los falsos negativos. La detección de fraude prioriza el recall (detectar el fraude importa más que las falsas alarmas). El filtrado de spam prioriza la precisión (los falsos positivos molestan más a los usuarios que el spam que se cuela).

P8: Explique la regularización L1 vs. L2 y cuándo se prefiere cada una.

La regularización L1 (Lasso) agrega la suma de los valores absolutos de los pesos a la función de pérdida, llevando algunos coeficientes exactamente a cero. Esto produce modelos dispersos y actúa como selección de características embebida. La regularización L2 (Ridge) agrega la suma de los pesos al cuadrado, reduciendo todos los coeficientes hacia cero sin eliminar ninguno. Se utiliza L1 cuando muchas características son irrelevantes y se desea dispersión. Se utiliza L2 cuando todas las características aportan y existe multicolinealidad. Elastic Net combina ambas y suele ser la opción predeterminada cuando la proporción óptima es desconocida.

P9: ¿Cómo tratan los árboles con gradient boosting (XGBoost/LightGBM) las características categóricas de forma diferente?

XGBoost requiere tradicionalmente one-hot encoding o codificación ordinal antes del entrenamiento. LightGBM maneja las características categóricas de forma nativa mediante un algoritmo de búsqueda de divisiones óptimas que agrupa las categorías según sus estadísticas de gradiente, reduciendo el espacio de búsqueda exponencial a tiempo lineal. Este manejo nativo supera frecuentemente al one-hot encoding, especialmente para características de alta cardinalidad, y explica por qué LightGBM entrena más rápido en conjuntos de datos tabulares.

Evaluación y Validación de Modelos

P10: ¿Qué es la fuga de datos y cuáles son las tres fuentes más comunes?

La fuga de datos ocurre cuando información proveniente de fuera de la distribución de entrenamiento se filtra al modelo, inflando las métricas de validación pero degradando el rendimiento en producción. Las tres fuentes más comunes son:

1. Fuga temporal: uso de datos futuros para predecir el pasado (por ejemplo, usar el valor de vida del cliente para predecir la deserción en el primer mes)
2. Fuga del objetivo: características derivadas de la variable objetivo (por ejemplo, "número de reembolsos" para predecir "solicitará reembolso")
3. Fuga en preprocesamiento: ajustar escaladores, codificadores o imputadores sobre el conjunto de datos completo antes de la división

# leakage_prevention.py
from sklearn.pipeline import Pipeline
from sklearn.preprocessing import StandardScaler
from sklearn.impute import SimpleImputer
from sklearn.ensemble import GradientBoostingClassifier
from sklearn.model_selection import cross_val_score
import numpy as np

X = np.random.randn(1000, 10)
y = (X[:, 0] + X[:, 1] > 0).astype(int)

# WRONG: fit scaler on all data, then cross-validate
scaler = StandardScaler()
X_scaled = scaler.fit_transform(X)  # leakage: test fold info in scaling

# CORRECT: pipeline ensures preprocessing fits only on training folds
pipeline = Pipeline([
    ('imputer', SimpleImputer(strategy='median')),
    ('scaler', StandardScaler()),
    ('model', GradientBoostingClassifier(n_estimators=100, random_state=42))
])
scores = cross_val_score(pipeline, X, y, cv=5, scoring='roc_auc')
print(f"AUC (no leakage): {scores.mean():.3f} +/- {scores.std():.3f}")

Los Pipelines de scikit-learn son la defensa estándar contra la fuga en preprocesamiento. Cada paso de transformación dentro del pipeline se reajusta de forma independiente en cada fold de entrenamiento.

P11: ¿Cuándo debe reemplazarse la validación cruzada estándar K-fold por la validación cruzada para series temporales?

La K-fold estándar mezcla aleatoriamente los datos, lo que rompe el orden temporal. Para cualquier conjunto de datos donde las filas tienen un componente temporal (precios de acciones, actividad de usuarios, datos de sensores), esto genera fuga del futuro al pasado. La validación cruzada para series temporales utiliza ventanas expandidas o deslizantes: el conjunto de entrenamiento de cada fold contiene únicamente datos anteriores al conjunto de validación. scikit-learn proporciona TimeSeriesSplit para este patrón.

Deep Learning y Redes Neuronales

P12: ¿Por qué las redes profundas usan ReLU en lugar de sigmoide, y cuándo falla ReLU?

Sigmoide comprime las salidas al intervalo (0, 1), pero su gradiente se desvanece para entradas extremas: cerca de 0 o 1, el gradiente se aproxima a cero, deteniendo la retropropagación en redes profundas. ReLU (max(0, x)) tiene un gradiente constante de 1 para entradas positivas, lo que permite un entrenamiento más rápido. ReLU falla cuando las neuronas reciben entradas consistentemente negativas (el problema de "ReLU muerto"), produciendo gradientes permanentemente nulos. Leaky ReLU y GELU (utilizado en Transformers) abordan esto permitiendo gradientes pequeños para valores negativos.

P13: Explique el mecanismo de atención y por qué los Transformers reemplazaron a las RNN para tareas de secuencias.

Las RNN procesan las secuencias paso a paso, creando un cuello de botella: la información de los tokens tempranos debe sobrevivir a través de cada estado oculto subsiguiente. La atención calcula relaciones directas por pares entre todas las posiciones simultáneamente, con complejidad O(n²) pero con paralelización completa. La auto-atención en los Transformers produce matrices de Query, Key y Value a partir de la entrada, calculando los pesos de atención como softmax(QK^T / sqrt(d_k)) * V.

# self_attention.py
import torch
import torch.nn.functional as F

def self_attention(x, d_k):
    """Scaled dot-product self-attention from scratch."""
    # x shape: (batch_size, seq_len, d_model)
    batch_size, seq_len, d_model = x.shape

    # Linear projections for Q, K, V
    W_q = torch.randn(d_model, d_k) * 0.1
    W_k = torch.randn(d_model, d_k) * 0.1
    W_v = torch.randn(d_model, d_k) * 0.1

    Q = x @ W_q  # (batch, seq_len, d_k)
    K = x @ W_k
    V = x @ W_v

    # Scaled dot-product attention
    scores = Q @ K.transpose(-2, -1) / (d_k ** 0.5)  # (batch, seq_len, seq_len)
    weights = F.softmax(scores, dim=-1)  # attention weights
    output = weights @ V  # (batch, seq_len, d_k)

    return output, weights

# Example: 1 batch, 4 tokens, 8-dim embeddings
x = torch.randn(1, 4, 8)
out, attn = self_attention(x, d_k=8)
print(f"Output shape: {out.shape}")    # (1, 4, 8)
print(f"Attention weights:\n{attn[0].detach().numpy().round(3)}")

La ventaja clave: la atención permite al modelo conectar directamente cualquier par de posiciones independientemente de su distancia, resolviendo el problema de dependencias de largo alcance que afectaba a las LSTM.

P14: ¿Cuál es la diferencia entre fine-tuning y transfer learning, y cuándo aplica cada uno?

El transfer learning utiliza las representaciones aprendidas por un modelo preentrenado como punto de partida. El fine-tuning es una estrategia específica de transfer learning que descongela algunas o todas las capas preentrenadas y continúa el entrenamiento sobre la tarea objetivo. La extracción de características (otra estrategia) congela todas las capas preentrenadas y solo entrena una nueva cabeza de clasificación. El fine-tuning funciona mejor con datos objetivo moderados (miles de muestras). La extracción de características es adecuada para conjuntos de datos pequeños donde el fine-tuning completo generaría sobreajuste.

SQL y Manipulación de Datos

P15: Escriba una consulta para encontrar el segundo salario más alto en cada departamento sin usar funciones de ventana.

-- second_highest_salary.sql
-- Approach: correlated subquery counting distinct higher salaries
SELECT d.department_name, e.employee_name, e.salary
FROM employees e
JOIN departments d ON e.department_id = d.id
WHERE (
    SELECT COUNT(DISTINCT e2.salary)
    FROM employees e2
    WHERE e2.department_id = e.department_id
      AND e2.salary > e.salary
) = 1
ORDER BY d.department_name;

Los entrevistadores usan esta pregunta para verificar los fundamentos de SQL sin la conveniencia de RANK() o DENSE_RANK(). La pregunta de seguimiento consiste en resolverlo con funciones de ventana, lo que es más limpio pero evalúa una habilidad distinta.

P16: Explique la diferencia entre WHERE y HAVING. ¿En qué momento se evalúa cada uno?

WHERE filtra las filas antes de la agregación. HAVING filtra los grupos después de la agregación. En el orden de ejecución de SQL, WHERE se aplica durante la fase de escaneo de filas, GROUP BY crea los grupos, las funciones de agregación calculan sus valores y luego HAVING filtra esos grupos. Un error frecuente es utilizar HAVING sin GROUP BY o intentar referenciar alias definidos en SELECT desde dentro de WHERE.

Ciencia de Datos Aplicada y Diseño de Sistemas

P17: ¿Cómo diseñaría un test A/B para un nuevo algoritmo de recomendación?

El diseño requiere cinco componentes: (1) una métrica primaria clara (por ejemplo, tasa de clics, tasa de conversión o ingresos por usuario), (2) un análisis de potencia para determinar el tamaño de la muestra, (3) aleatorización a nivel de usuario (no a nivel de sesión, para evitar la contaminación cruzada), (4) métricas de guarda que no deben degradarse (latencia, tasa de fallos) y (5) un plan de análisis pre-registrado para prevenir el p-hacking.

P18: Un modelo funciona bien en validación pero mal en producción. ¿Cuáles son las tres causas principales?

1. Desplazamiento de distribución: los datos de entrenamiento no representan el tráfico de producción (demografía diferente de usuarios, períodos de tiempo o geografías distintas)
2. Sesgo de características: las características se calculan de forma diferente en los pipelines de entrenamiento (batch) y de inferencia (tiempo real): el parseo de timestamps, el manejo de valores faltantes o las ventanas de agregación divergen
3. Fuga de etiquetas: la etiqueta de entrenamiento se derivó de datos no disponibles en el momento de la predicción en producción

El diagnóstico comienza comparando las distribuciones de características entre entrenamiento y producción mediante pruebas estadísticas (prueba KS, PSI — Índice de Estabilidad de Población) aplicadas de forma independiente a cada característica.

P19: Explique el teorema CAP y sus implicaciones para los feature stores en ML.

CAP establece que un sistema distribuido puede garantizar como máximo dos de tres propiedades: Consistencia (cada lectura devuelve la última escritura), Disponibilidad (cada solicitud recibe una respuesta) y Tolerancia a Particiones (el sistema opera a pesar de fallos de red). Los feature stores enfrentan directamente este balance: los almacenes en línea (Redis, DynamoDB) priorizan la disponibilidad y la tolerancia a particiones, aceptando consistencia eventual. Los almacenes fuera de línea (BigQuery, Hive) priorizan la consistencia para el entrenamiento por lotes. Una arquitectura de doble almacén sirve a ambas necesidades.

P20: ¿Cómo se gestiona el concept drift en un sistema de ML en producción?

El concept drift ocurre cuando la relación estadística entre las características y el objetivo cambia con el tiempo. Los métodos de detección incluyen el monitoreo de desplazamientos en la distribución de predicciones (PSI sobre las salidas del modelo), el seguimiento de métricas de rendimiento sobre datos de producción etiquetados y pruebas estadísticas sobre las distribuciones de características entrantes. Las estrategias de mitigación incluyen el reentrenamiento programado sobre una ventana deslizante, el aprendizaje en línea para la deriva gradual, o la activación del reentrenamiento cuando las métricas de deriva superan umbrales definidos.

Python y Dominio de Pandas

P21: ¿Cuál es la diferencia entre apply(), map() y transform() en Pandas?

map() opera elemento a elemento sobre una Serie únicamente. apply() funciona tanto en Series como en DataFrames, pasando cada fila o columna a una función. transform() requiere que la salida tenga la misma forma que la entrada: no puede agregar. La implicación práctica: transform() permite cálculos a nivel de grupo que se difunden de vuelta al índice original, algo que apply() también puede hacer pero con menor eficiencia.

# pandas_operations.py
import pandas as pd

df = pd.DataFrame({
    'team': ['A', 'A', 'B', 'B', 'A'],
    'score': [10, 20, 30, 40, 50]
})

# map: element-wise on Series
df['team_upper'] = df['team'].map({'A': 'Alpha', 'B': 'Beta'})

# apply: arbitrary function per row
df['score_label'] = df['score'].apply(lambda x: 'high' if x > 25 else 'low')

# transform: group-level, same shape output (broadcasts back)
df['team_mean'] = df.groupby('team')['score'].transform('mean')
df['score_normalized'] = df.groupby('team')['score'].transform(
    lambda x: (x - x.mean()) / x.std()
)
print(df)

P22: Explique el GIL de Python y su impacto en los flujos de trabajo de ciencia de datos.

El Global Interpreter Lock impide que múltiples hilos ejecuten bytecode de Python simultáneamente. Las tareas con uso intensivo de CPU (cómputo numérico, entrenamiento de modelos) no se benefician del threading. Esta es la razón por la que NumPy, pandas y scikit-learn utilizan extensiones en C que liberan el GIL, y por qué el multiprocesamiento (no el threading) es la estrategia estándar de paralelismo para código Python puro. Para tareas con uso intensivo de I/O (llamadas a APIs, consultas a bases de datos), el threading funciona porque el GIL se libera durante las esperas de I/O.

Reducción de Dimensionalidad y Aprendizaje No Supervisado

P23: PCA vs. t-SNE vs. UMAP: ¿cuándo aplica cada método?

PCA es un método lineal que maximiza la varianza en las dimensiones proyectadas. Preserva la estructura global y es determinista, lo que lo hace adecuado para preprocesamiento (reducir el número de características antes del modelado) y para visualizaciones interpretables. t-SNE es no lineal, optimizado para visualización en 2D/3D preservando los vecindarios locales. Distorsiona las distancias globales y no es adecuado para preprocesamiento. UMAP preserva tanto la estructura local como la global mejor que t-SNE, se ejecuta más rápido en conjuntos de datos grandes y produce resultados más consistentes entre ejecuciones.

| Method | Linear | Preserves Global Structure | Speed (100K points) | Use Case | |--------|--------|---------------------------|---------------------|----------| | PCA | Yes | Yes | Seconds | Preprocessing, feature reduction | | t-SNE | No | No | Minutes | Cluster visualization (small data) | | UMAP | No | Partially | Seconds | Visualization + preprocessing |

P24: ¿Cómo falla K-means y qué alternativas manejan clusters no esféricos?

K-means asume clusters esféricos de tamaño uniforme y utiliza distancia euclidiana. Falla con clusters alargados, en forma de anillo o con variación de densidad. DBSCAN identifica clusters por densidad, manejando formas arbitrarias y detectando automáticamente los valores atípicos. Los Modelos de Mezcla Gaussiana (GMM) modelan cada cluster como una distribución gaussiana multivariada, permitiendo formas elípticas. El clustering espectral utiliza los vectores propios del Laplaciano del grafo y maneja geometrías complejas, pero escala mal más allá de aproximadamente 10,000 puntos.

Comunicación e Impacto en el Negocio

P25: Un stakeholder pregunta: "¿Cuáles son las características más importantes del modelo?" ¿Cómo se responde?

La importancia de las características tiene múltiples definiciones válidas y la respuesta depende de la audiencia. Para los modelos basados en árboles existen tres medidas comunes: importancia basada en divisiones (con qué frecuencia se usa una característica en los splits), importancia basada en ganancia (reducción total en la pérdida generada por los splits de esa característica) e importancia por permutación (cuánto cae el rendimiento cuando una característica se mezcla aleatoriamente). Los valores SHAP proporcionan la respuesta más rigurosa: cuantifican la contribución de cada característica a las predicciones individuales usando principios de teoría de juegos.

# feature_importance_shap.py
import shap
import xgboost as xgb
from sklearn.datasets import make_classification

# Generate synthetic dataset
X, y = make_classification(n_samples=1000, n_features=10,
                           n_informative=5, random_state=42)

# Train XGBoost model
model = xgb.XGBClassifier(n_estimators=100, random_state=42, eval_metric='logloss')
model.fit(X, y)

# SHAP explanation
explainer = shap.TreeExplainer(model)
shap_values = explainer.shap_values(X)

# Global importance: mean absolute SHAP value per feature
import numpy as np
importance = np.abs(shap_values).mean(axis=0)
for i in np.argsort(importance)[::-1]:
    print(f"Feature {i}: {importance[i]:.4f}")

Para los stakeholders, es fundamental traducir los valores SHAP al lenguaje del negocio: "Los clientes con ingresos superiores a $80,000 tienen un 15% más de probabilidad de convertirse, manteniendo todo lo demás constante", en lugar de "La característica 3 tiene un valor SHAP medio de 0.23".

Conclusión

• La precisión en las pruebas de hipótesis importa: es necesario saber cuándo aplicar pruebas binomiales, comprender los p-valores y distinguir el razonamiento bayesiano del frecuentista
• La ingeniería de características suele determinar el rendimiento del modelo más que la elección del algoritmo: dominar el target encoding, las estrategias para datos faltantes y la prevención de fugas es fundamental
• La evaluación va más allá de la exactitud: utilizar AUPRC para datos desbalanceados, TimeSeriesSplit para datos temporales y pipelines para prevenir fugas en el preprocesamiento
• Los fundamentos de deep learning (atención, funciones de activación, transfer learning) aparecen incluso en roles de data science que trabajan principalmente con métodos tabulares
• Las preguntas sobre ML en producción (detección de drift, tests A/B, feature stores) separan cada vez más a los candidatos senior de los junior
• Las habilidades de comunicación se evalúan mediante la explicación de la importancia de las características: practicar la traducción de los valores SHAP a lenguaje comprensible para los stakeholders es una ventaja diferencial