Algorithmes de Machine Learning : Guide Complet pour les Entretiens Techniques

Les algorithmes de machine learning constituent le socle de tout entretien technique en data science. Que le poste vise un role de ML Engineer, de Data Scientist ou d'analyste quantitatif, la capacite a expliquer le fonctionnement interne d'un algorithme, a choisir le bon modele selon le contexte et a evaluer correctement ses performances fait la difference entre un candidat moyen et un candidat qui obtient l'offre. Ce guide couvre les familles d'algorithmes essentielles, avec du code scikit-learn executable et les criteres d'evaluation attendus en entretien en 2026.

Regression lineaire : le fondement de l'apprentissage supervise

La regression lineaire reste l'algorithme le plus frequemment aborde en entretien, non pas pour sa complexite, mais parce qu'elle permet de tester la comprehension des concepts fondamentaux : la fonction de cout, la descente de gradient, le biais et la variance. Un candidat capable d'expliquer pourquoi la regression lineaire minimise la somme des carres des residus, puis de discuter ses limites sur des donnees non lineaires, demontre une base solide.

L'implementation suivante genere des donnees synthetiques reliant la surface habitable au prix d'un bien immobilier, entraine un modele et evalue ses performances via le R2 et le RMSE.

# linear_regression_demo.py
import numpy as np
from sklearn.linear_model import LinearRegression
from sklearn.model_selection import train_test_split
from sklearn.metrics import mean_squared_error, r2_score

# Generate synthetic housing data: square footage -> price
np.random.seed(42)
sqft = np.random.uniform(500, 3000, size=200).reshape(-1, 1)
price = 150 * sqft.flatten() + np.random.normal(0, 20000, size=200)

X_train, X_test, y_train, y_test = train_test_split(sqft, price, test_size=0.2)

model = LinearRegression()
model.fit(X_train, y_train)                    # Fit on training data
predictions = model.predict(X_test)            # Predict on unseen data

print(f"Coefficient: {model.coef_[0]:.2f}")    # Weight per sqft
print(f"R2 Score: {r2_score(y_test, predictions):.4f}")
print(f"RMSE: {np.sqrt(mean_squared_error(y_test, predictions)):.2f}")

Le coefficient obtenu represente l'augmentation de prix par unite de surface. Le R2 mesure la proportion de variance expliquee par le modele. En entretien, il est courant de devoir expliquer la difference entre R2 et R2 ajuste, ainsi que les hypotheses de la regression lineaire (linearite, homoscedasticite, independance des residus). Pour approfondir ce sujet, les questions d'entretien sur la regression supervisee couvrent les cas les plus frequents.

Classification par regression logistique

Malgre son nom, la regression logistique est un algorithme de classification. Elle modelise la probabilite d'appartenance a une classe via la fonction sigmoide, et la frontiere de decision se situe au seuil de 0.5 par defaut. La regularisation, controlee par le parametre C, empeche le surapprentissage en penalisant les coefficients eleves.

Ce code entraine un classifieur sur le dataset Breast Cancer de scikit-learn, un jeu de donnees standard pour la classification binaire.

# logistic_classification.py
from sklearn.linear_model import LogisticRegression
from sklearn.datasets import load_breast_cancer
from sklearn.model_selection import train_test_split
from sklearn.metrics import classification_report

data = load_breast_cancer()                    # Binary classification dataset
X_train, X_test, y_train, y_test = train_test_split(
    data.data, data.target, test_size=0.2, random_state=42
)

clf = LogisticRegression(max_iter=5000, C=1.0) # C controls regularization strength
clf.fit(X_train, y_train)
y_pred = clf.predict(X_test)

print(classification_report(y_test, y_pred, target_names=data.target_names))

Le classification_report affiche la precision, le rappel et le F1-score par classe. En entretien, la question classique porte sur le compromis precision/rappel : dans un contexte medical, un faux negatif (cancer non detecte) est bien plus grave qu'un faux positif (alerte inutile), ce qui implique de privilegier le rappel. Les questions sur la classification supervisee detaillent les scenarios typiques d'entretien sur ce theme.

Methodes d'ensemble : Random Forest et Gradient Boosting

Les methodes d'ensemble combinent plusieurs modeles faibles pour produire un modele fort. Deux approches dominent la pratique et les entretiens : le bagging (Random Forest) et le boosting (Gradient Boosting). Le bagging entraine des arbres en parallele sur des echantillons bootstrappes et reduit la variance. Le boosting entraine des arbres sequentiellement, chaque arbre corrigeant les erreurs du precedent, et reduit le biais.

# ensemble_comparison.py
from sklearn.ensemble import RandomForestClassifier, GradientBoostingClassifier
from sklearn.datasets import load_wine
from sklearn.model_selection import cross_val_score

data = load_wine()                             # 3-class classification
X, y = data.data, data.target

# Random Forest: parallel trees, reduces variance
rf = RandomForestClassifier(n_estimators=100, max_depth=5, random_state=42)
rf_scores = cross_val_score(rf, X, y, cv=5, scoring='accuracy')

# Gradient Boosting: sequential trees, reduces bias
gb = GradientBoostingClassifier(n_estimators=100, learning_rate=0.1, max_depth=3)
gb_scores = cross_val_score(gb, X, y, cv=5, scoring='accuracy')

print(f"Random Forest:     {rf_scores.mean():.4f} +/- {rf_scores.std():.4f}")
print(f"Gradient Boosting: {gb_scores.mean():.4f} +/- {gb_scores.std():.4f}")

La validation croisee a 5 plis donne une estimation fiable de la generalisation. En pratique, le Gradient Boosting surpasse souvent le Random Forest sur les donnees tabulaires propres, mais il est plus sensible aux hyperparametres. Un outil comme Optuna automatise cette recherche d'hyperparametres de maniere efficace.

| Criterion | Random Forest | Gradient Boosting | |-----------|--------------|-------------------| | Training speed | Fast (parallel) | Slower (sequential) | | Overfitting risk | Low | Higher without tuning | | Hyperparameter sensitivity | Low | High | | Feature importance | Built-in (impurity-based) | Built-in (gain-based) | | Best for | Baseline models, noisy data | Competitions, tabular data |

Ce tableau revient frequemment dans les entretiens sous forme de question ouverte : "Quand choisiriez-vous un Random Forest plutot qu'un Gradient Boosting ?" La reponse attendue mentionne le compromis vitesse/performance, la robustesse au bruit et le budget de reglage des hyperparametres. Pour un approfondissement complet des arbres et ensembles, consulter les questions d'entretien sur les arbres et methodes d'ensemble.

Apprentissage non supervise : clustering avec K-Means

Le clustering K-Means partitionne les donnees en k groupes en minimisant l'inertie (somme des distances intra-cluster). L'algorithme initialise k centroides, assigne chaque point au centroide le plus proche, recalcule les centroides, et itere jusqu'a convergence. Le choix de k est critique et repose sur deux metriques : le silhouette score (qualite de la separation entre clusters) et la methode du coude (point d'inflexion de l'inertie).

# kmeans_clustering.py
from sklearn.cluster import KMeans
from sklearn.preprocessing import StandardScaler
from sklearn.metrics import silhouette_score
from sklearn.datasets import load_iris

data = load_iris()
X = StandardScaler().fit_transform(data.data)  # Scale features first

# Test multiple values of k to find optimal cluster count
for k in [2, 3, 4, 5]:
    kmeans = KMeans(n_clusters=k, n_init=10, random_state=42)
    labels = kmeans.fit_predict(X)
    sil = silhouette_score(X, labels)          # Higher = better-defined clusters
    inertia = kmeans.inertia_                  # Within-cluster sum of squares
    print(f"k={k}: silhouette={sil:.3f}, inertia={inertia:.1f}")

La normalisation (StandardScaler) avant le clustering est indispensable : K-Means utilise la distance euclidienne, et des variables sur des echelles differentes fausseraient completement les resultats. En entretien, un candidat qui oublie cette etape perd des points immediatement. Le dataset Iris contient naturellement 3 especes, donc k=3 devrait produire le meilleur silhouette score.

Metriques d'evaluation : precision, rappel, F1 et matrice de confusion

Savoir entrainer un modele ne suffit pas. L'evaluation correcte des performances est tout aussi determinante en entretien. Sur des donnees desequilibrees (cas frequent en production : detection de fraude, diagnostic medical, detection de spam), l'accuracy seule est trompeuse. Un modele qui predit toujours la classe majoritaire obtient 95% d'accuracy sur un dataset avec 5% de positifs, mais il est totalement inutile.

# evaluation_metrics.py
from sklearn.metrics import (
    precision_score, recall_score, f1_score,
    roc_auc_score, confusion_matrix
)
import numpy as np

# Simulated predictions on imbalanced data (5% positive class)
np.random.seed(42)
y_true = np.array([1]*50 + [0]*950)
y_pred = np.array([1]*40 + [0]*10 + [1]*30 + [0]*920)  # Some errors

print(f"Precision: {precision_score(y_true, y_pred):.3f}")  # 40/(40+30) = 0.571
print(f"Recall:    {recall_score(y_true, y_pred):.3f}")     # 40/(40+10) = 0.800
print(f"F1-Score:  {f1_score(y_true, y_pred):.3f}")         # Harmonic mean

cm = confusion_matrix(y_true, y_pred)
print(f"\nConfusion Matrix:\n{cm}")
# [[920, 30],   -> TN=920, FP=30
#  [10,  40]]   -> FN=10,  TP=40

La precision (0.571) indique que parmi toutes les predictions positives, seulement 57% sont correctes. Le rappel (0.800) indique que 80% des vrais positifs sont detectes. Le F1-score (moyenne harmonique) synthetise ces deux metriques en un seul chiffre. En entretien, la question typique est : "Votre modele de detection de fraude a 95% de precision mais 30% de rappel. Est-ce acceptable ?" La reponse depend du cout relatif des faux positifs et des faux negatifs dans le contexte metier.

La matrice de confusion decoupe les predictions en quatre categories : vrais positifs (TP), vrais negatifs (TN), faux positifs (FP) et faux negatifs (FN). Savoir lire cette matrice et en deduire les metriques est une competence de base attendue des le premier tour d'entretien. Le top 25 des questions d'entretien data science en 2026 inclut plusieurs questions sur ce theme.

Regularisation : Ridge, Lasso et ElasticNet

La regularisation empeche le surapprentissage en ajoutant une penalite aux coefficients du modele. Ridge (L2) penalise la somme des carres des coefficients, les rapprochant de zero sans jamais les annuler. Lasso (L1) penalise la somme des valeurs absolues, ce qui peut mettre certains coefficients exactement a zero et donc effectuer une selection de variables. ElasticNet combine les deux penalites avec un ratio controle par l1_ratio.

# regularization_comparison.py
from sklearn.linear_model import Ridge, Lasso, ElasticNet
from sklearn.preprocessing import StandardScaler
from sklearn.pipeline import make_pipeline
from sklearn.model_selection import cross_val_score
from sklearn.datasets import load_diabetes

X, y = load_diabetes(return_X_y=True)

models = {
    "Ridge (L2)":      make_pipeline(StandardScaler(), Ridge(alpha=1.0)),
    "Lasso (L1)":      make_pipeline(StandardScaler(), Lasso(alpha=0.1)),
    "ElasticNet (L1+L2)": make_pipeline(StandardScaler(), ElasticNet(alpha=0.1, l1_ratio=0.5)),
}

for name, model in models.items():
    scores = cross_val_score(model, X, y, cv=5, scoring='r2')
    print(f"{name:25s}  R2: {scores.mean():.4f} +/- {scores.std():.4f}")

L'utilisation de make_pipeline enchaine automatiquement le scaling et le modele, evitant toute fuite de donnees (data leakage) entre le jeu d'entrainement et le jeu de test. En entretien, la question "Quelle est la difference entre Ridge et Lasso ?" attend une reponse articulee autour de la selection de variables : Lasso produit des modeles parcimonieux (sparse), Ridge conserve toutes les variables avec des coefficients reduits. ElasticNet est le compromis quand les variables sont correlees entre elles.

La page data science sur SharpSkill regroupe tous les modules d'entrainement couvrant ces algorithmes et leurs variantes.

Conclusion

Les points cles a retenir pour un entretien technique en machine learning :

• Regression lineaire et logistique : maitriser les hypotheses sous-jacentes, la fonction de cout, et savoir quand chaque modele est adapte. La regression logistique est un classifieur, pas un regresseur.
• Methodes d'ensemble : distinguer bagging (variance) et boosting (biais), connaitre les compromis Random Forest vs Gradient Boosting, et savoir argumenter un choix de modele selon le contexte.
• Clustering K-Means : toujours normaliser avant le clustering, utiliser le silhouette score pour valider k, et connaitre les limites de K-Means (clusters non spheriques, sensibilite a l'initialisation).
• Metriques d'evaluation : ne jamais se fier a l'accuracy seule sur des donnees desequilibrees. Maitriser precision, rappel, F1, et la matrice de confusion. Savoir choisir la metrique selon le contexte metier.
• Regularisation : differencier L1 (selection de variables), L2 (retrecissement) et ElasticNet (hybride). Toujours normaliser avant de regulariser.
• Pipelines scikit-learn : utiliser make_pipeline pour eviter le data leakage et garantir la reproductibilite.