Centrale Méditerranée · École centrale de Marseille
Machine Learning : des théorèmes au modèle en service
Page compagnon de l'électif de 54 heures pour les élèves-ingénieurs de Centrale Méditerranée, nom d'usage de l'École centrale de Marseille. Trois blocs intensifs de deux jours, en octobre, décembre et janvier, avec un jalon à atteindre entre chaque bloc.
Par Sitraka Forler · Enseignant, Durham Business SchoolMis à jour le 23 août 2026 À propos du site
54 heures
3 blocs de 2 jours, 9 h par jour
Oct. · Déc. · Janv.
Deux jalons entre les blocs
26 séances
Une dérivation, puis du code qui la vérifie
55 % sans IA
Note individuelle obtenue en salle
Comment ce cours est construit
Cours de 54 heures pour les élèves-ingénieurs de Centrale Méditerranée, nom d'usage de l'École centrale de Marseille, en trois blocs intensifs de deux jours (octobre, décembre, janvier). Chaque séance part d'une dérivation (projection des moindres carrés, maximum de vraisemblance, biais-variance, convexité et SGD, dual SVM et noyaux, bornes de généralisation, arbres et information, boosting comme descente de gradient fonctionnelle, rétropropagation, prédiction conforme) et se termine par du code qui reproduit la dérivation, la vérifie contre scikit-learn, puis l'applique à un projet fil rouge : un score de défaut de crédit construit sur données ouvertes, calibré, seuillé par coût, comparé avec des intervalles, audité, surveillé sur un vrai jeu temporel, documenté et exposé derrière une API testée. L'IA générative est autorisée et déclarée pour le code de plomberie ; la note repose sur ce que vous savez dériver, expliquer et vérifier sans elle : 55 % de la note est individuelle et obtenue en salle sans IA, sur papier, à l'oral ou sur poste hors ligne, y compris sur vos propres chiffres et votre propre code. Aucun détecteur d'IA n'est utilisé ; la preuve vient de vous.
On dérive
Chaque séance part d'un résultat démontré au tableau : projection des moindres carrés, maximum de vraisemblance, convexité, dualité, bornes de généralisation, rétropropagation. La liste des dérivations exigibles est publiée à l'avance.
On vérifie
La dérivation est ensuite recodée en numpy et confrontée à scikit-learn sur de vraies données. Un résultat que vous ne savez pas reproduire par une commande ne compte pas.
On livre
Un projet fil rouge traverse les trois blocs : un score de défaut de crédit calibré, seuillé par coût, audité, surveillé, documenté et exposé derrière une API testée.
Avant le bloc d'octobre
Le pré-test et la mise à niveau tournent dans le navigateur, sans installation ni compte.
- 1Algèbre linéaire : produit scalaire, projection orthogonale, valeurs propres, SVD, rang, matrices définies positives, conditionnement.
- 2Calcul différentiel à plusieurs variables : gradient, hessienne, règle de la chaîne, jacobienne, développement de Taylor à l'ordre 2.
- 3Probabilités : espérance, variance, lois normale et de Bernoulli, maximum de vraisemblance, inégalité de Hoeffding (rappelée en S3).
- 4Python de base (fonctions, listes, numpy) et SQL de base (SELECT, GROUP BY, JOIN). Pré-test diagnostique de 30 minutes, auto-corrigé, dans le navigateur sur ecofinlearning.com (gradient, projection, vraisemblance de Bernoulli, une requête SQL), à faire avant le bloc 1 (date à confirmer) : le score sert à dimensionner les rappels, pas à noter.
- 5Mise à niveau gratuite dans le navigateur (Pyodide, sans installation) : parcours python-foundations, python-pandas, sql-basics et le deck /studio/ols-logistic sur ecofinlearning.com.
- 6Environnement livré par l'enseignant avant le bloc 1 : gabarit de dépôt avec requirements figé (lockfile), devcontainer testé (GitHub Codespaces ou image Docker) et procédure locale Python 3.12 + git ; tout ce qui n'a pas tourné dans le devcontainer avant octobre n'est pas exigé en séance. PyTorch pour le bloc 3 (secours : sklearn MLPClassifier).
Le programme, bloc par bloc
Chaque séance affiche ce que vous construisez. Dépliez pour voir la dérivation exigible, les données et le livrable. Les liens d'entraînement sont gratuits et s'exécutent dans votre navigateur.
Bloc 1 · octobre 2026 · 18 heures
Bloc 1 : les fondations, du linéaire au convexe
Géométrie des moindres carrés, vraisemblance, biais-variance et validation sans fuite, optimisation convexe, régularisation, décision sous coût, ingénierie reproductible. Le projet fil rouge démarre avec un audit SQL, une carte des fuites, une coupe figée et une baseline défendable. Dates à confirmer, hors vacances d'automne indicatives (du 17 octobre au 1er novembre 2026).
Jour 1 : moindres carrés, vraisemblance, généralisation, lancement du projet
S1. La géométrie des moindres carrés
2 hEn numpy pur : ols(X, y) par équations normales, puis par SVD, comparées à np.linalg.lstsq et sklearn LinearRegression sur California Housing (20 640 lignes). Vérifier numériquement Xᵀe ≈ 0, H² ≈ H, décomposition de la variance ; comparer les erreurs-types à statsmodels. Ajouter une colonne quasi colinéaire, mesurer κ(X) et l'explosion de Var(β̂). Utile en poste : lire un coefficient et son écart-type, détecter la colinéarité avant qu'un modèle de prix ne devienne instable. Cœur : les trois implémentations et les vérifications ; extension : White.
Les maths, les données, le livrable
Ce qu'on démontre
Modèle y = Xβ + ε, X ∈ R^{n×p}. Minimiser ||y − Xβ||² : gradient 2Xᵀ(Xβ − y) = 0, équations normales XᵀXβ̂ = Xᵀy, β̂ = (XᵀX)⁻¹Xᵀy si rang(X) = p. Lecture géométrique : ŷ = Hy, H = X(XᵀX)⁻¹Xᵀ projecteur orthogonal sur Im(X) (H² = H, Hᵀ = H), résidus e = (I − H)y ⟂ Im(X), donc Xᵀe = 0. Décomposition de la variance, sous condition que le modèle contienne une constante (1 ∈ Im(X), donc 1ᵀe = 0, ce qui annule le double produit) : ||y − ȳ||² = ||ŷ − ȳ||² + ||e||² et R² = 1 − ||e||²/||y − ȳ||² ∈ [0, 1] ; sans constante la décomposition est fausse et R² peut être négatif. Gauss-Markov : E[ε] = 0, Var(ε) = σ²I ⇒ β̂ meilleur estimateur linéaire sans biais, Var(β̂) = σ²(XᵀX)⁻¹, σ̂² = ||e||²/(n − p), erreurs-types et test t. Numérique : κ(X) = σ_max/σ_min, SVD X = UΣVᵀ, β̂ = VΣ⁻¹Uᵀy, pourquoi on n'inverse jamais XᵀX. Extension : erreurs-types robustes à l'hétéroscédasticité (White).
Données et outils
California Housing (scikit-learn) ; numpy, scikit-learn, statsmodels ; échauffement Pyodide sur ecofinlearning.com
Ce que vous rendez
Notebook ols_from_scratch.ipynb : trois implémentations concordantes à 1e-8, trois vérifications géométriques, erreurs-types concordantes avec statsmodels, un paragraphe sur la colinéarité observée.
S2. Maximum de vraisemblance : de la loi à la perte, binaire et multiclasse
2 hImplémenter la régression logistique deux fois (descente de gradient, Newton/IRLS), comparer à sklearn LogisticRegression(penalty=None) sur UCI Default of Credit Card Clients (30 000 clients, 23 variables, cible = défaut le mois suivant) ; tracer ℓ par itération ; écarts-types via I(β̂)⁻¹ comparés à statsmodels. Bonus multiclasse : softmax sur load_digits, matrice de confusion 10×10, F1 macro et micro. Utile en poste : c'est le modèle de score des banques et des assureurs, et les écarts-types sont ce qu'un régulateur demande.
Les maths, les données, le livrable
Ce qu'on démontre
Log-vraisemblance ℓ(θ) = Σ_i log p(y_i | x_i ; θ). Gaussien y_i ~ N(x_iᵀβ, σ²) : maximiser ℓ ⇔ minimiser Σ(y_i − x_iᵀβ)², donc OLS = MLE et σ̂²_MLE = ||e||²/n. Bernoulli p_i = σ(x_iᵀβ), σ(z) = 1/(1 + e^{−z}) : ℓ(β) = Σ[y_i log p_i + (1 − y_i) log(1 − p_i)], ∇ℓ = Xᵀ(y − p), ∇²ℓ = −XᵀWX, W = diag(p_i(1 − p_i)) : ℓ concave, strictement concave dès que rang(X) = p ; le maximum est alors atteint et unique si les données présentent un recouvrement, c'est-à-dire ne sont ni complètement ni quasi complètement séparables (Albert et Anderson, 1984) ; Newton = IRLS : β ← β + (XᵀWX)⁻¹Xᵀ(y − p) ; information de Fisher I(β) = XᵀWX, Var(β̂) ≈ I(β̂)⁻¹ ; log(p/(1 − p)) = xᵀβ, rapport de cotes e^{β_j}. Séparation complète ou quasi complète ⇒ β̂ diverge (motivation de S6). Multiclasse : softmax p_k = e^{z_k}/Σ_j e^{z_j}, z = Wx, entropie croisée L = −Σ_k y_k log p_k, ∂L/∂z = p − y (même forme qu'en binaire), un-contre-tous comme alternative ; métriques macro et micro (S7).
Données et outils
UCI Default of Credit Card Clients (archive.ics.uci.edu/dataset/350, CC BY 4.0) ; load_digits ; numpy, scikit-learn, statsmodels
Ce que vous rendez
logit_from_scratch.py + tableau des coefficients (GD, Newton, sklearn, statsmodels) concordants à 1e-4, courbes de convergence, matrice de confusion 10×10 du bonus.
S3. Biais-variance, validation sans fuite, taille d'échantillon
2 hCœur : sur le jeu crédit, montrer deux fuites chiffrées (standardisation avant la coupe versus Pipeline ; encodage par la cible naïf versus TargetEncoder hors pli) et l'écart optimiste ; sur UCI Bike Sharing (demande horaire 2011-2012), comparer KFold mélangé et TimeSeriesSplit avec gap : l'écart d'erreur mesure l'illusion. Extension : notebook fourni de simulation f(x) = sin(2πx) + bruit, polynômes de degré 1 à 15, courbe en U biais²/variance. Utile en poste : la fuite est la première cause des modèles qui « marchaient en dev ».
Les maths, les données, le livrable
Ce qu'on démontre
Pour y = f(x) + ε : E_{D,ε}[(y − f̂(x))²] = σ² + (E_D[f̂(x)] − f(x))² + Var_D(f̂(x)). Risque R(f̂) = E[L(y, f̂(x))], risque empirique R̂ ; validation croisée CV_k = (1/k)Σ_j R̂_j(f̂^{(−j)}), presque sans biais pour la procédure ; aucun estimateur sans biais de sa variance n'existe (Bengio et Grandvalet 2004), et un IC bootstrap sur les lignes de test ne capte que la variabilité d'échantillonnage du test, pas celle de l'entraînement : lire les intervalles avec cette réserve. Fuite : toute statistique T(D_test) qui entre dans f̂. Encodage par la cible enc(c) = (Σ_{i : x_i = c} y_i + m·ȳ)/(n_c + m) calculé sur tout l'échantillon contient y_i de la ligne encodée : fuite ; remède : encodage hors pli. Hoeffding : P(|R̂ − R| > ε) ≤ 2exp(−2nε²), donc ε = √(ln(2/δ)/(2n)) ; n = 1 000 lignes de test ⇒ ±4,3 points d'exactitude à 95 % : règle de dimensionnement du jeu de test. Séries temporelles : Cov(ε_t, ε_{t+1}) ≠ 0 rend le k-fold mélangé faux ; découpes croissantes avec écart (gap).
Données et outils
UCI Default ; UCI Bike Sharing (archive.ics.uci.edu/dataset/275, CC BY 4.0) ; scikit-learn Pipeline, ColumnTransformer, TargetEncoder, StratifiedKFold, TimeSeriesSplit
Ce que vous rendez
Notebook fuites.ipynb : deux fuites avec scores avant/après correction, tableau KFold contre TimeSeriesSplit avec écart, calcul de la marge Hoeffding pour la taille du jeu de test du projet.
S4. Lancement du projet : audit SQL, carte des fuites, coupe figée, baselines
2 hPar équipe de 3 : audit du CSV en SQL avec DuckDB (doublons, valeurs hors nomenclature dans EDUCATION et MARRIAGE, taux de défaut par groupe, montants impossibles) ; fiche de données (source, licence, définition exacte de la cible, codes PAY_0..PAY_6) ; carte des fuites par colonne : pour chaque variable, à quelle date elle est connue (BILL_AMT1 et PAY_0 = fin septembre 2005, cible = octobre) et si elle peut servir ; coupe train/validation/test stratifiée figée par graine et hachage SHA-256 du CSV ; deux baselines (constante, logistique régularisée par défaut). Constitution des équipes, déclaration du niveau d'IA prévu par livrable, première entrée de DECISIONS.md, dépôt de la première issue PREREG. Utile en poste : fiche de données, carte des fuites et coupe figée sont les premiers livrables de tout projet sérieux.
Les maths, les données, le livrable
Ce qu'on démontre
Taux de base p̂ = (1/n)Σy_i avec intervalle de Wilson : centre (p̂ + z²/2n)/(1 + z²/n), demi-largeur (z/(1 + z²/n))·√(p̂(1 − p̂)/n + z²/4n²). Entropie de la cible H(p̂) = −p̂ log p̂ − (1 − p̂) log(1 − p̂) : log-loss du modèle constant, et aucun modèle ne fait mieux que H(Y | X). Jointure point-in-time : ne joindre que les enregistrements de date t' ≤ t ; une variable fuit si elle est calculée avec une information postérieure à la date de prédiction. One-hot et rang (colonne de référence). Standardisation avec μ_train et σ_train seulement.
Données et outils
UCI Default ; DuckDB, pandas, scikit-learn ; gabarit de dépôt du cours (GitHub Classroom, à confirmer)
Ce que vous rendez
DATA_CARD.md + LEAKAGE_MAP.md (une ligne par colonne) + split figé (indices + hash) + baseline.py (AUC, log-loss, Brier sur validation) + première entrée de DECISIONS.md + déclaration des niveaux d'IA.
Jalon du jour : contrôle papier, oraux tirés au sort, critique d'une sortie d'IA imposée · 1 h
30 minutes de contrôle, puis 30 minutes : 10 étudiants tirés au sort (registre public, sans remise) passent 3 minutes chacun devant leur notebook du jour (« explique cette cellule, change ce paramètre, prédis l'effet, lance ») ; pendant ce temps, les autres critiquent sur papier, sans IA, une sortie d'IA imposée par l'enseignant (même texte pour tous : une explication fausse mais plausible d'une fuite) ; cette critique alimente l'annexe IA.
Jour 2 : optimisation convexe, régularisation, décision sous coût, dépôt reproductible
S5. Convexité, descente de gradient, SGD, Adam
2 hÉcrire un mini-optimiseur (GD, SGD mini-lots, Adam) pour la perte logistique en numpy, avec un objet Loss exposant f, ∇f et L. Sur le jeu crédit : tracer f(x_k) − f* (f* par Newton) en échelle log, avec et sans standardisation ; κ empirique par les valeurs propres de XᵀX/n ; reproduire l'échec de GD avec η > 2/L. Extension : momentum. Utile en poste : diagnostiquer un entraînement qui ne converge pas et choisir un pas sans tâtonner.
Les maths, les données, le livrable
Ce qu'on démontre
f convexe : f(λx + (1 − λ)y) ≤ λf(x) + (1 − λ)f(y), tout minimum local est global. L-lisse : ||∇f(x) − ∇f(y)|| ≤ L||x − y|| ; μ-fortement convexe : f(y) ≥ f(x) + ∇f(x)ᵀ(y − x) + (μ/2)||y − x||². Descente x_{k+1} = x_k − η∇f(x_k), η = 1/L : f(x_k) − f* ≤ L||x_0 − x*||²/(2k) (convexe) et ||x_k − x*||² ≤ (1 − μ/L)^k||x_0 − x*||² (fortement convexe), taux gouverné par κ = L/μ ; plus de garantie de décroissance si η > 2/L, et divergence effective dès qu'une direction de courbure L est excitée (cas quadratique). Perte logistique moyenne : L ≤ λ_max(XᵀX)/(4n), la standardisation réduit κ. SGD : x_{k+1} = x_k − η_k∇f_{i_k}(x_k), E[∇f_i] = ∇f, O(1/√k) dans le cas convexe avec η_k ∝ 1/√k, O(1/k) dans le cas fortement convexe avec η_k ∝ 1/k ; Robbins-Monro Ση_k = ∞, Ση_k² < ∞ ; mini-lots, variance σ²/B. Adam : moments m_k, v_k, pas m̂_k/(√v̂_k + ε) ; pas de garantie de convergence dans le cas convexe, mais efficace en pratique.
Données et outils
UCI Default ; numpy, matplotlib
Ce que vous rendez
optim_bench.py + figure des courbes de convergence (3 méthodes × 2 prétraitements) + 10 lignes reliant chaque courbe à la borne théorique.
S6. Régularisation : ridge, lasso, lecture bayésienne
2 hRidge par SVD et lasso par ISTA en numpy, vérifiés contre sklearn Ridge et Lasso (mêmes conventions). Sur le jeu crédit (logistique pénalisée L1 et L2) : chemin de régularisation, C par CV avec la règle du 1-SE, stabilité du support (fréquence de sélection sur 100 rééchantillonnages). Utile en poste : un score avec 8 variables stables se déploie et s'explique ; 60 variables instables, non.
Les maths, les données, le livrable
Ce qu'on démontre
Ridge : min ||y − Xβ||² + λ||β||², β̂_λ = (XᵀX + λI)⁻¹Xᵀy toujours définie ; en base SVD β̂_λ = Σ_j (σ_j/(σ_j² + λ))(u_jᵀy)v_j, rétrécissement des petites valeurs singulières ; df(λ) = Σ_j σ_j²/(σ_j² + λ). Lasso : min (1/2n)||y − Xβ||² + λ||β||₁ ; convention : colonnes centrées de norme √n (XᵀX/n = I) ⇒ β̂_j = S_λ(β̂_j^{OLS}) = signe(β̂_j)(|β̂_j| − λ)₊ (seuillage doux, zéros exacts ; avec la norme 1 ou sans le 1/2n, le seuil change de facteur : à dire explicitement) ; KKT : |x_jᵀ(y − Xβ̂)|/n ≤ λ avec égalité si β̂_j ≠ 0 ; ISTA β ← S_{ηλ}(β − η∇g(β)) ; λ_max = ||Xᵀy||_∞/n annule tout. Bayésien : ridge = MAP sous N(0, τ²I), λ = σ²/τ² ; lasso = MAP sous Laplace. Elastic net. Choix de λ par CV, règle du 1-SE, stabilité du support.
Données et outils
UCI Default ; numpy, scikit-learn (LogisticRegressionCV, lasso_path)
Ce que vous rendez
Figure chemin de régularisation + tableau de stabilité du support + C retenu justifié en 3 phrases dans DECISIONS.md.
S7. Métriques, calibration, pondération des classes et seuil sous coût
2 hSur la baseline puis le modèle L1 : diagramme de fiabilité, Brier décomposé, ROC et PR avec IC bootstrap (en rappelant ce que l'IC capte). Entraîner avec class_weight, vérifier le déplacement des probabilités, le corriger, puis recalibrer (isotonique). Scénario de coûts (bon client refusé = marge perdue, défaut accepté = perte attendue), t*, courbe C(t). Utile en poste : le seuil est la décision métier ; savoir le justifier par un coût est ce qu'on vous demandera en comité.
Les maths, les données, le livrable
Ce qu'on démontre
Matrice de confusion au seuil t ; ROC = {(FPR(t), TPR(t))}, AUC = P(s(X⁺) > s(X⁻)) = U de Mann-Whitney/(n⁺n⁻), invariante par transformation monotone ; précision-rappel et F_β quand p̂ ≪ 0,5 ; multiclasse : F1 macro (moyenne des classes) et micro (comptes agrégés). Calibration E[Y | s(X) = s] = s ; Brier (1/n)Σ(s_i − y_i)² = fiabilité − résolution + incertitude ; Platt et isotonique (PAV). Décision bayésienne : prédire 1 ssi p(x) > t* = c_FP/(c_FP + c_FN), valable seulement si p est calibrée ; sinon minimiser C(t) = c_FP·FP(t) + c_FN·FN(t). Pondération ou suréchantillonnage des positifs avec poids w : le modèle estime p_w = wp/(wp + 1 − p), donc p = p_w/(w − (w − 1)p_w) avant d'appliquer t* ; sans cette correction le seuil et la calibration se contredisent.
Données et outils
UCI Default ; scikit-learn (roc_curve, calibration_curve, CalibratedClassifierCV), matplotlib
Ce que vous rendez
Note d'une page « Seuil et coût » : hypothèses de coût, t*, coût attendu pour 10 000 clients, effet de la pondération et de la calibration ; figures ROC, PR, fiabilité, C(t).
S8. Ingénierie reproductible : branches, tests, CI, journal
2 hTransformer S4 à S7 en dépôt : src/, tests/ (pytest, 5 tests dont 1 contrat de schéma), Makefile avec make reproduce qui refait coupe, entraînement et metrics.json, lockfile, CI GitHub Actions comparant metrics.json à la référence à ±0,005. Flux collaboratif : branche par tâche, pull request, revue avec grille de 6 points, résolution d'un conflit provoqué. L'IA est encouragée pour la plomberie (niveau 4) ; DECISIONS.md consigne ce qu'elle a proposé et ce qui a été rejeté. Extension : suivi des runs avec MLflow local. Utile en poste : c'est le standard minimal d'une équipe data qui livre, et les juniors échouent plus souvent sur les branches que sur les maths.
Les maths, les données, le livrable
Ce qu'on démontre
Pas de théorème, une discipline. Un Pipeline sklearn est une composition de fonctions ajustées sur le pli d'entraînement : CV sans fuite par construction. Un test est une propriété vérifiable : AUC = 1 sur données séparables, invariance à la permutation des lignes, predict(pipeline chargé) = predict(pipeline entraîné) à 1e-12, contrat de schéma (types, bornes, taux de manquants). Déterminisme : graine unique, hachage des données, versions figées. Reproductibilité : résultat = F(données, code, graine, environnement).
Données et outils
git, GitHub (branches, PR, issues), GitHub Actions, pytest, make ; scikit-learn ; assistant IA autorisé (niveau 4)
Ce que vous rendez
Dépôt d'équipe avec CI verte, make reproduce, 5 tests, une PR relue et fusionnée par un coéquipier, DECISIONS.md avec au moins 5 entrées datées.
Jalon du jour : contrôle papier et oraux tirés au sort · 1 h
30 minutes de contrôle, 30 minutes : 10 nouveaux oraux de 3 minutes (registre) sur le dépôt d'équipe (« explique ce test, modifie cette fonction, prédis l'effet, lance ») ; les autres critiquent sur papier une seconde sortie d'IA imposée (une PR générée contenant une fuite). Annonce du jalon 1, de la liste publiée des dérivations exigibles et du calendrier de la revue croisée.
Jalon 1 : une baseline défendable
À confirmer : vers le 20 novembre 2026, une semaine avant le bloc de décembre, tag git jalon-1 poussé avant l'heure limite (horodatage serveur). Point d'étape obligatoire trois semaines après le bloc 1 : visio de 15 minutes par équipe (date à confirmer), condition : make reproduce tourne. Revue croisée asynchrone la semaine suivant le tag.
Ce que vous rendez
- Dépôt d'équipe avec CI verte, make reproduce, tests, lockfile, coupe figée et hachée ; README suivi avec succès par l'équipe auditrice sur le devcontainer.
- Notebooks OLS et logistique « from scratch » concordants avec scikit-learn (S1, S2), vérifications géométriques incluses.
- Note de 2 pages « Baseline et seuil » : fiche de données, carte des fuites, modèle logistique pénalisé retenu, pondération et calibration, t* et coût attendu, limites.
- DECISIONS.md : au moins 10 entrées datées, chacune avec l'alternative rejetée, la raison et un chiffre reproductible par une commande.
- Tableau d'ablation pré-enregistré : AUC et Brier quand on retire chaque groupe de variables (démographie, limite de crédit, historique PAY_*, montants BILL_*, paiements PAY_AMT*), prédiction chiffrée déposée en issue GitHub avant le calcul, écart commenté.
- Chasse aux erreurs : le notebook piégé de l'enseignant contient 3 défauts (fuite, métrique mal calculée, standardisation hors pipeline) ; les identifier, expliquer, corriger.
- Annexe IA : usages, prompts principaux, au moins deux propositions de l'IA jugées fausses avec la preuve (test, calcul, figure), plus la critique faite en salle de la sortie imposée.
- LIVRABLES_NOMINATIFS.md : chaque membre signe une fonction de src/, une ligne du tableau d'ablation et une entrée de DECISIONS.md ; une question d'oral obligatoire portera dessus.
- Revue croisée : deux issues étayées ouvertes sur le dépôt attribué (une sur le code, une sur la méthode), et réponses aux issues reçues avant le bloc 2.
Les preuves que vous avez réfléchi
- Pré-enregistrement horodaté côté serveur : chaque prédiction d'ablation est déposée en issue GitHub et le hachage SHA-256 de PREREG.md est déposé sur Moodle avant l'exécution ; un robot de l'enseignant clone les dépôts chaque semaine. Le git log seul n'est pas une preuve.
- Journal de décisions avec alternatives rejetées et chiffres reproductibles : une IA produit des choix, pas l'historique des hésitations ; une entrée tirée au sort est interrogée à chaque oral.
- Tableau d'ablation interprété : dire pourquoi retirer PAY_0 coûte plus d'AUC que retirer la démographie demande d'avoir regardé les données.
- Chasse aux erreurs sur un notebook que l'IA n'a pas vu : il faut lire du code et connaître la définition de la fuite.
- Annexe IA critique : l'erreur prouvée est interrogée à l'oral (« montrez-moi le test qui réfute cette proposition »), et la critique de la sortie imposée a été faite en salle sans IA.
- Livrable nominatif par membre relié à une question d'oral obligatoire : le git shortlog s'attribue à n'importe quel nom, une fonction que l'on doit expliquer devant l'enseignant, non.
Vérification en salle, sans IA
Début du bloc 2, 45 minutes sans IA ni documents, puis 15 minutes de retour collectif : (1) dériver la solution ridge et expliquer le rétrécissement en base SVD ; (2) calculer à la main le coût attendu d'une matrice de confusion donnée et t* ; (3) question personnalisée : une fonction de votre propre dépôt (tirée au sort la veille par script) est imprimée avec une modification proposée ; expliquer ce qu'elle fait et écrire l'effet prédit de la modification sur metrics.json ; (4) une question sur votre ligne d'ablation nominative. La version en direct (« modifiez, prédisez, lancez ») est faite dans les oraux du jour 3.
Bloc 2 · décembre 2026 · 18 heures
Bloc 2 : au-delà du linéaire, noyaux, arbres, ensembles, comparaison honnête, équité
Marge et dualité, astuce du noyau, ce que disent vraiment les bornes de généralisation, arbres et information, forêts et boosting comme descente de gradient fonctionnelle, sélection et comparaison avec intervalles, interprétabilité, équité et droit, non-supervisé. Le projet passe d'une baseline à un modèle champion documenté. Dates à confirmer, avant les vacances de fin d'année indicatives (du 19 décembre 2026 au 3 janvier 2027).
Jour 3 : noyaux, généralisation, arbres, forêts
Point d'entrée : contrôle sans IA du jalon 1 · 1 h
45 minutes de contrôle individuel sur papier, 15 minutes de retour collectif sur les erreurs fréquentes du jalon 1 (fuites résiduelles, seuils non justifiés, IC mal lus).
S9. SVM, dualité, KKT et astuce du noyau
2 hCœur : SVC linéaire sur 200 points 2D, vérifier les conditions KKT à partir de dual_coef_ et support_ (w reconstruit, complémentarité), tracer la marge pour 3 valeurs de C ; kernel ridge en 5 lignes numpy vérifié contre KernelRidge ; sur le jeu crédit, logistique sur RFF (D = 1 000) contre linéaire et contre SVC RBF sur 5 000 lignes (temps mesuré). Extension : résoudre le dual avec scipy.optimize sur 100 points ; balayer D. Utile en poste : savoir quand un noyau vaut son coût, comment le rendre scalable, et pourquoi un SVM ne renvoie pas de probabilité.
Les maths, les données, le livrable
Ce qu'on démontre
Marge dure : min (1/2)||w||² s.c. y_i(wᵀx_i + b) ≥ 1, marge 2/||w|| ; marge souple + CΣξ_i. Lagrangien, KKT : w = Σα_i y_i x_i, Σα_i y_i = 0, 0 ≤ α_i ≤ C, complémentarité α_i[y_i(wᵀx_i + b) − 1 + ξ_i] = 0 ⇒ seuls les supports ont α_i > 0. Dual : max Σα_i − (1/2)Σα_iα_j y_i y_j x_iᵀx_j, dépend des données par les produits scalaires seulement. Équivalence : SVM = min (1/2)||w||² + CΣmax(0, 1 − y_i f(x_i)), hinge majorant convexe de la perte 0-1, comparée à log(1 + e^{−yf}). Noyau k(x, x') = ⟨φ(x), φ(x')⟩, Gram K ≽ 0 ; théorème de représentation : le minimiseur de ΣL(y_i, f(x_i)) + λ||f||²_H s'écrit f = Σα_i k(x_i, ·) ; kernel ridge α = (K + λI)⁻¹y, O(n³). RBF exp(−γ||x − x'||²) ; random Fourier features z(x) = √(2/D) cos(Wx + b), W ~ N(0, 2γI), b ~ U[0, 2π], E[z(x)ᵀz(x')] = k(x, x') (Rahimi et Recht 2007).
Données et outils
Synthétique 2D + UCI Default ; numpy, scikit-learn (SVC, KernelRidge, RBFSampler), scipy en extension
Ce que vous rendez
Notebook svm_kernels.ipynb : vérification KKT, figure marge et supports (3 C), kernel ridge validé, tableau temps × AUC (linéaire, RBF exact, RFF).
S10. Généralisation : Hoeffding, VC, Rademacher, et l'expérience des étiquettes aléatoires
1 hScript fourni : sur le jeu crédit, remplacer y par des étiquettes aléatoires, entraîner logistique, SVC RBF et arbre profond, mesurer erreurs train et test (20 minutes). Calculer la borne VC pour la logistique et constater son inutilité pratique mais sa bonne pente. Pré-enregistrer pour le jalon 2 la courbe de l'écart R̂_test − R̂_train en fonction de n (500 à 24 000). Utile en poste : justifier une taille d'échantillon et détecter un modèle qui mémorise.
Les maths, les données, le livrable
Ce qu'on démontre
Classe finie, borne uniforme : avec probabilité ≥ 1 − δ, ∀h ∈ H, R(h) ≤ R̂(h) + √((log|H| + log(2/δ))/(2n)). Dimension VC d (hyperplans de R^p : p + 1) et R(h) ≤ R̂(h) + √((8/n)(d log(2en/d) + log(4/δ))). Rademacher R_n(H) = E[sup_h (1/n)Σσ_i h(x_i)], R(h) ≤ R̂(h) + 2R_n(H) + √(log(1/δ)/(2n)) ; pour ||w|| ≤ B et ||x|| ≤ R, R_n ≤ BR/√n, indépendant de la dimension : argument théorique des SVM et de la régularisation. Lecture : constantes lâches, dépendances en n et en complexité justes ; l'expérience des étiquettes aléatoires (Zhang et al. 2017) montre la limite des bornes uniformes pour les modèles sur-paramétrés.
Données et outils
UCI Default ; scikit-learn, matplotlib ; script fourni
Ce que vous rendez
Tableau étiquettes aléatoires (3 modèles) + calcul de la borne VC + issue PREREG pour la courbe écart de généralisation.
S11. Arbres de décision et théorie de l'information
2 hImplémenter la meilleure coupure (entropie et Gini) et un arbre récursif limité en profondeur sur 3 variables du jeu crédit ; vérifier que la racine coïncide avec DecisionTreeClassifier ; gains d'information à la racine confrontés à l'intuition métier (PAY_0 domine) ; élaguer par cost_complexity_pruning_path avec CV, AUC en fonction de α. Utile en poste : un arbre élagué de profondeur 3 est souvent le modèle qu'un métier accepte de lire.
Les maths, les données, le livrable
Ce qu'on démontre
Entropie H(Y) = −Σ_k p_k log₂ p_k, entropie conditionnelle H(Y | A), gain = I(Y ; A) = H(Y) − H(Y | A) ≥ 0. Gini G = 1 − Σp_k², obtenu en remplaçant ln p par p − 1 dans l'entropie en nats ; avec H en log₂ il reste le facteur 1/ln 2 ≈ 1,44. CART : choix glouton du couple (variable, seuil) maximisant I(parent) − [N_g/N·I(g) + N_d/N·I(d)] ; régression : réduction de variance ; coût O(p·n log n) pour le tri initial des p colonnes, puis O(p·n) par niveau si les ordres triés sont conservés, contre O(p·n log n) par niveau si l'on retrie à chaque nœud. Élagage coût-complexité R_α(T) = R(T) + α|feuilles(T)|, sous-arbres emboîtés, α par CV. Biais faible, variance élevée (une ligne changée peut changer la racine) : motivation des ensembles.
Données et outils
UCI Default ; numpy, scikit-learn (DecisionTreeClassifier, export_text)
Ce que vous rendez
cart_from_scratch.py + tableau des gains à la racine + arbre élagué exporté en texte avec α retenu.
S12. Bagging et forêts aléatoires : réduire la variance
2 hSur le jeu crédit : RandomForestClassifier, OOB contre CV 5 plis (doivent concorder) ; AUC en fonction de B et de m ; MDI contre permutation avec une variable aléatoire continue injectée (elle sort en tête à la MDI, pas à la permutation) ; PD et ICE de PAY_0 et LIMIT_BAL. Utile en poste : l'importance par permutation et la PD sont ce qu'on met dans un rapport de validation.
Les maths, les données, le livrable
Ce qu'on démontre
Moyenne de B estimateurs de variance σ² et corrélation ρ : Var = ρσ² + (1 − ρ)σ²/B → ρσ². Le bootstrap baisse la variance sans toucher au biais ; m ≈ √p variables par nœud baisse ρ au prix d'un peu de biais. Chaque arbre ignore environ e⁻¹ ≈ 36,8 % des lignes ⇒ erreur out-of-bag, estimateur gratuit proche de la CV. Importance MDI biaisée vers les variables continues ou à nombreuses modalités et calculée sur le train ; importance par permutation R̂(f̂ ; X_j permutée) − R̂(f̂) sur validation, piège des variables corrélées. Dépendance partielle PD_j(x_j) = E_{X_{−j}}[f̂(x_j, X_{−j})], courbes ICE.
Données et outils
UCI Default ; scikit-learn (RandomForestClassifier, permutation_importance, PartialDependenceDisplay)
Ce que vous rendez
Figure AUC en fonction de B et m ; tableau MDI contre permutation avec la variable piège ; deux figures PD/ICE ; entrée DECISIONS.md.
Jalon du jour : contrôle papier et oraux tirés au sort · 1 h
30 minutes de contrôle, 30 minutes : 10 oraux de 3 minutes (registre) en version « modifiez cette fonction de votre dépôt, prédisez, lancez » ; les autres traitent sur papier une sortie d'IA imposée (un rapport d'importance de variables généré, à critiquer).
Jour 4 : boosting, comparaison honnête, interprétabilité, équité et droit, non-supervisé
S13. Boosting : descente de gradient dans l'espace des fonctions
2 hGradient boosting logistique en 40 lignes avec DecisionTreeRegressor, vérifié contre GradientBoostingClassifier ; reproduire le gain d'une coupe à la main sur 10 lignes ; HistGradientBoostingClassifier avec early_stopping, AUC validation en fonction de M pour 3 ν ; comparer forêt et logistique en AUC, Brier et temps. Utile en poste : le boosting sur histogrammes est le modèle par défaut du tabulaire ; savoir l'arrêter à temps évite le sur-apprentissage classique.
Les maths, les données, le livrable
Ce qu'on démontre
AdaBoost : w_i ← w_i exp(−α_m y_i h_m(x_i)), α_m = (1/2)log((1 − err_m)/err_m), descente par coordonnées sur Σexp(−y_i F(x_i)). Gradient boosting (Friedman 2001) : F_m = F_{m−1} + νh_m, h_m ajusté sur r_i = −∂L(y_i, F)/∂F en F_{m−1} ; logistique r_i = y_i − σ(F_{m−1}(x_i)) ; carré r_i = y_i − F_{m−1}(x_i). Newton (XGBoost, LightGBM) : g_i = ∂L, h_i = ∂²L, feuille w* = −Σg_i/(Σh_i + λ), gain = (1/2)[G_L²/(H_L + λ) + G_R²/(H_R + λ) − (G_L + G_R)²/(H_L + H_R + λ)] − γ ; pour la log-perte g_i = p_i − y_i, h_i = p_i(1 − p_i). ν et M se compensent, arrêt précoce, histogrammes O(n·bins). Le boosting réduit le biais, la forêt réduit la variance.
Données et outils
UCI Default ; scikit-learn (HistGradientBoostingClassifier) ; LightGBM en option
Ce que vous rendez
gb_from_scratch.py concordant avec sklearn ; calcul de gain sur 10 lignes ; figure AUC en fonction de M (3 ν) ; tableau logistique / forêt / boosting.
S14. Sélection et comparaison honnêtes : CV imbriquée, tests corrigés, pires erreurs
2 hCV imbriquée 5×3 pour logistique L1, forêt, boosting avec RandomizedSearchCV ; 3 graines × 5 plis ; AUC et Brier avec IC ; test apparié corrigé entre les deux meilleurs ; règle de décision du champion écrite en issue PREREG avant les résultats. Sortir les 20 pires erreurs du test : chaque membre en prend une nominativement (diagnostic écrit, tentative de correction chiffrée, même négative). Extension : journaliser les runs avec MLflow local. Utile en poste : c'est la section « comparaison de modèles » d'un rapport de validation, avec des intervalles au lieu de trois décimales.
Les maths, les données, le livrable
Ce qu'on démontre
Choisir les hyperparamètres sur le pli d'évaluation biaise l'estimation de la performance vers le haut (espérance du maximum de K variables bruitées) : CV imbriquée. Comparer deux modèles sur k plis : t apparié biaisé car les plis se recouvrent, correction de Nadeau-Bengio Var_corr = (1/k + n_test/n_train)·s² ; Bonferroni α/m ; règle du 1-SE. Erreur-type sur n graines σ/√n : avec σ ≈ 0,01 sur l'AUC, 5 graines donnent ±0,012 (t_{4 ; 0,975} = 2,78, σ estimé) ; ±0,009 seulement si σ est connu. Recherche aléatoire : 60 tirages touchent les 5 % meilleures configurations avec probabilité 1 − 0,95^60 ≈ 0,95 (Bergstra et Bengio 2012). Erreur conditionnelle par segment E[L | segment] pour localiser où le modèle échoue.
Données et outils
UCI Default ; scikit-learn (cross_validate, RandomizedSearchCV), scipy.stats ; MLflow en extension
Ce que vous rendez
Tableau final 3 modèles × (AUC, Brier, IC 95 %, temps, graines) + test corrigé + champion selon la règle pré-enregistrée + WORST20.md nominatif.
S15. Interprétabilité : valeurs de Shapley et SHAP
1,5 hSHAP sur le champion (TreeExplainer) : importance globale, dépendance de PAY_0, explications locales de 3 clients dont un refusé à tort, rédigées en français métier ; vérifier numériquement l'axiome d'efficacité sur 5 clients. Secours si shap n'est pas installé : permutation et PD. Utile en poste : c'est ce que demandent la conformité et le service client.
Les maths, les données, le livrable
Ce qu'on démontre
φ_j = Σ_{S ⊆ N∖{j}} |S|!(p − |S| − 1)!/p! · [v(S ∪ {j}) − v(S)], v(S) = E[f(x) | x_S] ; unique attribution vérifiant efficacité (Σφ_j = f(x) − E[f]), symétrie, nullité, additivité ; coût exponentiel en général, TreeSHAP polynomial pour les arbres ; lectures conditionnelle et interventionnelle de v(S) divergent quand les variables sont corrélées. Association apprise, pas causalité.
Données et outils
UCI Default ; shap (dans le devcontainer ; secours scikit-learn)
Ce que vous rendez
Section « Explicabilité » de la model card : vue globale, 3 explications locales, vérification d'efficacité, paragraphe sur les limites (corrélations).
S16. Équité, droit et AI Act : retirer l'attribut, mesurer les proxies, auditer par groupe
1,5 hRetirer SEX des entrées du champion ; mesurer si les proxies le reconstruisent (classifieur X → SEX, AUC) ; auditer par SEX et par tranche d'AGE (taux d'acceptation, TPR/FPR, calibration par groupe, IC, verdict concluant ou non concluant par puissance) ; documenter le compromis retenu. Rédiger la model card v1 (Mitchell et al. 2019 : usage prévu, hors périmètre, données, métriques désagrégées, limites). Utile en poste : model card et audit par groupe sont demandés par la conformité avant tout déploiement.
Les maths, les données, le livrable
Ce qu'on démontre
Parité démographique P(Ŷ = 1 | A = a) constante ; égalité des chances P(Ŷ = 1 | Y = 1, A = a) constante ; calibration par groupe E[Y | s, A = a] = s. Impossibilité (Kleinberg, Mullainathan et Raghavan 2016 ; Chouldechova 2017) : taux de base différents ⇒ calibration et égalité des taux d'erreur incompatibles sauf classifieur parfait. Proxy : X corrélée à A transmet A même si A est retirée ; test : AUC d'un classifieur X → A. Puissance : taille minimale d'un sous-groupe pour détecter un écart δ de taux, n ≈ 2(z_{α/2} + z_β)²p(1 − p)/δ² ; un groupe trop petit se déclare « non concluant », pas « équitable ». Droit : la directive 2004/113/CE interdit la discrimination fondée sur le sexe dans l'accès aux biens et services, dont les services financiers (arrêt Test-Achats C-236/09 pour les primes d'assurance) ; le sexe ne peut donc pas être une variable de décision. AI Act : règlement (UE) 2024/1689, en vigueur depuis le 1er août 2024, application générale depuis le 2 août 2026 ; l'évaluation de la solvabilité des personnes physiques figure à l'annexe III (haut risque), dont les obligations s'appliquent à partir du 2 décembre 2027 après le règlement (UE) 2026/1744 (omnibus numérique sur l'IA, en vigueur le 27 juillet 2026) ; à vérifier sur le texte consolidé le jour du cours.
Données et outils
UCI Default ; pandas, scikit-learn ; gabarit de model card du cours
Ce que vous rendez
MODEL_CARD.md v1 + tableau d'équité par groupe avec IC et verdict de puissance + résultat du test de proxy + paragraphe sur le compromis.
S17. Non-supervisé : ACP, k-means, mélanges gaussiens
1 hACP sur BILL_AMT* et PAY_AMT* : scree plot, lecture des deux premiers axes (niveau d'encours, tendance) ; k-means et GaussianMixture sur les scores, k par silhouette et BIC ; taux de défaut par segment ; ajouter le segment au champion et mesurer si l'AUC bouge (probablement peu : le dire). EM 1D en numpy vérifié contre GaussianMixture : livrable du jalon 2. Utile en poste : la segmentation sert au marketing et au risque même quand elle n'améliore pas le score.
Les maths, les données, le livrable
Ce qu'on démontre
ACP : X centrée, S = XᵀX/n, Sv_j = λ_j v_j, variance expliquée λ_j/Σλ ; SVD X = UΣVᵀ, λ_j = σ_j²/n ; Eckart-Young : X_k = U_kΣ_kV_kᵀ meilleure approximation de rang k en norme de Frobenius, erreur ||X − X_k||²_F = Σ_{j>k}σ_j². k-means : min Σ_kΣ_{i∈C_k}||x_i − μ_k||², Lloyd = descente par coordonnées, décroissance monotone, minimum local, k-means++, silhouette. GMM p(x) = Σπ_k N(x ; μ_k, Σ_k), EM : E-step r_{ik} = π_k N(x_i ; μ_k, Σ_k)/Σ_jπ_j N(x_i ; μ_j, Σ_j), M-step π_k, μ_k, Σ_k pondérés par r_{ik}, log-vraisemblance croissante (Jensen) ; k-means = GMM avec Σ_k = σ²I, σ → 0.
Données et outils
UCI Default ; numpy, scikit-learn (PCA, KMeans, GaussianMixture)
Ce que vous rendez
Figure ACP + tableau des segments (taille, taux de défaut, profil) + effet du segment sur le champion ; issue PREREG pour em_1d.py.
Jalon du jour : contrôle papier et oraux tirés au sort · 1 h
30 minutes de contrôle, 30 minutes : 10 oraux de 3 minutes (registre : tout étudiant non encore passé est prioritaire) sur gb_from_scratch.py et le tableau de comparaison ; les autres critiquent une sortie d'IA imposée (une model card générée, à corriger). Annonce du jalon 2.
Jalon 2 : un modèle champion documenté
À confirmer : début janvier 2027, une semaine avant le bloc de janvier, après les vacances de fin d'année indicatives, tag git jalon-2 avant l'heure limite. Point d'étape en visio de 15 minutes par équipe dans la semaine qui suit le bloc 2 et au plus tard le 18 décembre 2026, avant les vacances de fin d'année (date à confirmer). Revue croisée asynchrone la semaine suivant le tag.
Ce que vous rendez
- Dépôt : make compare reproductible avec tableau AUC/Brier/IC 95 % pour logistique, forêt, boosting et un modèle à noyau ou RFF, 3 graines × 5 plis, test corrigé.
- Champion retenu selon la règle pré-enregistrée en issue ; si la règle a changé après coup, le dire et expliquer.
- MODEL_CARD.md v2 : usage, données, coupe, métriques avec IC, seuil et coûts, calibration, audit d'équité (sans SEX en entrée, test de proxy, verdicts de puissance), limites, usages interdits.
- Ablation étendue pré-enregistrée : arrêt précoce, ν, m de la forêt, retrait des proxies d'AGE ; courbe écart de généralisation en fonction de n (S10).
- Trois implémentations « from scratch » validées contre scikit-learn : gradient boosting logistique, kernel ridge, EM 1D.
- Résultat surprenant : le résultat que l'équipe n'attendait pas, une explication testable, le test et son verdict.
- WORST20.md complété : une erreur par membre, diagnostic, correction tentée, effet chiffré.
- DECISIONS.md à jour (au moins 20 entrées cumulées), annexe IA avec deux nouvelles erreurs prouvées, LIVRABLES_NOMINATIFS.md mis à jour.
- Revue croisée : deux issues ouvertes sur le dépôt attribué après make compare sur le devcontainer ; réponses aux issues reçues avant le bloc 3.
Les preuves que vous avez réfléchi
- Pré-enregistrement horodaté serveur (issues + hachage Moodle) pour chaque expérience : prédiction chiffrée, résultat, écart commenté ; un écart nul partout est suspect et sera discuté à l'oral.
- Résultat surprenant testé : désigner ce qu'on n'attendait pas et le mettre à l'épreuve ne se délègue pas.
- Ablation interprétée ligne par ligne : relier chaque perte d'AUC à un mécanisme du cours (variance, biais, proxy, calibration).
- Erreur nominative du top 20 : chaque membre défend son diagnostic à l'oral.
- Annexe IA avec preuve : pour chaque erreur d'IA signalée, le test, le calcul ou la figure qui l'a réfutée, interrogé à l'oral.
- Livrables nominatifs recoupés avec le git shortlog et les grilles d'oral ; un membre sans fonction expliquée devant l'enseignant est reçu individuellement.
Vérification en salle, sans IA
Début du bloc 3, 60 minutes sans IA ni documents : (1) 30 minutes sur papier : écrire le dual du SVM et dire ce que signifie α_i = 0 ; expliquer le biais de la MDI et l'alternative ; question personnalisée « votre AUC champion est X avec IC [a, b], votre baseline est Y : la différence est-elle établie ? justifiez avec le test de S14 » (valeurs imprimées depuis le dépôt) ; (2) 30 minutes de chasse à l'erreur individuelle : un script de l'enseignant a injecté l'une de trois variantes de bug (fuite dans le prétraitement, seuil inversé, schéma trop permissif) dans une fonction du dépôt de l'équipe ; le diff est imprimé ; chaque étudiant localise le bug, l'explique et prédit son effet sur metrics.json.
Bloc 3 · janvier 2027 · 18 heures
Bloc 3 : réseaux de neurones, dérive, incertitude garantie, valeur, mise en service, examen et soutenances
Rétropropagation comme règle de la chaîne, entraînement pratique des réseaux avec ablations multi-graines, dérive et validation temporelle sur un vrai jeu, prédiction conforme et option de rejet, de la métrique à l'euro, analyse d'écart AI Act, modèle exposé derrière une API testée, examen individuel hors ligne, soutenances avec démonstration en direct. Dates à confirmer.
Jour 5 : réseaux de neurones, dérive, prédiction conforme
Point d'entrée : contrôle sans IA du jalon 2 et chasse à l'erreur sur son propre dépôt · 1 h
30 minutes de contrôle papier puis 30 minutes de chasse à l'erreur individuelle sur diff imprimé (trois variantes de bug injectées par script).
S18. Perceptron multicouche et rétropropagation
2 hMLP numpy (2 couches cachées, ReLU, sortie sigmoïde) avec forward, backward, mini-batch SGD ; gradient check ; entraînement sur le jeu crédit standardisé ; comparer log-loss et AUC à la logistique ; casser l'initialisation (zéros, variance 10) et observer. Utile en poste : déboguer un réseau qui n'apprend pas passe par le gradient check et l'initialisation, pas par un autre framework.
Les maths, les données, le livrable
Ce qu'on démontre
Réseau f = f_L ∘ ... ∘ f_1, z^{(l)} = W^{(l)}a^{(l−1)} + b^{(l)}, a^{(l)} = g(z^{(l)}). Règle de la chaîne : δ^{(l)} = (W^{(l+1)ᵀ}δ^{(l+1)}) ⊙ g'(z^{(l)}), ∂L/∂W^{(l)} = δ^{(l)}a^{(l−1)ᵀ}, ∂L/∂b^{(l)} = δ^{(l)} ; passe arrière au coût d'une passe avant (différentiation automatique en mode inverse). Softmax + entropie croisée : ∂L/∂z = p − y. Vérification par différences finies centrées (L(θ + εe_j) − L(θ − εe_j))/(2ε), ε = 1e-5, erreur relative < 1e-6 en float64. Initialisation He Var(W) = 2/n_in (ReLU), Xavier 2/(n_in + n_out) ; sinon gradients qui s'évanouissent ou explosent. Approximation universelle (Cybenko 1989, Hornik 1991) : énoncé, et pourquoi il ne dit rien sur l'apprentissage.
Données et outils
UCI Default ; numpy
Ce que vous rendez
mlp_numpy.py avec gradient check < 1e-6 (sortie jointe), courbes d'apprentissage, tableau de 3 initialisations.
S19. Entraîner en pratique : PyTorch, régularisation, ablations multi-graines
2 hMLP en PyTorch (nn.Module, DataLoader, Adam, early stopping), batch norm, dropout, plongements pour EDUCATION et MARRIAGE ; ablation à quatre lignes (sans BN, sans dropout, sans plongements, sans arrêt précoce), 3 graines chacune, AUC moyenne ± écart-type, pré-enregistrée ; comparer au champion boosting sur la même coupe. Secours : sklearn MLPClassifier. Utile en poste : l'ablation à graines multiples distingue un résultat d'un coup de chance.
Les maths, les données, le livrable
Ce qu'on démontre
Perte non convexe : pas de garantie globale. Batch norm ẑ = (z − μ_B)/√(σ²_B + ε), puis γẑ + β, statistiques glissantes à l'inférence. Dropout : unité gardée avec probabilité q, activations multipliées par q à l'inférence ; moyenne de 2^n sous-réseaux, pénalité L2 adaptative dans le cas linéaire. Arrêt précoce ≈ ridge pour un problème quadratique (t ≈ 1/(ηλ), η le pas de descente). Plongements E ∈ R^{K×d} pour les catégorielles. Résultat empirique à vérifier : sur des tables de taille moyenne, le boosting reste au niveau ou au-dessus des MLP (Grinsztajn, Oyallon et Varoquaux 2022).
Données et outils
UCI Default ; PyTorch (devcontainer ; secours MLPClassifier)
Ce que vous rendez
Tableau d'ablation (4 variantes × 3 graines) + décision motivée dans DECISIONS.md : le réseau remplace-t-il le champion ?
S20. Temps, dérive et politique de réentraînement sur un vrai jeu temporel
1,5 hSur UCI Bike Sharing : modèle de demande entraîné sur 2011, surveillé mois par mois sur 2012 ; PSI par variable, KS, validation adversariale, courbe de l'erreur réelle quand les étiquettes arrivent ; simulation statique contre réentraînement mensuel, trimestriel et sur alerte PSI, coût et erreur ; seuils d'alerte propres au jeu, pas recopiés. Transposer au crédit : étiquettes retardées à 12 mois, fenêtres décalées. Utile en poste : c'est la partie du projet qui survit à la mise en production.
Les maths, les données, le livrable
Ce qu'on démontre
Stationnarité faible, autocorrélation ρ(h). Walk-forward : entraîner sur [1, t], tester sur [t + 1, t + h], glisser ; jamais de mélange quand l'ordre compte. Dérive de covariables P_t(X) ≠ P_0(X) : PSI = Σ_b(q_b − p_b)ln(q_b/p_b) (somme des deux KL, seuils usuels 0,10 et 0,25 à justifier par simulation), Kolmogorov-Smirnov D = sup|F_0 − F_t|, validation adversariale (AUC d'un classifieur « période 0 contre t », 0,5 = pas de dérive détectable), repondération w(x) = p_t(x)/p_0(x). Dérive de concept P_t(Y | X) ≠ P_0(Y | X) : visible seulement avec étiquettes, souvent retardées. CUSUM S_t = max(0, S_{t−1} + (x_t − μ_0 − k)), alerte si S_t > h. Réentraîner quand Σ_t(R_t − R_0)·volume_t > C_retrain.
Données et outils
UCI Bike Sharing ; pandas, scipy.stats, scikit-learn
Ce que vous rendez
MONITORING.md : PSI/KS par variable, AUC adversariale, erreur walk-forward contre mélangée, courbe des politiques de réentraînement, seuils d'alerte justifiés par simulation.
S21. Incertitude garantie : prédiction conforme et option de rejet
1,5 hImplémenter le split conformal en numpy en moins de 30 lignes ; sur Bike Sharing, intervalles avec calibration glissante, couverture mesurée mois par mois ; sur le crédit, ensembles conformes et politique d'abstention chiffrée (fraction de dossiers envoyés en revue humaine, gain attendu) ; couverture par segment. Comparer à MAPIE si installé. Utile en poste : une prédiction avec garantie rend le contrôle humain concret et inspire confiance au client.
Les maths, les données, le livrable
Ce qu'on démontre
Prédiction conforme par partition : scores s_i = |y_i − f̂(x_i)| sur un jeu de calibration de taille n, q̂ = le ⌈(n + 1)(1 − α)⌉-ième plus petit score, soit le quantile empirique de niveau ⌈(n + 1)(1 − α)⌉/n, défini seulement si α ≥ 1/(n + 1), sinon q̂ = +∞, C(x) = [f̂(x) − q̂, f̂(x) + q̂]. Garantie marginale sous échangeabilité, sans hypothèse sur f̂ : P(Y ∈ C(X)) ≥ 1 − α (preuve en trois lignes par le rang du score test parmi n + 1 scores échangeables). Classification : s_i = 1 − p̂(y_i | x_i), C(x) = {y : 1 − p̂(y | x) ≤ q̂}. Couverture marginale ≠ conditionnelle : vérifier par segment. Séries temporelles violent l'échangeabilité : calibration glissante. Option de rejet : abstenir si max_y p̂(y | x) < τ, τ minimisant coût des erreurs + coût de l'examen humain × taux de rejet.
Données et outils
UCI Bike Sharing, UCI Default ; numpy ; MAPIE en option
Ce que vous rendez
conformal.py (< 30 lignes) + tableau couverture empirique contre 1 − α par segment + politique d'abstention (taux, coût, gain).
Jalon du jour : contrôle papier et derniers oraux du registre · 1 h
30 minutes de contrôle, 30 minutes : 10 oraux de 3 minutes (registre : 50 passages cumulés pour au plus 40 étudiants, chacun est passé au moins une fois) ; les autres rédigent la réflexion individuelle de 300 mots, sans IA : la décision la plus difficile du projet et pourquoi.
Jour 6 : valeur, conformité, mise en service, examen individuel, soutenances
S22. De la métrique à l'euro : courbe de profit, mémo client, test A/B
1 hCourbe de profit du champion avec les coûts de la fiche de cadrage, comparaison à la baseline et à « sans modèle » ; mémo d'une page pour le décideur (ce que le modèle rapporte par an, sous quelles hypothèses, quel test A/B pour le vérifier : taille, durée) ; paragraphe sur le biais des étiquettes sélectives. Utile en poste : ce mémo est ce que lit le décideur ; le rapport est ce que lit son équipe technique.
Les maths, les données, le livrable
Ce qu'on démontre
Valeur d'une politique de seuil V(t) = Σ_i[gain_i·1{s_i ≥ t, y_i = 1} − c_FP·1{s_i ≥ t, y_i = 0} − c_FN·1{s_i < t, y_i = 1}], comparée à « sans modèle » et à la politique actuelle. Dimensionner un test A/B : moyennes n ≈ 2(z_{1−α/2} + z_{1−β})²σ²/δ² par bras ; proportions n = (z_{1−α/2} + z_{1−β})²·2p̄(1 − p̄)/δ² (p̄ = 0,2, δ = 0,02, α = 5 %, puissance 80 % ⇒ environ 6 300 par bras) ; le coup d'œil répété gonfle les faux positifs. Prédiction ≠ intervention : en scoring, Y n'est observé que sur les dossiers acceptés. Si l'acceptation ne dépend que de X (seuil déterministe sur le score), la loi de Y sachant X est inchangée, E[Y | X, accepté] = E[Y | X]. Le biais apparaît dans deux cas. Un, l'acceptation dépend d'informations prédictives de Y absentes de X (dérogations, jugement de l'analyste) : alors E[Y | X, accepté] ≠ E[Y | X], ce qui motive l'inférence des refusés. Deux, il n'y a aucun support là où la probabilité d'acceptation est nulle : toute prédiction y est une extrapolation, ce qui motive l'exploration d'une fraction ε des refus.
Données et outils
UCI Default ; numpy, pandas, matplotlib, statsmodels (puissance)
Ce que vous rendez
Courbe de profit + MEMO_CLIENT.md d'une page + dimensionnement A/B.
S23. AI Act pour l'ingénieur : analyse d'écart annexe IV, model card finale, datasheet
1 hRèglement (UE) 2024/1689 (en vigueur le 1er août 2024, application générale le 2 août 2026 ; annexe III, dont le scoring de crédit des personnes physiques, applicable à partir du 2 décembre 2027 après le règlement (UE) 2026/1744, omnibus numérique sur l'IA en vigueur le 27 juillet 2026 ; obligation de maîtrise de l'IA prévue à l'article 4, maintenue mais assouplie ; à vérifier sur le texte consolidé le jour du cours) : pyramide de risques, obligations du fournisseur et du déployeur, contrôle humain. Atelier : analyse d'écart du projet contre la documentation technique de l'annexe IV en 2 pages ; model card v3 et datasheet du jeu de données ; revue par une autre équipe avec liste de contrôle en 12 points (chaque chiffre a-t-il un n et un intervalle ? la limite est-elle vérifiable ?). Utile en poste : la question que posera le juriste au premier comité.
Les maths, les données, le livrable
Ce qu'on démontre
Toute allégation de performance est une estimation avec intervalle et un n ; comparaisons multiples entre G groupes : Bonferroni α/G ou Benjamini-Hochberg ; traçabilité = hachage du modèle, hachage des données, version du code par prédiction ; journalisation : quelles quantités enregistrer pour recalculer les métriques par période.
Données et outils
Portail AI Act de la Commission européenne (digital-strategy.ec.europa.eu) ; gabarits du cours
Ce que vous rendez
AI_ACT_GAP.md (2 pages) + MODEL_CARD.md v3 + DATASHEET.md + fiche de revue reçue et réponses.
S24. Du modèle au service : contrat d'entrée, tests de propriété, latence
1,5 hSérialiser le champion, l'exposer derrière l'API FastAPI du gabarit (/predict avec ensemble conforme et signal d'abstention, /health, /model-info avec tag et hash) ; écrire soi-même 4 tests d'intégration (schéma refusé, invariance, monotonie, latence) ; script de charge simple. L'IA est encouragée pour le squelette (niveau 4) ; les tests de propriété sont à écrire soi-même. Utile en poste : c'est la différence entre un notebook et un livrable.
Les maths, les données, le livrable
Ce qu'on démontre
Contrat d'entrée : schéma typé et domaine de chaque variable (pydantic) ; invariance predict(pipeline chargé) = predict(pipeline entraîné) à 1e-12 sur un jeu figé ; propriété de monotonie : le score de défaut doit être croissant en PAY_0, toutes choses égales par ailleurs, vérifié sur 1 000 tirages ; latence p50 et p95 sur 1 000 requêtes ; identité du modèle = tag git + SHA-256 du fichier sérialisé ; joblib exécute du code au chargement, donc jamais un artefact non vérifié.
Données et outils
FastAPI, pydantic, joblib, pytest (devcontainer)
Ce que vous rendez
Dossier service/ avec API, 4 tests d'intégration verts, latences p50/p95 dans MODEL_CARD.md.
S25. Examen individuel sans IA : dérivations sur papier puis pratique hors ligne
2,5 hConditions à cadrer avec l'école (à confirmer) : postes de l'école ou portables en mode examen, réseau coupé, documentation scikit-learn locale autorisée, aménagements réglementaires (temps majoré) appliqués. Ce que teste l'examen : ce que vous savez faire seul en deux heures, c'est-à-dire ce qu'on demande en entretien technique.
Les maths, les données, le livrable
Ce qu'on démontre
Partie A (45 minutes, papier) : deux dérivations tirées de la liste publiée (moindres carrés, MLE, ridge/lasso, dual SVM, représentation, Rademacher, pseudo-résidu, rétropropagation, EM, quantile conforme) et lecture critique d'un extrait de code défectueux. Partie B (1 h 45, poste hors ligne) : jeu de données tabulaire inédit fourni sur clé, avec une fuite cachée et une composante temporelle ; pipeline sans fuite, validation justifiée, métrique avec IC, seuil par coût, note d'une page pour un décideur.
Données et outils
Papier ; Python, scikit-learn, pandas sur poste hors ligne ; jeu inédit préparé par l'enseignant
Ce que vous rendez
Copie papier + notebook et note d'une page rendus sur clé.
S26. Soutenances : démonstration en direct, dérivation tirée au sort, modification de code
3 h12 équipes × 14 minutes (5 de pitch, 9 de questions) puis 12 minutes de consignes du rendu final ; au-delà de 12 équipes, deux salles ou 12 minutes (à confirmer). L'enseignant clone le dépôt, lance make reproduce sur l'extrait et l'API, modifie une entrée et demande à un membre tiré au sort de prédire la sortie avant de l'exécuter ; deux questions tirées d'une urne (« ouvrez src/features.py ligne N », « refaites t* avec ces coûts », « quelle entrée de DECISIONS.md regrettez-vous ? ») ; chaque membre interrogé au moins une fois, dont sur son livrable nominatif. Praticien invité au jury (à confirmer). Grilles publiées à l'avance.
Les maths, les données, le livrable
Ce qu'on démontre
Attendu : problème, règle de décision pré-enregistrée, champion et son IC, seuil et coût, couverture conforme, audit d'équité, plan de monitoring, analyse d'écart AI Act, ce qui a été appris des ablations et des erreurs de l'IA. Une dérivation au tableau tirée au sort dans la liste publiée par équipe.
Données et outils
Dépôt d'équipe projeté, devcontainer, urne de questions, grille d'oral
Ce que vous rendez
Support de 10 diapositives maximum déposé dans le dépôt avant la séance ; grille d'oral par étudiant.
Rendu final : le projet livré
À confirmer : deux semaines après le bloc de janvier (fin janvier ou début février 2027), tag git final avant l'heure limite.
Ce que vous rendez
- Dépôt final tagué : make reproduce, make compare, tests, service/ avec API et tests d'intégration, CI verte, README suivi par une autre équipe sur le devcontainer.
- Rapport de 8 pages maximum : problème, données et carte des fuites, méthodes avec dérivations clés en annexe, comparaison avec IC, seuil et coût, prédiction conforme, interprétabilité, équité, monitoring, valeur en euros, limites, ce que vous feriez avec 3 mois de plus.
- MODEL_CARD.md v3, DATASHEET.md, MONITORING.md, AI_ACT_GAP.md, MEMO_CLIENT.md.
- DECISIONS.md, issues PREREG et annexe IA complets ; WORST20.md et LIVRABLES_NOMINATIFS.md finaux.
- Réponses aux issues de la revue croisée et à la fiche de revue de la model card (corrigées ou argumentées).
- Réflexion individuelle de 300 mots rédigée en séance (jour 5) et fiche individuelle d'une page : ma contribution, ce que j'ai compris de plus difficile, ce que j'ai vérifié moi-même.
Les preuves que vous avez réfléchi
- La réflexion de 300 mots a été écrite en salle sans IA et doit citer des chiffres précis du propre projet ; la fiche individuelle est recoupée avec les livrables nominatifs, le git shortlog et les grilles d'oral.
- Les issues PREREG horodatées côté serveur portent la trace des prédictions faites avant les expériences, avec les écarts.
- Les réponses à la revue croisée : accepter ou réfuter une critique demande de comprendre son propre code.
- L'examen individuel hors ligne, la dérivation au tableau et la modification de code en direct ont déjà vérifié la maîtrise individuelle ; le rendu final doit être cohérent avec ce qui a été dit et montré.
Vérification en salle, sans IA
Aucun bloc suivant : la vérification finale est l'examen S25 (papier puis pratique hors ligne) et la soutenance S26 (démonstration en direct, dérivation tirée au sort, modification prédite puis exécutée). Un entretien individuel de 10 minutes peut être demandé par l'enseignant en cas d'incohérence entre le rendu final et les traces (date à confirmer).
Construire avec l'IA, sans tricher
L'IA générative est autorisée et même attendue sur une partie du travail. Ce qui est noté, c'est ce que vous savez dériver, expliquer et vérifier sans elle.
- Deux voies, comme le modèle « two-lane » de l'université de Sydney (Bridgeman, Liu et Weeks 2024) : la note certifiante vient d'épreuves en présence sans IA (contrôles, oraux, examen hors ligne, soutenance), soit 55 % ; le projet entre les blocs est ouvert, l'IA y est autorisée et déclarée. Les niveaux d'usage suivent l'AI Assessment Scale dans sa version 2 (Perkins, Roe et Furze 2025, « Reimagining the Artificial Intelligence Assessment Scale », JUTLP 22(7), DOI 10.53761/rrm4y757), qui introduit le niveau « AI Exploration » ; les libellés 2.1 sont ceux publiés sur aiassessmentscale.com. Échelle originale : Perkins, Furze, Roe et MacVaugh 2024, JUTLP 21(6), DOI 10.53761/q3azde36.
- Aucun détecteur d'IA n'est utilisé, ni comme indice ni comme base de sanction : les détecteurs ne sont ni exacts ni fiables (Weber-Wulff et al. 2023, précision sous 80 %), OpenAI a retiré le sien en juillet 2023, Turnitin exclut le code de la détection fiable, et ils pénalisent les non-natifs (Liang et al. 2023). La preuve vient de l'étudiant : dérivation en salle, oral sur son propre code, chiffres reproductibles.
- Toute affirmation chiffrée doit être reproductible par une commande que l'enseignant exécute ; ce qui ne se reproduit pas ne compte pas. L'oral sur son propre travail est la modalité privilégiée ici : les enseignants rencontrés par la mission Pascal et Taddei sont unanimes pour y voir le meilleur moyen de savoir si l'étudiant maîtrise le savoir et les compétences associées (rapport MESR « IA et enseignement supérieur : formation, structuration et appropriation par la société », juillet 2025, section 2.3.1 ; la mission signale aussi le coût des oraux sur de grandes promotions et les compétences que l'oral n'évalue pas). Voir aussi QAA 2023 sur les mini-vivas.
- Le raisonnement laisse des traces horodatées hors du contrôle de l'étudiant : issues GitHub et hachages sur Moodle pour le pré-enregistrement, instantanés hebdomadaires des dépôts par un robot de l'enseignant ; le git log seul, dont les dates et l'auteur se réécrivent, n'est jamais une preuve, seulement une source de questions (arXiv 2607.07400).
- Déclarer un usage de l'IA n'est jamais pénalisé ; ne pas le déclarer là où il est interdit, ou inventer un chiffre, une source ou un résultat, est une fraude traitée selon le règlement de l'école (à confirmer). Les aménagements réglementaires (temps majoré) s'appliquent à toutes les épreuves ; les grilles d'oral et la liste des dérivations exigibles sont publiées à l'avance.
- Budget enseignant totalisé pour un enseignant seul et 40 étudiants : environ 30 heures hors cours par semestre (contrôles 13 h, examen 6 h, jalons et sondages 6 h, rendu final 3 h, revue croisée et sorties imposées 2 h), plus environ 15 heures de préparation réutilisable la première année (gabarit et CI, devcontainer, pré-test, scripts de génération et d'injection, jeu d'examen). Ce qui dépasse ce budget est retiré, pas bâclé.
Les cinq niveaux d'usage de l'IA
1 · No AI (sans IA)
Aucun outil d'IA ; papier, poste hors ligne ou dépôt projeté sans assistant. Conditions surveillées, aménagements appliqués.
S'applique à : Contrôles de fin de journée et de début de bloc, chasse à l'erreur sur diff, critique des sorties imposées, oraux tirés au sort, examen S25, questions et démonstration de soutenance, réflexion de 300 mots.
2 · AI Planning (IA pour planifier)
L'IA peut expliquer un théorème, proposer un plan, un exemple ou une piste, aider à réviser ; rien de ce qu'elle produit n'est rendu.
S'applique à : Préparation des contrôles, lecture des références, cadrage du projet et plan du dépôt, implémentations « from scratch » (l'IA peut expliquer l'algorithme, pas écrire le code ; elles sont vérifiées en contrôle et à l'oral).
3 · AI Collaboration (IA en collaboration, sortie évaluée)
L'IA peut proposer des brouillons, relire, corriger la langue et la mise en page ; chaque chiffre, interprétation et décision est écrit et vérifié par l'équipe ; l'usage est déclaré dans l'annexe.
S'applique à : Notes de jalon, rapport final, model card, datasheet, mémo client, analyse d'écart AI Act, support de soutenance, fiche individuelle.
4 · Full AI (IA complète, jugement humain)
L'IA peut produire du code et des brouillons d'analyse si chaque sortie est testée, corrigée, comprise, déclarée, et explicable à l'oral par n'importe quel membre.
S'applique à : Plomberie du dépôt (S8, S24), pipelines sklearn, figures, scripts d'expérience, API FastAPI, CI, tests hors tests de propriété.
5 · AI Exploration (IA explorée)
L'usage de l'IA est l'objet de l'exercice : on est noté sur la façon de la piloter, de la contredire et de prouver ses erreurs.
S'applique à : Annexe IA critique (deux erreurs prouvées par jalon), IA comme premier relecteur du dépôt puis contre-vérification humaine documentée.
Ce qui rend la triche inutile
Contrôles sur papier sans IA, avec questions personnalisées générées par script
30 minutes en fin de chacune des journées 1 à 5 (dérivations du jour, barème binaire à 4 items) et 45 à 60 minutes en début des blocs 2 et 3 (dérivations de la liste publiée + questions imprimées depuis le dépôt de l'étudiant : une fonction et une modification dont il prédit l'effet, ses propres AUC et IC).
Détecte : L'étudiant qui a fait générer dérivations et code sans les comprendre ; les résultats copiés qu'il ne sait pas interpréter ; l'écart entre le rendu d'équipe et la maîtrise individuelle.
Oraux tirés au sort avec registre de passage : « explique, modifie, prédis, lance »
À chaque heure de jalon, 10 étudiants tirés au sort sans remise (registre public, où tout étudiant non encore passé est prioritaire) ouvrent leur dépôt : expliquer une fonction ou un test, appliquer une modification demandée, écrire l'effet prédit, exécuter. 5 heures de jalon = 50 passages pour au plus 40 étudiants : chacun passe au moins une fois avant la soutenance, où chaque membre est de nouveau interrogé.
Détecte : Le membre passif ; le code collé dont personne ne connaît la logique ; la lecture sans compréhension causale (prédire l'effet distingue comprendre de réciter).
Pré-enregistrement horodaté côté serveur, journal de décisions et livrables nominatifs
Avant chaque expérience notée, la prédiction chiffrée et la règle de décision sont déposées en issue GitHub (horodatage serveur) et le hachage de PREREG.md sur Moodle ; DECISIONS.md consigne chaque choix avec l'alternative rejetée et un chiffre reproductible ; LIVRABLES_NOMINATIFS.md attribue à chaque membre une fonction, une ligne d'ablation et une erreur du top 20, interrogées à l'oral. Un script vérifie la régularité des dates et le git shortlog.
Détecte : La rationalisation après coup ; le projet généré en une nuit ; le passager clandestin ; le journal plausible généré par IA (une entrée tirée au sort est interrogée à chaque oral).
Reproduction automatique en CI, sondage sur machine neuve et revue croisée asynchrone
make reproduce et make compare tournent dans GitHub Actions et comparent metrics.json aux valeurs du rapport à ±0,005 ; à chaque jalon l'enseignant clone 3 dépôts tirés au sort dans un devcontainer vierge ; la semaine suivant chaque tag, chaque équipe suit le README d'un autre dépôt sur le devcontainer et ouvre deux issues étayées, traitées avant le bloc suivant.
Détecte : Les chiffres du rapport qui ne sortent pas du code ; les graines changées après coup ; le dépôt qui ne tourne que sur la machine de l'auteur ; les fuites invisibles à l'auteur.
Chasse à l'erreur : notebook piégé puis bug injecté dans une copie de son propre dépôt
Jalon 1 : notebook piégé de l'enseignant avec 3 défauts (pièges changés chaque année). Début du bloc 3 : un script injecte l'une de trois variantes de bug (fuite dans le prétraitement, seuil inversé, schéma trop permissif) dans une fonction du dépôt de l'équipe ; le diff est imprimé ; chaque étudiant, seul et sans IA, localise, explique et prédit l'effet.
Détecte : L'incapacité à lire du code et à reconnaître une fuite ; les équipes qui n'ont pas relu le code produit par l'IA ; une réponse introuvable en ligne puisque le code est le leur.
Ablation pré-enregistrée, résultat surprenant et 20 pires erreurs nominatives
Chaque jalon exige un tableau d'ablation interprété ligne par ligne, la désignation d'un résultat inattendu avec une explication testée, et une des 20 pires erreurs du test prise en charge par chaque membre (diagnostic, correction tentée, effet chiffré).
Détecte : L'usage boîte noire ; l'absence de lien entre résultats et mécanismes du cours ; le membre qui n'a jamais regardé une ligne de données.
Annexe IA critique avec preuves et sortie d'IA imposée à critiquer en salle
L'annexe liste les usages, les prompts et au moins deux propositions de l'IA réfutées avec la preuve (test, calcul, figure) ; à chaque heure de jalon, une sortie d'IA imposée par l'enseignant (même texte pour tous : explication fausse, PR avec fuite, model card générée) est critiquée sur papier sans IA ; une question d'oral porte sur l'erreur déclarée.
Détecte : L'usage non déclaré ; la confiance aveugle ; l'annexe fabriquée en demandant à l'IA une erreur puis sa réfutation (la critique en salle et la question d'oral ne se fabriquent pas).
Examen individuel hors ligne et soutenance avec démonstration en direct
Jour 6 : 45 minutes de dérivations sur papier (liste publiée) puis 1 h 45 sur un jeu inédit avec fuite cachée, poste sans réseau ; en soutenance, l'enseignant exécute le dépôt, demande une dérivation au tableau tirée au sort et une modification de code dont un membre tiré au sort prédit l'effet avant exécution.
Détecte : Le pitch appris par cœur sans maîtrise du code ; le passager clandestin ; l'écart entre la maîtrise affichée en équipe et ce que l'étudiant sait faire seul en conditions d'entretien.
La note
55 % de la note est individuelle et obtenue en salle sans IA : contrôles, examen, oraux.
Les références du cours
Pour approfondir. Gratuit = une version intégrale et légale est en ligne.
Point d'entrée de chaque séance : lire le chapitre correspondant avant le bloc (régression, classification, rééchantillonnage, régularisation, arbres, SVM, non-supervisé). Version Python gratuite ; un exercice tiré du livre est corrigé au début de chaque bloc.
Le texte des dérivations : moindres carrés et ridge en base SVD (ch. 3), noyaux (ch. 5 et 12), boosting comme descente de gradient (ch. 10), forêts (ch. 15). Gratuit.
Les rappels d'algèbre linéaire, de calcul différentiel et de probabilités que le cours suppose ; chapitres 7 (optimisation), 9 (régression linéaire, MLE et MAP), 10 (ACP). Gratuit.
S10 suit ce livre : PAC, dimension VC, Rademacher ; le théorème du représentant, chapitre 16, sert à S9 ; chapitre 14 pour les taux de convergence de SGD utilisés en S5. Gratuit.
Convexité, dualité et conditions KKT pour S5 et S9 ; chapitres 2 à 5 et 9. Gratuit.
Lecture probabiliste : MLE, MAP, calibration, EM et mélanges gaussiens (S2, S6, S7, S17). Gratuit.
Chapitre 6 (noyaux) et chapitre 9 (k-means, EM, mélanges gaussiens) pour S9 et S17. Gratuit.
Rétropropagation, initialisation, régularisation des réseaux (chapitres 6 à 8) pour S18 et S19. Gratuit.
L'inférence derrière S1 : hypothèses de Gauss-Markov, erreurs-types, hétéroscédasticité et erreurs-types robustes. Non gratuit.
Validation croisée purgée avec écart et sur-apprentissage des backtests : l'avertissement temporel de S3 et S20. Non gratuit.
Le côté pratique de scikit-learn et de Keras : pipelines, recherche d'hyperparamètres, mise en production ; notebooks compagnons gratuits.
Free companion notebooksCourbes de coût et de profit, seuil de décision et lecture métier des métriques (S7, S22) ; à lire avant la note « Seuil et coût » et le mémo client.
Et quatre ressources en accès libre
Questions fréquentes
Puis-je utiliser ChatGPT, Claude ou Copilot pour le projet ?
Oui, pour tout ce qui est étiqueté niveau 4 (Full AI) : plomberie du dépôt, pipelines, API, figures, CI. Vous déclarez l'usage dans l'annexe IA, testez chaque sortie et devez savoir l'expliquer à l'oral, y compris prédire l'effet d'une modification avant de la lancer. Les implémentations « from scratch » sont au plus niveau 2 (l'IA explique l'algorithme, elle n'écrit pas le code) et sont vérifiées en contrôle. Les contrôles, l'examen, les oraux et la soutenance sont sans IA. Déclarer n'est jamais pénalisé ; ne pas déclarer là où c'est interdit, ou inventer un chiffre, est une fraude. Aucun détecteur d'IA n'est utilisé : la preuve vient de vous.
Pourquoi autant de maths si scikit-learn fait tout en trois lignes ?
Parce que les trois lignes ne disent pas pourquoi le score CV monte quand vous standardisez avant la coupe, pourquoi le lasso met des zéros exacts, pourquoi la pondération des classes déplace vos probabilités, ni si la différence entre deux AUC est établie. Les dérivations sont courtes (une page chacune), la liste des dérivations exigibles est publiée, et chaque séance les vérifie numériquement contre scikit-learn. C'est ce qu'on vous demandera en entretien technique et en comité de validation.
Comment sont notés les membres d'une équipe où quelqu'un ne travaille pas ?
55 % de la note est individuelle et sans IA : contrôles, examen, oraux. Les notes d'équipe sont modulées par les livrables nominatifs (une fonction, une ligne d'ablation, une erreur du top 20 par membre, interrogés à l'oral), la fiche individuelle et le git shortlog. Un membre sans livrable nominatif défendu à l'oral ne reçoit pas la note de l'équipe et est reçu individuellement. Signalez un déséquilibre à l'enseignant dès le point d'étape de mi-parcours, pas la veille de la soutenance.
Que se passe-t-il en cas d'absence, de retard de rendu ou d'échec à un jalon ?
Absence justifiée à un contrôle : note neutralisée (moyenne des autres contrôles) ; absence non justifiée : zéro sur ce contrôle ; seuls les 4 meilleurs contrôles de fin de journée sur 5 comptent. L'examen S25 et la soutenance se rattrapent uniquement sur justificatif, selon le règlement de l'école (à confirmer). Tag de jalon en retard : pénalité de 10 % par jour ouvré, trois jours maximum, et questions personnalisées générées depuis le dernier commit. Équipe sans baseline au bloc 2 : entretien de 15 minutes et plan de rattrapage écrit. Barre individuelle : une moyenne des items individuels inférieure à 8/20 déclenche un entretien de rattrapage, quelle que soit la note d'équipe (règles de l'école à confirmer). Les aménagements réglementaires (temps majoré) s'appliquent à toutes les épreuves.
Faut-il installer quelque chose avant le bloc d'octobre ?
L'enseignant livre avant le bloc 1 un gabarit de dépôt avec un lockfile et un devcontainer testé (GitHub Codespaces ou image Docker) ; si vous préférez une installation locale : Python 3.12, git, numpy, pandas, scipy, scikit-learn, matplotlib, statsmodels, DuckDB, pytest et un compte GitHub. Les échauffements et le pré-test diagnostique de 30 minutes se font dans le navigateur sur ecofinlearning.com, sans installation. PyTorch, shap, FastAPI et MAPIE servent aux blocs 2 et 3 et sont dans le devcontainer ; tout ce qui n'y tourne pas avant octobre n'est pas exigé en séance.
Les données sont-elles réelles, combien de temps demande le projet entre les blocs, et puis-je le réutiliser ?
Oui : UCI Default of Credit Card Clients (30 000 clients) et UCI Bike Sharing (demande horaire 2011-2012), tous deux publics sous licence CC BY 4.0, copiés avec leur licence et leur hachage dans le gabarit. Chaque équipe reçoit un sous-échantillon tiré avec sa propre graine et une variable retirée : les chiffres attendus diffèrent par équipe et par année. Comptez 15 à 20 heures par personne entre chaque bloc, avec un point d'étape en visio à trois semaines. Le dépôt final (pipeline reproductible, comparaison avec intervalles, model card, audit d'équité, prédiction conforme, API testée, plan de monitoring) est un portfolio présentable en stage ou en entretien, à condition de citer la source des données. Dates et salles : à confirmer, hors vacances indicatives du 17 octobre au 1er novembre 2026 et du 19 décembre 2026 au 3 janvier 2027.
Ce qui reste à confirmer
Cette maquette est une proposition d'enseignant. Voici honnêtement ce qui dépend de l'école ou reste à arbitrer.
- Charge enseignant : environ 30 h hors cours par semestre pour 40 étudiants, plus 15 h de préparation réutilisable la première année ; le budget ne tient qu'avec les barèmes binaires, les questions générées par script, le sondage de reproductibilité et les grilles d'oral remplies en direct. Sans ces raccourcis, retirer un contrôle de fin de journée plutôt que bâcler.
- Journées de 9 h de cours, pauses non comprises : horaires à confirmer avec l'école (par exemple 8 h 30 à 12 h 30 et 13 h 30 à 18 h 30). Règle de délestage : chaque séance a un cœur (dérivation + vérification numérique) et une extension marquée, sautée si la séance dépasse ; le jour 6 n'a aucune marge.
- Calendrier : blocs et jalons à confirmer, hors vacances indicatives (du 17 octobre au 1er novembre 2026 ; du 19 décembre 2026 au 3 janvier 2027 ; calendrier scolaire national, arrêté du 22 octobre 2025, reprises les 2 novembre 2026 et 4 janvier 2027 ; l'école n'est pas tenue par ce calendrier, à confirmer) ; la date de fin du semestre 9 n'est pas publiée ; positionnement dans la maquette (électif de S7 ou option d'approfondissement INFO, parcours IAM, en S9) à confirmer avec l'école.
- Conditions des épreuves sans IA : salle, postes hors ligne ou mode examen sur portables, surveillance de 40 étudiants par un seul enseignant, documentation locale autorisée, aménagements : à cadrer avec le règlement des examens de l'école avant octobre.
- Effectif et soutenances : 12 équipes de 3 pour 36 étudiants ; à 40, 13 ou 14 équipes et les 3 h de S26 ne suffisent pas : deux salles ou 12 minutes par équipe (à confirmer) ; praticien invité au jury à confirmer.
- Environnement : le devcontainer doit être testé sur les postes réels avant octobre ; secours prévus (sklearn MLPClassifier pour PyTorch, permutation et PD pour shap, numpy pour MAPIE) ; les données sont copiées dans le gabarit pour ne pas dépendre du réseau en séance.
- Réglementation mouvante : les dates de l'AI Act citées reflètent le règlement (UE) 2026/1744 du 27 juillet 2026 ; vérifier le texte consolidé et le portail de la Commission le jour de S16 et S23, jamais les diapositives de l'année précédente.
- Similarité inter-équipes et inter-promotions : UCI Default est traité par des milliers de notebooks publics ; d'où le sous-échantillon par graine d'équipe, la variable retirée, les pièges changés chaque année et, en cas de doute, une comparaison de similarité de code (JPlag) utilisée comme source de questions d'oral, jamais comme preuve.
- Densité mathématique : trois implémentations from scratch ont été retirées ou passées en extension par rapport à la première version ; si S9 ou S14 dépassent encore, l'extension (dual par scipy, balayage de D, MLflow) saute en priorité.
- Sur-usage de l'IA malgré les garde-fous : la part individuelle sans IA (55 %), les questions sur les propres chiffres et le propre code de l'étudiant, et la sortie d'IA imposée limitent le gain d'une fraude ; un entretien individuel reste possible en cas d'incohérence entre rendu et traces.
Prendre de l'avance dès maintenant
Le parcours Machine Learning tourne dans votre navigateur, sans installation ni compte. Faites-le avant octobre : la première séance commencera plus haut.
Commencer le parcours ML, gratuitementCette page compagnon est tenue par Sitraka Forler et n'est pas une publication officielle de Centrale Méditerranée (École centrale de Marseille). Le syllabus, les dates, les salles et le règlement des épreuves qui font foi sont ceux de l'école. Une erreur ? Signalez-la et je la corrige.