Preguntas de entrevista Senior Ingeniero de ML / Algoritmos

Qué se espera en el nivel Senior

Se espera diseño de sistemas de ML, fiabilidad en producción y criterio de investigación a producto.

Preguntas de ejemplo para entrevista de Ingeniero de ML / Algoritmos

• TécnicaExplica el compromiso entre sesgo y varianza y cómo lo afecta la regularización.
  Lo que cubre una buena respuesta

  • Sesgo: error por asunciones incorrectas del modelo
  • Varianza: sensibilidad a pequeñas fluctuaciones en los datos
  • Tradeoff: modelos simples alto sesgo baja varianza; modelos complejos bajo sesgo alta varianza
  • Regularización L1/L2: penaliza pesos grandes, reduce varianza pero aumenta sesgo
  • Validación cruzada para encontrar el punto óptimo de sesgo-varianza

  Ver respuesta de ejemplo

  El compromiso sesgo-varianza describe cómo la capacidad del modelo afecta el error total. El sesgo es el error por asunciones simplificadoras (por ejemplo, regresión lineal con datos no lineales), mientras que la varianza es la sensibilidad a pequeñas fluctuaciones en los datos (por ejemplo, un árbol de decisión profundo). Modelos con alta capacidad (como polinomios de grado alto) tienden a bajo sesgo y alta varianza, sobreajustando; modelos con baja capacidad (grado bajo) tienen alto sesgo y baja varianza, subajustando. La regularización, como L1 (Lasso) o L2 (Ridge), añade una penalización a los coeficientes, lo que aumenta el sesgo pero reduce la varianza, ayudando a controlar el sobreajuste. El objetivo es minimizar el error total = sesgo² + varianza + ruido irreducible. La validación cruzada es clave para seleccionar el grado de regularización óptimo. Un error común es pensar que más regularización siempre mejora, pero puede causar underfitting.

• Técnica¿Cómo detectarías y evitarías la fuga de datos en un pipeline de entrenamiento?
  Lo que cubre una buena respuesta

  • Fuga de datos: información del conjunto de test influye en el entrenamiento
  • Ejemplos: escalado antes de split, imputación con datos globales, target encoding con test
  • Técnicas: dividir datos antes de cualquier transformación, usar pipelines (sklearn Pipeline)
  • Validación temporal para series de tiempo
  • Monitoreo de features con correlación inusualmente alta con el target

  Ver respuesta de ejemplo

  La fuga de datos ocurre cuando información del conjunto de prueba o del futuro se filtra al entrenamiento. Por ejemplo, normalizar usando la media de todo el dataset (incluyendo test) o hacer imputación de valores perdidos con estadísticas globales. Para evitarla, siempre se deben separar los datos en entrenamiento y prueba antes de cualquier transformación. Utilizar pipelines como los de sklearn asegura que las transformaciones (escalado, imputación, etc.) se aprendan solo en el conjunto de entrenamiento. En series de tiempo, se debe usar validación temporal (walk-forward) para respetar el orden temporal. También es importante revisar features que tienen una correlación extremadamente alta con el target, lo que puede indicar fuga (por ejemplo, incluir el target del día siguiente). Un seguimiento común: si las métricas en entrenamiento son mucho mejores que en test, probablemente hay fuga.

• Técnica¿Qué métrica optimizarías para un problema de clasificación desbalanceado, y por qué?
  Lo que cubre una buena respuesta

  • Exactitud no es adecuada por clases mayoritarias
  • F1-score para clase minoritaria o F1 macro
  • Área bajo la curva Precision-Recall (PR AUC) más sensible que ROC AUC
  • Considerar costos de errores: minimizar falsos negativos si es crítico
  • Umbral óptimo usando curvas de beneficio

  Ver respuesta de ejemplo

  En clasificación desbalanceada, la exactitud (accuracy) es engañosa porque predecir siempre la clase mayoritaria puede dar alta exactitud. Es mejor usar métricas como precisión, recall y F1-score. Para la clase minoritaria, F1-score (media armónica de precisión y recall) es útil. Si hay múltiples clases, se puede usar F1 macro (media simple) o F1 weighted (ponderado por soporte). El área bajo la curva ROC (ROC AUC) puede ser optimista con desbalance severo, mientras que el área bajo la curva Precision-Recall (PR AUC) es más informativa porque se enfoca en la clase positiva. Además, se debe considerar el costo de los errores (por ejemplo, en detección de fraude, minimizar falsos negativos es prioritario, lo que lleva a optimizar recall aunque baje precisión). Un error común es usar accuracy o ROC AUC sin ajustar umbral ni evaluar el impacto de negocio.

• ProgramaciónImplementa el clustering k-means desde cero.
  Lo que cubre una buena respuesta

  • Inicialización de centroides (aleatoria o k-means++)
  • Asignación de puntos al centroide más cercano
  • Actualización de centroides como media de puntos asignados
  • Convergencia: centroides no cambian o número máximo de iteraciones
  • Complejidad: O(n*k*d*i) por iteración

  Ver respuesta de ejemplo

  La implementación de k-means desde cero incluye: inicializar k centroides aleatoriamente (o usar k-means++ para mejor convergencia), luego iterar dos pasos: asignar cada punto al centroide más cercano (usando distancia euclidiana) y actualizar cada centroide como la media de los puntos asignados. El algoritmo converge cuando los centroides no cambian significativamente o tras un número máximo de iteraciones. Un detalle importante es manejar clusters vacíos (no actualizar centroide). La complejidad temporal es O(n*k*d*i) por iteración, donde n es número de puntos, k clusters, d dimensiones, i iteraciones. Un inconveniente común: la inicialización influye mucho en el resultado, por lo que se recomienda ejecutar varias veces. La complejidad espacial es O(n*k) para almacenar distancias.

  import numpy as np
  
  def k_means(X, k, max_iters=100, tol=1e-4):
      """
      Implementación de k-means desde cero.
      X: matriz de datos (n_samples, n_features)
      k: número de clusters
      max_iters: máximo de iteraciones
      tol: tolerancia para convergencia
      Retorna: centroides, etiquetas
      """
      n_samples, n_features = X.shape
      # Inicialización aleatoria de centroides
      np.random.seed(42)
      centroides = X[np.random.choice(n_samples, k, replace=False)]
      
      for i in range(max_iters):
          # Asignación: calcular distancias euclidianas al cuadrado
          distancias = np.linalg.norm(X[:, np.newaxis] - centroides, axis=2) ** 2
          etiquetas = np.argmin(distancias, axis=1)
          
          # Actualización: nuevos centroides como media de puntos asignados
          nuevos_centroides = np.zeros_like(centroides)
          for j in range(k):
              puntos_cluster = X[etiquetas == j]
              if len(puntos_cluster) > 0:
                  nuevos_centroides[j] = puntos_cluster.mean(axis=0)
              else:
                  nuevos_centroides[j] = centroides[j]  # evitar cluster vacío
          
          # Verificar convergencia
          if np.linalg.norm(nuevos_centroides - centroides) < tol:
              centroides = nuevos_centroides
              break
          centroides = nuevos_centroides
      
      return centroides, etiquetas
  
  # Ejemplo de uso
  if __name__ == "__main__":
      from sklearn.datasets import make_blobs
      X, _ = make_blobs(n_samples=300, centers=3, random_state=42)
      centroides, etiquetas = k_means(X, 3)
      print("Centroides:\n", centroides)

• ProgramaciónResuelve un problema de programación dinámica y analiza su complejidad.
  Lo que cubre una buena respuesta

  • Problema: mochila 0/1 (0/1 Knapsack) – maximizar valor sin exceder peso
  • Subestructura óptima y subproblemas superpuestos
  • Tabla DP de tamaño (n+1) x (W+1)
  • Complejidad temporal O(n*W), espacial O(n*W) o O(W) con optimización
  • Recuperación de elementos seleccionados

  Ver respuesta de ejemplo

  El problema de la mochila 0/1 (0/1 Knapsack) es un clásico de programación dinámica. Dados n objetos con pesos y valores, y una capacidad máxima W, se busca maximizar el valor total sin exceder el peso. La subestructura óptima: para cada objeto y peso restante, decidir si incluirlo o no. La relación de recurrencia: dp[i][w] = max(dp[i-1][w], dp[i-1][w-peso_i] + valor_i) si el peso entra; si no, dp[i][w] = dp[i-1][w]. Se construye una tabla de tamaño (n+1)×(W+1). La complejidad temporal es O(n*W) y espacial O(n*W). Se puede optimizar espacio a O(W) usando un arreglo unidimensional, pero cuidado con el orden de actualización (de derecha a izquierda). Un error común: no manejar correctamente la capacidad cero o índices.

  def mochila_01(valores, pesos, W):
      """
      Resuelve el problema de la mochila 0/1.
      valores: lista de valores de los objetos
      pesos: lista de pesos de los objetos
      W: capacidad máxima de la mochila
      Retorna: valor máximo y lista de índices seleccionados
      """
      n = len(valores)
      # Tabla DP: dp[i][w] = max valor usando primeros i objetos con peso <= w
      dp = [[0] * (W + 1) for _ in range(n + 1)]
      
      for i in range(1, n + 1):
          vi = valores[i-1]
          pi = pesos[i-1]
          for w in range(W + 1):
              if pi <= w:
                  dp[i][w] = max(dp[i-1][w], dp[i-1][w - pi] + vi)
              else:
                  dp[i][w] = dp[i-1][w]
      
      valor_maximo = dp[n][W]
      # Recuperar elementos seleccionados
      seleccionados = []
      w = W
      for i in range(n, 0, -1):
          if dp[i][w] != dp[i-1][w]:
              seleccionados.append(i-1)
              w -= pesos[i-1]
      seleccionados.reverse()
      return valor_maximo, seleccionados
  
  # Ejemplo de uso
  if __name__ == "__main__":
      valores = [60, 100, 120]
      pesos = [10, 20, 30]
      capacidad = 50
      valor, items = mochila_01(valores, pesos, capacidad)
      print(f"Valor máximo: {valor}")
      print(f"Elementos seleccionados: {items}")

• Diseño de sistemasDiseña un sistema de recomendación para una plataforma de video.
  Lo que cubre una buena respuesta

  • Requisitos: personalización, baja latencia, escalabilidad, cold start
  • Componentes: recolección de eventos, feature store, modelo de candidatos, ranking
  • Arquitectura: batch + streaming para actualización de embeddings
  • Algoritmos: Filtrado colaborativo (Matrix Factorization), contenido (embeddings de video), híbrido
  • Bottlenecks: latencia de búsqueda en millones de videos, frescura de datos

  Ver respuesta de ejemplo

  Un sistema de recomendación para video requiere: personalización en tiempo real, baja latencia (<200ms), escalar a millones de usuarios y videos, manejar cold start para nuevos usuarios/videos. La arquitectura típica tiene dos etapas: candidatos (generar un conjunto amplio) y ranking (ordenar con modelo más complejo). En la etapa de candidatos, se usan métodos como filtrado colaborativo (Matrix Factorization de interacciones usuario-video), embeddings de contenido (características de video) y búsqueda de vecinos cercanos (FAISS) para escalar. En ranking, se puede usar un modelo de aprendizaje (por ejemplo, gradient boosting o red neuronal) con features de usuario, video y contexto. Los datos se recogen mediante un pipeline de streaming (Kafka) y se transforman en un feature store (por ejemplo, Redis). El cold start se aborda con recomendaciones basadas en popularidad o contenido. Los principales cuellos de botella son la latencia de búsqueda de vecinos cercanos (se usa ANN) y la actualización de modelos (se recomienda reentrenamiento periódico).

• ConductualCuéntame de un modelo que falló en producción y qué aprendiste.
  Lo que cubre una buena respuesta

  • Situación: modelo de detección de anomalías en transacciones
  • Tarea: mantener rendimiento ante cambios de distribución
  • Acción: implementó monitoreo de drift (PSI), alertas, reentrenamiento automático
  • Resultado: reducción de falsos positivos en 30% y mejora en recall
  • Lecciones: importancia de monitoreo en producción, validación continua

  Ver respuesta de ejemplo

  En un proyecto de detección de fraude, desplegamos un modelo basado en XGBoost que funcionaba bien en offline. En producción, después de dos semanas, la tasa de falsos positivos se disparó. Investigando, descubrimos que el perfil de las transacciones había cambiado (drift en las features de monto y hora) debido a una campaña promocional. No teníamos monitoreo de drift. La lección aprendida fue crucial: ahora implementamos monitoreo continuo de la distribución de features y predicciones (Population Stability Index), y alertas automáticas. También establecimos un pipeline de reentrenamiento automático con los nuevos datos etiquetados. Como resultado, el modelo se mantuvo robusto, reduciendo los falsos positivos en un 30%. Aprendí que los modelos no son estáticos y requieren vigilancia constante, y que la comunicación con el equipo de negocio es clave para entender cambios en el entorno.

• Conductual¿Cómo decides que un modelo es lo bastante bueno para lanzarlo?
  Lo que cubre una buena respuesta

  • Definir métricas de negocio vs. métricas técnicas
  • Comparar con baseline (modelo simple o heurística)
  • Evaluar en conjunto de test representativo y con intervalos de confianza
  • Realizar A/B testing en producción con significancia estadística
  • Considerar trade-offs: latencia, costo computacional, mantenimiento

  Ver respuesta de ejemplo

  Decidir si un modelo es suficientemente bueno para lanzar depende de varios criterios. Primero, se deben definir métricas de negocio relevantes (por ejemplo, ingresos, retención) y comparar el modelo con una baseline (modelo actual o heurística). En offline, se evalúa con un conjunto de test representativo, usando intervalos de confianza (bootstrap) para determinar si la mejora es significativa. Luego, se realiza un A/B test en producción con tráfico real, asegurando que el experimento tenga suficiente poder estadístico. No solo importa la precisión; también hay que considerar la latencia (el modelo debe responder en tiempo), el costo computacional (infraestructura) y la facilidad de mantenimiento. Por ejemplo, si un modelo mejora un 1% en precisión pero duplica la latencia, podría no valer la pena. Además, se debe monitorear posibles derivas post-lanzamiento. Mi recomendación: definir un umbral mínimo de mejora en la métrica principal y cumplir con restricciones operativas.

Qué evalúan los entrevistadores

Cómo prepararte

• Vincula cada decisión de modelado con la métrica y el objetivo de negocio.
• Prepárate para hablar de modos de fallo: fuga de datos, deriva y desajuste offline/online.
• Mantén afilada tu programación: las rondas de algoritmos siguen siendo un filtro común.

Preguntas frecuentes