Questions d'entretien Senior Ingénieur ML / Algorithmes

Ce qui est attendu au niveau Senior

On attend de la conception de systèmes ML, de la fiabilité en production et du jugement de la recherche au produit.

Exemples de questions d'entretien pour Ingénieur ML / Algorithmes

• TechniqueExpliquez le compromis biais-variance et comment la régularisation l'influence.
  Ce qu'une bonne réponse couvre

  • compromis biais-variance
  • sous-apprentissage vs sur-apprentissage
  • régularisation L1/L2
  • effet sur la variance
  • choix du paramètre de régularisation (valid croisée)

  Voir un exemple de réponse

  Le compromis biais-variance décrit le tradeoff entre l'erreur due au biais (sous-apprentissage) et l'erreur due à la variance (sur-apprentissage). Un modèle simple a un biais élevé mais une faible variance, tandis qu'un modèle complexe a un faible biais mais une forte variance. La régularisation ajoute une pénalité sur la magnitude des poids, ce qui réduit la variance en augmentant légèrement le biais. Par exemple, la régularisation L2 (Ridge) pénalise la somme des carrés des coefficients, L1 (Lasso) peut annuler certains coefficients. Le paramètre de régularisation λ contrôle ce tradeoff : plus λ est grand, plus la variance diminue et le biais augmente. On utilise la validation croisée pour choisir λ optimal. Un piège courant est d'appliquer une régularisation trop forte et d'obtenir un modèle sous-ajusté.

• TechniqueComment détecteriez-vous et éviteriez-vous une fuite de données dans un pipeline d'entraînement ?
  Ce qu'une bonne réponse couvre

  • fuite temporelle (time travel)
  • normalisation avant split
  • encodage de cible (target encoding)
  • pipeline pour éviter les fuites
  • validation croisée incorrecte

  Voir un exemple de réponse

  La fuite de données (data leakage) se produit lorsque des informations du futur ou de l'ensemble de test sont utilisées pendant l'entraînement, ce qui donne des performances irréalistes. Pour la détecter, on peut vérifier si les performances hors échantillon sont anormalement élevées, ou analyser les étapes de feature engineering. Pour l'éviter, il faut toujours séparer les données en train/test avant toute transformation. Par exemple, le centrage-réduction doit être appris sur le train seul. Les pipelines (ex. sklearn Pipeline) garantissent que les opérations sont ajustées uniquement sur les plis d'entraînement pendant la validation croisée. Un cas classique est l'encodage de la cible sans cross-validation, qui introduit une fuite. Il faut aussi éviter d'utiliser des informations temporellement futures pour les séries temporelles. Un piège fréquent est d'imputer les valeurs manquantes avec la moyenne de tout le dataset avant le split.

• TechniqueQuelle métrique optimiseriez-vous pour un problème de classification déséquilibré, et pourquoi ?
  Ce qu'une bonne réponse couvre

  • accuracy non fiable
  • précision, rappel, F1 (macro/micro/weighted)
  • AUC-ROC vs AUC-PR
  • coût des erreurs (FP vs FN)
  • seuil de décision ajustable

  Voir un exemple de réponse

  Pour un problème de classification déséquilibré, l'accuracy n'est pas pertinente car un classifieur prédisant toujours la classe majoritaire peut obtenir un score élevé. Je recommande d'optimiser une métrique qui tient compte du coût des erreurs. Le F1-score (moyenne harmonique de précision et rappel) est utile, mais il peut être biaisé ; on peut utiliser le F1 macro ou pondéré. L'AUC-ROC est souvent trop optimiste car elle intègre les vrais négatifs ; l'AUC-PR est préférable car elle se concentre sur la classe positive. Le choix final dépend du coût métier : si les faux positifs sont coûteux, on maximise la précision ; si les faux négatifs sont coûteux, on maximise le rappel. On peut également ajuster le seuil de décision après entraînement. Un piège courant est d'optimiser une métrique générique sans considérer les conséquences réelles des erreurs.

• ProgrammationImplémentez le clustering k-means de zéro.
  Ce qu'une bonne réponse couvre

  • initialisation (k-means++ ou aléatoire)
  • distance euclidienne
  • mise à jour des centroïdes (moyenne)
  • convergence (centroïdes stables)
  • choix de k (coude, silhouette)

  Voir un exemple de réponse

  L'algorithme k-means regroupe n points en k clusters en minimisant la somme des distances euclidiennes au carré entre les points et leur centroïde. Initialisation : souvent aléatoire, mais k-means++ améliore la convergence. Étapes : 1) assigner chaque point au centroïde le plus proche ; 2) recalculer chaque centroïde comme la moyenne des points qui lui sont assignés ; répéter jusqu'à convergence (peu de changement). La complexité temporelle est O(t * k * n * d), où t est le nombre d'itérations, k le nombre de clusters, n le nombre de points, d la dimensionnalité. L'algorithme ne garantit pas l'optimalité global ; il est sensible à l'initialisation et aux outliers. Pour choisir k, on utilise la méthode du coude ou le score de silhouette. Un piège courant est de supposer que les clusters sont sphériques et de taille similaire.

  import numpy as np
  
  def kmeans(X, k, max_iters=100, tol=1e-4):
      # Initialisation aléatoire des centroïdes
      centroids = X[np.random.choice(X.shape[0], k, replace=False)]
      for _ in range(max_iters):
          # Distance euclidienne de chaque point à chaque centroïde
          distances = np.linalg.norm(X[:, np.newaxis] - centroids, axis=2)
          # Assignation au centroïde le plus proche
          labels = np.argmin(distances, axis=1)
          # Nouveaux centroïdes : moyenne des points par cluster
          new_centroids = np.array([X[labels == i].mean(axis=0) if np.any(labels == i) else centroids[i] for i in range(k)])
          # Vérifier la convergence
          if np.linalg.norm(new_centroids - centroids) < tol:
              break
          centroids = new_centroids
      return labels, centroids

• ProgrammationRésolvez un problème de programmation dynamique et analysez sa complexité.
  Ce qu'une bonne réponse couvre

  • sous-structure optimale
  • sous-problèmes chevauchants
  • tableau de programmation dynamique
  • reconstruction de la solution
  • complexité O(n*m)

  Voir un exemple de réponse

  Pour un problème de plus longue sous-séquence commune (LCS), on utilise la programmation dynamique. On définit dp[i][j] = longueur du LCS des préfixes X[0:i] et Y[0:j]. Récurrence : si X[i-1] == Y[j-1], dp[i][j] = dp[i-1][j-1] + 1 ; sinon dp[i][j] = max(dp[i-1][j], dp[i][j-1]). Initialisation : première ligne et première colonne à 0. On remplit la matrice de taille (n+1) x (m+1). La solution est dans dp[n][m]. Pour reconstruire la séquence, on remonte la matrice. Complexité temporelle et spatiale : O(n*m). On peut réduire la mémoire à O(min(n,m)) en ne gardant que deux lignes. Un piège courant est d'implémenter récursivement sans mémoïsation, ce qui conduit à une complexité exponentielle.

  def lcs(X, Y):
      n, m = len(X), len(Y)
      # Matrice de programmation dynamique
      dp = [[0] * (m + 1) for _ in range(n + 1)]
      for i in range(1, n + 1):
          for j in range(1, m + 1):
              if X[i - 1] == Y[j - 1]:
                  dp[i][j] = dp[i - 1][j - 1] + 1
              else:
                  dp[i][j] = max(dp[i - 1][j], dp[i][j - 1])
      # Reconstruction
      seq = []
      i, j = n, m
      while i > 0 and j > 0:
          if X[i - 1] == Y[j - 1]:
              seq.append(X[i - 1])
              i -= 1
              j -= 1
          elif dp[i - 1][j] > dp[i][j - 1]:
              i -= 1
          else:
              j -= 1
      return ''.join(reversed(seq))

• Conception de systèmesConcevez un système de recommandation pour une plateforme vidéo.
  Ce qu'une bonne réponse couvre

  • filtrage collaboratif (implicite/explicite)
  • filtrage basé contenu (tags, métadonnées)
  • approche hybride
  • problème de démarrage à froid
  • évaluation hors ligne (Recall@k, NDCG) et A/B testing

  Voir un exemple de réponse

  Pour une plateforme vidéo, je conçois un système hybride combinant filtrage collaboratif et basé contenu. Les exigences sont : suggestions personnalisées à partir des vues, likes, et historique ; gestion des nouveaux utilisateurs/vidéos (froid) ; passage à l'échelle. Composants clés : un modèle deux-tours (user tower et item tower) apprenant des embeddings en commun. On utilise les interactions (implicites) comme signaux. Le filtrage basé contenu utilise les métadonnées (genre, acteurs) et le traitement NLP des descriptions. Pour la génération de candidats, on emploie un index ANN (faiss) pour trouver les vidéos les plus proches de l'embedding utilisateur. Le classement final peut être fait par un modèle de ranking (e.g., xgboost) intégrant des features contextuelles. Pour évaluer hors ligne : Recall@k, NDCG. En production : A/B test avec métriques de CTR, temps de visionnage, rétention. Les goulots d'étranglement incluent le calcul des embeddings pour les nouveaux éléments. Un piège courant est d'ignorer le biais de popularité ; on peut utiliser des techniques de debiasing.

• ComportementalParlez-moi d'un modèle qui a échoué en production et de ce que vous en avez appris.
  Ce qu'une bonne réponse couvre

  • sur-apprentissage non détecté
  • dérive des données (data drift)
  • latence élevée en production
  • monitoring insuffisant
  • leçons : retraining automatique, validation hors ligne robuste

  Voir un exemple de réponse

  J'ai travaillé sur un modèle de prédiction de rétention client qui a échoué en production. Situation : le modèle donnait des performances excellentes en validation offline (AUC > 0.95). Tâche : il devait être déployé pour cibler des clients à risque. Action : nous l'avons déployé sans vérifier la stabilité temporelle. Résultat : après deux semaines, les performances ont chuté (AUC ~0.6). La cause était une dérive des données : une campagne marketing avait changé le comportement des clients. Le modèle était entraîné sur des données antérieures sans tenir compte des changements. Ce que j'ai appris : il faut impérativement un monitoring des distributions des features et des prédictions, et définir des alertes. Mettre en place un retraining régulier (quotidien ou hebdomadaire). Avoir un plan de rollback facile. Tester le modèle sur une période de validation out-of-time avant déploiement. Un piège courant est de trop faire confiance aux métriques offline.

• ComportementalComment décidez-vous qu'un modèle est assez bon pour être mis en production ?
  Ce qu'une bonne réponse couvre

  • seuil de performance métier (ROI, lift)
  • validation hors ligne robuste (out-of-time, cross-validation)
  • A/B test avec significativité statistique
  • robustesse face à la dérive
  • contraintes de latence et ressources

  Voir un exemple de réponse

  Je décide qu'un modèle est prêt pour la production d'abord en alignant les métriques sur les objectifs business. Par exemple, une augmentation de 5% du taux de conversion justifie le déploiement. Ensuite, je vérifie les performances offline en validation croisée temporelle (pour éviter la fuite) et avec des métriques comme le lift sur la baseline. Mais le test ultime est un A/B test en ligne randomisé sur une fraction du trafic, avec un calcul de significativité (p-value < 0.05, puissance suffisante). Je m'assure aussi que le modèle est robuste à la dérive : on mesure la stabilité des prédictions sur un échantillon récent. Enfin, on vérifie les contraintes pratiques : latence (moins de 100ms), utilisation mémoire, et possibilité de mise à jour (retraining). Un piège est de se baser uniquement sur des métriques offline qui ne reproduisent pas les conditions réelles de déploiement.

Ce que les recruteurs évaluent

Comment se préparer

• Reliez chaque choix de modélisation à la métrique et à l'objectif métier.
• Soyez prêt à discuter des modes de défaillance : fuite, dérive et décalage hors-ligne/en-ligne.
• Gardez votre code affûté — les épreuves d'algorithmique restent un filtre courant.

Questions fréquentes