Module L24 · Partie J · Vers la recherche

Faire de la recherche : lire, reproduire, questionner, publier.

Vous savez maintenant coder proprement, prouver, calculer, apprendre, percevoir, contrôler, et vous connaissez les limites. La recherche commence là où le cours s’arrête : une question que personne n’a résolue. Ce module donne la méthode — lire un article, reproduire un résultat, mesurer honnêtement, formuler une question — puis une carte des grandes questions ouvertes en informatique, IA et robotique, et le chemin concret : TIPE, prépa, écoles, laboratoires.

Durée : 2 séances + un projet · Prérequis : tout le parcours. Objectifs : anatomie d’un article, lecture en trois passes, reproduction et ses pièges, expérimentation rigoureuse (baselines, ablations, variance, significativité), rédaction et présentation, éthique et ouverture, panorama des questions ouvertes, parcours X/ENS/prépa/université et au-delà.

Ce que vous saurez faire à la fin

Lire un article de recherche et en extraire la contribution, la méthode et les limites en 30 minutes.
Reproduire un résultat publié et documenter les écarts.
Concevoir une expérience qui répond vraiment à une question.
Choisir et cadrer un sujet de TIPE ou de projet de recherche.

Références : « How to Read a Paper » (Keshav), « The Turing Way » (guide de la science reproductible, gratuit), Writing for Computer Science (Zobel), les rapports « State of AI » et les revues de la Robotics: Science and Systems.

Fiche de cours · Définitions

Vers la recherche : définitions

Définition (article de recherche). Texte évalué par les pairs qui présente une contribution nouvelle (méthode, résultat, preuve, système, jeu de données, étude) avec ses preuves ou expériences, dans le contexte des travaux existants. Types : conférence (informatique : le format principal, 8–10 pages, cycle de 3 à 6 mois), journal (plus long, plus lent), atelier (préliminaire), prépublication (arXiv, non évaluée).

Définition (contribution, question de recherche, hypothèse). Question : ce qu’on ne sait pas et qui compte. Hypothèse : réponse candidate falsifiable. Contribution : ce que l’article ajoute, en une phrase (« nous montrons que X permet Y dans les conditions Z, avec un gain de W »).

Définition (reproductibilité, réplicabilité). Reproduire : mêmes données, même code → mêmes résultats. Répliquer : nouvelle implémentation ou nouvelles données → mêmes conclusions. Une contribution non reproductible n’est pas établie.

Définition (protocole expérimental). Variables indépendantes (ce qu’on fait varier), dépendantes (ce qu’on mesure), contrôlées (fixées), de confusion (variant avec les indépendantes sans qu’on le veuille). Baseline, ablation, graines multiples, jeu de test scellé, métriques fixées à l’avance.

Définition (biais et fautes). p-hacking (tester jusqu’à trouver p < 0,05), HARKing (formuler l’hypothèse après les résultats), sélection des résultats, fuite du test, contamination des données, cherry-picking des baselines. Distinction avec la fraude (fabrication, falsification, plagiat) : les premiers sont des erreurs de méthode, souvent inconscientes.

Définition (évaluation par les pairs, facteur h, citations). Relecture anonyme par 3–4 experts ; décision : accepté, révisions, rejeté. Les indicateurs (citations, h-index) mesurent l’attention, pas la vérité.

Fiche de cours · Formules

Les outils quantitatifs du chercheur

Moyenne ± écart-type sur n graines ; erreur standard s/√n ; IC à 95 % ≈ x̄ ± 1,96·s/√n (n ≥ 30) ou ± t_n−1·s/√n

t de Welch : t = (x̄_A − x̄_B)/√(s_A²/n_A + s_B²/n_B) ; |t| > 2 ≈ significatif à 5 % ; taille d’effet de Cohen d = (x̄_A − x̄_B)/s

Puissance : pour détecter un écart Δ avec un bruit σ à 80 % de puissance et α = 5 %, n ≈ 16σ²/Δ² par groupe

Correction de Bonferroni pour k comparaisons : seuil α/k ; ou Holm, ou contrôle du taux de fausses découvertes (Benjamini-Hochberg)

Loi d’Amdahl : accélération ≤ 1/((1 − p) + p/s) — optimiser la fraction p du temps d’un facteur s

Coût d’une expérience : (nombre de configurations) × (graines) × (temps par exécution) — à écrire avant de lancer

Question	Outil
Deux méthodes diffèrent-elles ?	t de Welch, ou test de permutation (sans hypothèse gaussienne), sur ≥ 5 graines
Quel composant explique le gain ?	Ablation : retirer un à un, même protocole
Le résultat tient-il ailleurs ?	Autres jeux de données, autres échelles, autres graines, autre matériel
Est-ce un artefact ?	Baseline réglée avec le même budget ; vérifier les fuites ; randomiser les étiquettes (le score doit s’effondrer)

Fiche de cours · Théorèmes et démonstrations

Ce qu’on peut démontrer sur la méthode scientifique

Proposition 1 (le maximum de k essais est biaisé). Si k mesures indépendantes ont la même moyenne μ et le même écart-type σ, l’espérance du maximum est μ + σ·c_k avec c_k > 0 croissant (≈ 0,56σ pour k = 2, 1,16σ pour k = 5, 1,54σ pour k = 10, 2,5σ pour k = 100 sous hypothèse gaussienne).

E[max] ≥ E[X₁] = μ avec égalité seulement si les variables sont presque sûrement égales ; pour des gaussiennes, E[max(X₁, X₂)] = μ + σ/√π ≈ μ + 0,56σ (calcul direct de E[|X₁ − X₂|]/2), et la constante croît comme √(2 ln k). Conséquence : rapporter « le meilleur de 10 essais » surestime la performance d’environ 1,5 écart-type ; sélectionner la meilleure configuration sur le jeu de test puis rapporter son score sur ce même jeu est la même faute (L24, exercice du module). Le seul remède : sélectionner sur la validation, rapporter sur un test intact.

Proposition 2 (tests multiples). Avec k hypothèses toutes fausses testées au seuil α, la probabilité d’au moins un « résultat significatif » est 1 − (1 − α)^k : 40 % pour k = 10, 64 % pour k = 20 à α = 0,05.

Chaque test rejette à tort avec probabilité α, indépendamment ; la probabilité qu’aucun ne rejette est (1 − α)^k. Avec Bonferroni (seuil α/k), la probabilité d’au moins une erreur est ≤ k·α/k = α (borne de l’union). C’est le fondement de la pré-inscription (déclarer les hypothèses avant les données) : elle rend k explicite.

Proposition 3 (un gain non reproduit sur une graine n’est pas un gain). Si deux méthodes ont la même performance moyenne et un bruit d’écart-type σ, l’écart observé sur une seule exécution de chacune est de loi N(0, 2σ²) : dépasse σ en valeur absolue avec probabilité 48 %, 2σ avec 16 %.

Différence de deux gaussiennes indépendantes : variance σ² + σ² = 2σ², écart-type σ√2 ≈ 1,41σ ; P(|N(0, 2σ²)| > σ) = P(|Z| > 0,71) = 0,48 ; P(|Z| > 1,41) = 0,16. Un « +1 point » quand le bruit inter-graines est de 1 point ne dit rien. Avec n graines par méthode, l’écart-type de la différence des moyennes est σ√(2/n) : pour n = 10, 0,45σ — un gain de 1σ devient détectable.

Proposition 4 (falsifiabilité et charge de la preuve). Une hypothèse qui ne peut être contredite par aucune observation possible n’a pas de contenu empirique (Popper) ; la charge de la preuve incombe à qui affirme la nouveauté.

Argument logique : si H est compatible avec toute observation O, alors P(O | H) = P(O | ¬H) pour tout O, et Bayes donne P(H | O) = P(H) : aucune donnée ne peut faire évoluer la croyance en H. Pour un article : prévoir ce qui réfuterait la contribution (« si la baseline bien réglée atteint le même score, notre méthode n’apporte rien ») et tester précisément cela.

Fiche de cours · Méthodes

Méthodes : lire, expérimenter, écrire

Méthode — lire un article en trois passes (Keshav). (1) 5 min : titre, résumé, introduction, titres de sections, conclusion → de quoi s’agit-il, est-ce pour moi ? (2) 1 h : figures, tableaux, méthode, en notant les références à lire → contribution et preuves, sans les détails. (3) 4 h : réimplémenter mentalement (ou réellement) chaque étape, vérifier chaque affirmation → forces, faiblesses, ce que je ferais autrement. Fiche par article : contribution en 3 phrases, méthode, résultat clé, limites, idées.

Méthode — concevoir une expérience. Écrire la question et l’hypothèse ; choisir la métrique et la baseline ; fixer le protocole (données, séparations, graines, budget d’hyperparamètres égal pour tous) ; estimer la taille d’échantillon (formule de puissance) ; écrire le script d’analyse avant les résultats ; lancer ; analyser sans changer le protocole ; documenter ce qui n’a pas marché.

Méthode — écrire un article. Contribution en une phrase, puis résumé (problème, méthode, résultat chiffré, portée) ; figures d’abord (chacune avec un message) ; introduction qui répond à « pourquoi ce problème, pourquoi maintenant, qu’apportons-nous » ; méthode reproductible ; expériences honnêtes (limites, cas d’échec) ; travaux connexes justes ; conclusion sans exagération. Relecture par quelqu’un d’extérieur ; version courte pour un exposé de 10 min.

Méthode — choisir un sujet de TIPE/premier projet. Croisement de trois cercles : ce qui vous intéresse, ce qui est faisable en 6 mois avec votre matériel, ce qui a une question ouverte (même modeste). Vérifier qu’il existe une baseline reproductible et une mesure claire du succès.

Pièges : réinventer sans chercher la littérature (30 min sur Scholar avant tout) ; sujet trop large ; expérience sans baseline ; « ça marche sur mon exemple » ; changer la métrique après coup ; ne pas noter les échecs ; croire qu’un article publié est vrai ; croire qu’un article rejeté est faux.

Fiche de cours · Exercices corrigés

Exercices corrigés

Exercice 1. Un article rapporte : méthode A 74,2 %, baseline B 71,8 %, une exécution chacune, sur un jeu de test de 500 exemples. Que peut-on conclure ? Que demander aux auteurs ?

Correction. Deux sources de bruit : (i) la variabilité d’entraînement (graine, ordre des lots), typiquement 0,5–2 points, inconnue ici ; (ii) l’échantillonnage du test : pour p ≈ 0,73 et n = 500, l’écart-type d’une exactitude est √(p(1−p)/n) = 2,0 points ; l’écart-type de la différence (même test, corrélation partielle) est de l’ordre de 1,5–2,8 points. L’écart observé de 2,4 points est de l’ordre du bruit : conclusion impossible. Demander : 5 graines par méthode avec moyenne ± écart-type ; un test plus grand ou une validation croisée ; un test apparié (les mêmes exemples pour A et B : test de McNemar sur les désaccords) ; le budget de réglage de la baseline ; le code.

Exercice 2. Vous voulez montrer qu’un nouveau filtre réduit l’erreur de localisation d’un robot de 12 cm à 10 cm (σ inter-essais ≈ 3 cm). Combien d’essais par méthode ? Écrire le protocole en 6 lignes.

Correction. Δ = 2 cm, σ = 3 cm : n ≈ 16σ²/Δ² = 16·9/4 = 36 essais par méthode (puissance 80 %, α = 5 %). Protocole : (1) Hypothèse : le filtre F réduit l’erreur absolue moyenne de trajectoire par rapport à la baseline B, toutes choses égales. (2) 40 trajectoires pré-enregistrées (bags) sur 3 environnements, chaque bag rejoué avec F et B (apparié : même données, même bruit → test apparié, plus puissant). (3) Métrique fixée : ATE en cm contre vérité terrain (capture de mouvement). (4) Hyperparamètres de B et F réglés sur 10 bags distincts, budget identique. (5) Analyse : moyenne des différences appariées, IC à 95 %, test t apparié ; graphique par environnement. (6) Critère de succès déclaré à l’avance : IC de la différence entièrement < 0 et amélioration ≥ 1 cm.

Exercice 3. Vous reproduisez un article et obtenez 68 % au lieu des 74 % annoncés. Lister, par ordre de probabilité, les causes et les vérifications.

Correction. (1) Détail d’implémentation absent de l’article (prétraitement, augmentation, planning du pas, initialisation) : comparer avec le code officiel s’il existe, lire les issues GitHub. (2) Hyperparamètres ou budget d’entraînement différents : reproduire exactement ceux indiqués, compter les époques. (3) Version des données ou de la séparation train/test : vérifier les tailles, les hachés des fichiers. (4) Variabilité : lancer 5 graines — l’article a peut-être rapporté le meilleur essai (Proposition 1). (5) Bug de votre côté : tests unitaires, sur-apprentissage d’un mini-lot, comparaison des courbes de perte. (6) Résultat de l’article non reproductible : après avoir documenté (1)–(5), contacter les auteurs avec des questions précises ; si aucune réponse, un rapport de reproduction avec vos 5 graines est une contribution utile (ML Reproducibility Challenge). Ne jamais conclure « l’article est faux » avant d’avoir épuisé (1)–(5).

01 / Lire

Anatomie d’un article, et la lecture en trois passes

Section	Ce qu’elle contient	Question à se poser
Titre, résumé	La contribution en 200 mots	Qu’est-ce qui est nouveau ? Pour qui ?
Introduction	Le problème, pourquoi il compte, ce qui manquait, ce que l’article apporte	Le problème est-il bien posé ? La motivation est-elle honnête ?
Travaux connexes	Ce que les autres ont fait	Quelle est la vraie différence avec l’état de l’art ?
Méthode	L’algorithme, le modèle, la preuve	Pourrais-je le réimplémenter avec ces informations ?
Expériences	Données, baselines, métriques, résultats, ablations	Les baselines sont-elles justes ? Les écarts sont-ils significatifs ? Que se passe-t-il quand on retire un composant ?
Limites, conclusion	Ce qui ne marche pas, la suite	Les auteurs sont-ils lucides ? Que ferais-je ensuite ?

Trois passes (Keshav)

5 minutes : titre, résumé, introduction, titres de sections, conclusion. Décider : lire ou non.
1 heure : lire tout sauf les preuves ; regarder chaque figure ; noter les références à lire ; résumer la contribution en trois phrases avec ses propres mots.
4 heures : reconstruire l’article : refaire les dérivations, contester chaque hypothèse, imaginer comment on l’aurait fait autrement. C’est la lecture d’un relecteur — ou d’un chercheur qui veut construire dessus.

Où trouver les articles : arXiv (cs.RO, cs.LG, cs.AI, cs.DS), Semantic Scholar, Google Scholar, les actes des conférences (NeurIPS, ICML, ICLR pour l’IA ; ICRA, IROS, RSS, CoRL pour la robotique ; STOC, FOCS, SODA pour la théorie ; POPL, PLDI pour les langages). Tout est gratuit en ligne ; en informatique, l’article de conférence compte autant que l’article de revue.

01 / Lire

Exercice guidé : lire « Attention Is All You Need » avec les outils du cours

# Un article se lit avec un carnet. Voici le carnet d'un lecteur qui a suivi ce parcours :
carnet = {
 "titre": "Attention Is All You Need (Vaswani et al., NeurIPS 2017)",
 "contribution (3 phrases)": [
   "Une architecture pour les séquences (traduction) sans récurrence ni convolution, uniquement de l'attention.",
   "Parallélisable sur la longueur → entraînement 10× moins cher que les meilleurs RNN, et meilleure qualité (BLEU 28.4 EN→DE).",
   "Introduit l'attention multi-têtes, l'attention par produit scalaire mis à l'échelle (÷√d) et les plongements de position sinusoïdaux."],
 "liens avec le cours": {"attention": "L15", "produit matriciel et √d": "L10 (variance d'un produit scalaire de d termes ∝ d)",
                          "softmax + entropie croisée": "L13", "Adam, warmup, dropout, label smoothing": "L14", "O(n²) et comparaison RNN": "L15, L23"},
 "questions du relecteur": [
   "Pourquoi diviser par √d_k ? (§3.2.1 : sinon les logits deviennent grands, le softmax sature, les gradients s'annulent — vérifiable en 5 lignes NumPy)",
   "Les plongements sinusoïdaux sont-ils meilleurs qu'appris ? (Tableau 3, ligne E : équivalents — donc pas l'essentiel)",
   "L'ablation montre-t-elle que chaque composant compte ? (Tableau 3 : oui pour le nombre de têtes et d_k ; 1 tête : −0.9 BLEU)",
   "Que ne dit pas l'article ? La généralisation à d'autres domaines (ça viendra : BERT, GPT, ViT), le coût en mémoire de l'attention."],
 "à reproduire": "le mini-transformeur du module L15 : vérifier l'effet du ÷√d en le retirant.",
}
for k, v in carnet.items(): print(f"{k.upper()}\n  {v}\n")

# Vérification immédiate de la première question : sans ÷√d, le softmax sature
import numpy as np
rng = np.random.default_rng(0)
for d in (16, 64, 512):
    q, k = rng.normal(0, 1, (10, d)), rng.normal(0, 1, (10, d))
    s = q @ k.T; s_norm = s / np.sqrt(d)
    soft = lambda z: np.exp(z - z.max(1, keepdims=True)) / np.exp(z - z.max(1, keepdims=True)).sum(1, keepdims=True)
    print(f"d={d:3d}: écart-type des scores {s.std():5.1f} → poids max {soft(s).max():.3f} (saturé) ; normalisé {s_norm.std():.2f} → {soft(s_norm).max():.3f}")

Lire un article, c’est dialoguer avec lui : chaque affirmation est une hypothèse qu’on peut tester en dix lignes. Les meilleurs lecteurs ont un interpréteur ouvert à côté du PDF.

02 / Reproduire

La reproduction : le premier vrai travail de recherche

# Simulation d'une « reproduction » : un article annonce qu'un algorithme B bat A de 3 points. Vous refaites l'expérience.
import numpy as np
rng = np.random.default_rng(42)
def experience(algo, graine, n_essais=5):
    """Chaque essai a une variance (initialisation aléatoire, ordre des données…)."""
    r = np.random.default_rng(graine)
    base = {"A": 70.0, "B": 71.0}[algo]                       # le VRAI écart n'est que de 1 point
    return base + r.normal(0, 2.0, n_essais)                   # écart-type entre essais : 2 points

# L'article a rapporté le MEILLEUR essai de B et un essai MOYEN de A (pratique hélas courante)
article_A, article_B = experience("A", 1).mean(), experience("B", 7).max()
print(f"article : A = {article_A:.1f}, B = {article_B:.1f} → « +{article_B - article_A:.1f} points »")

# Votre reproduction : 5 graines, moyenne ± écart-type, test de permutation (module L11)
A, B = experience("A", 100, 5), experience("B", 200, 5)
print(f"reproduction : A = {A.mean():.1f} ± {A.std():.1f}, B = {B.mean():.1f} ± {B.std():.1f} → +{B.mean() - A.mean():.1f}")
tout = np.concatenate([A, B]); diffs = []
for _ in range(5000):
    rng.shuffle(tout); diffs.append(tout[5:].mean() - tout[:5].mean())
p = np.mean(np.abs(diffs) >= abs(B.mean() - A.mean()))
print(f"p-valeur = {p:.2f} → {'différence non significative avec 5 essais' if p > 0.05 else 'significatif'}")
print("Conclusion honnête : B semble légèrement meilleur ; l'écart annoncé n'est pas reproduit ; il faudrait ≈", int((1.96 * 2 / 0.5)**2), "essais pour trancher à ±0.5.")

La crise de la reproductibilité, et comment ne pas y contribuer

En IA, une part importante des résultats publiés ne se reproduit pas : graines choisies, hyperparamètres ajustés sur le test (module L13), baselines mal réglées, code absent. Les remèdes : publier le code et les données, plusieurs graines avec moyenne et intervalle, baselines réglées avec le même soin, ablations (retirer chaque composant), pré-enregistrement des hypothèses, et rapporter ce qui n’a pas marché. Les grandes conférences demandent maintenant une « checklist de reproductibilité ». Reproduire un article publié — et publier l’écart trouvé — est un travail de recherche à part entière (ML Reproducibility Challenge), accessible dès la prépa.

02 / Reproduire

Concevoir une expérience qui répond à la question

Élément	Question	Erreur classique
Hypothèse	Que veut-on montrer, précisément ? (« B est plus rapide que A sur des graphes creux de plus de 10⁵ sommets »)	« Voir si ça marche »
Variables	Qu’est-ce qui change (indépendante), qu’est-ce qu’on mesure (dépendante), qu’est-ce qu’on fixe (contrôlée) ?	Changer deux choses à la fois
Baseline	À quoi compare-t-on ? Est-elle réglée aussi bien que la méthode ?	Baseline bâclée
Métrique	Mesure-t-elle vraiment ce qui compte ? (exactitude vs F1, module L13 ; temps CPU vs temps mur)	Optimiser la métrique et pas le but
Variance	Combien de répétitions ? Barres d’erreur ? Test ?	Un seul essai, une seule graine
Ablation	Que se passe-t-il sans chaque composant ?	Attribuer le gain au mauvais composant
Échelle	Le résultat tient-il à 10×, 100× la taille ?	Conclure d’un jouet
Journal	Chaque expérience horodatée, avec code, config, résultat (même raté)	« Je crois que c’était avec lr = 0.01 »

Outils : un dépôt Git (L06) par projet, un fichier de configuration par expérience, un script qui lance tout et produit les figures, un cahier de laboratoire (Markdown suffit). La reproductibilité commence par la vôtre : pouvoir refaire vos propres résultats dans six mois.

03 / Questions ouvertes

Informatique fondamentale : ce qu’on ne sait pas

P vs NP et ses cousins (NP vs coNP, P vs PSPACE, dérandomisation P = BPP ?) : module L23. Les barrières connues (relativisation, preuves naturelles, algébrisation) expliquent pourquoi les techniques actuelles ne suffisent pas.
Bornes inférieures : on ne sait même pas prouver qu’un problème naturel de NP exige un circuit super-linéaire. La complexité algébrique (le problème VP vs VNP, la conjecture de Valiant) est une voie active.
Multiplication de matrices : ω est entre 2 et 2,371… ; peut-on atteindre 2 ? Conséquences pour toute l’algèbre linéaire (L10).
Isomorphisme de graphes : quasi-polynomial (Babai 2015) ; polynomial ?
Algorithmes de flots et plus courts chemins : en 2022, flot maximal en temps presque linéaire (Chen et al.) — révolution théorique, pas encore pratique. Le rendre pratique est ouvert.
Cryptographie post-quantique : les réseaux euclidiens (Kyber, Dilithium) sont-ils vraiment durs ? Existe-t-il une fonction à sens unique (⇔ P ≠ NP en un sens) ?
Vérification et langages : rendre la preuve de programmes (L09) aussi courante que les tests ; types dépendants utilisables ; Rust a montré que la sûreté mémoire sans ramasse-miettes est possible — que peut-on garantir d’autre statiquement ?
Systèmes : programmer des millions de cœurs, tolérer les pannes, consommer moins — les limites physiques (fin de la loi de Moore, chaleur) remettent l’algorithmique et l’architecture au centre.

03 / Questions ouvertes

Intelligence artificielle : les questions derrière les démonstrations

Pourquoi le deep learning généralise-t-il ? Des réseaux avec plus de paramètres que de données devraient sur-apprendre (L13) ; ils ne le font pas toujours (double descente, régularisation implicite du SGD). La théorie classique (VC, Rademacher) ne l’explique pas.
Lois d’échelle et émergence : jusqu’où ? Quelles capacités apparaissent, lesquelles n’apparaîtront jamais par simple échelle ? Le raisonnement multi-étapes fiable, la planification, l’arithmétique exacte restent fragiles (L15).
Interprétabilité mécanistique : que calculent les circuits internes d’un transformeur ? Peut-on lire, éditer, garantir un comportement ? Domaine jeune, résultats partiels (têtes d’induction, caractéristiques superposées).
Alignement et sûreté : comment spécifier ce qu’on veut (L16 : le piratage de récompense est la règle, pas l’exception), vérifier qu’un système le fait, garder le contrôle de systèmes plus compétents que nous dans certains domaines ? Questions techniques ouvertes (récompense apprise, supervision scalable, évaluations) et questions de société.
Données et efficacité : les humains apprennent avec 10⁴ fois moins de données. Apprentissage auto-supervisé, modèles du monde, curiosité, apprentissage continu sans oubli catastrophique.
Raisonnement neuro-symbolique (L17) : combiner apprentissage et logique avec des garanties.
Modèles du monde et agents incarnés : un modèle qui prédit les conséquences physiques de ses actions (le lien avec la robotique).

03 / Questions ouvertes

Robotique et systèmes embarqués : ce qui manque pour un robot vraiment autonome

Manipulation générale : saisir n’importe quel objet dans n’importe quelle cuisine. Les politiques apprises (L16, RT-2, π0) progressent vite ; la fiabilité à 99,99 % et la généralisation hors distribution manquent. Le « moment ImageNet » de la robotique est-il l’échelle des données de démonstration ?
Sim-to-real : la simulation de contacts, de tissus, de liquides reste imprécise ; les simulateurs différentiables et les modèles appris de la physique sont des pistes.
Perception long terme (L19, L20) : cartes qui vivent des mois, scènes dynamiques, sémantique ouverte.
Sûreté vérifiable (L09, L21) : prouver qu’un système avec un réseau de neurones dans la boucle reste dans un ensemble sûr ; vérification de réseaux, fonctions barrières apprises, atteignabilité. Central pour les voitures et les drones.
Locomotion et dextérité : les quadrupèdes marchent partout ; les mains humanoïdes restent maladroites ; l’humanoïde utile est-il proche ? (débat vif, gros investissements).
Interaction humain-robot : intentions, langage (L15), confiance, normes sociales.
Embarqué (L18) : IA à 1 mW (TinyML), puces neuromorphiques, temps réel garanti avec des accélérateurs, sécurité des mises à jour de flottes.
Multi-robots et essaims : coordination décentralisée, communication intermittente, garanties collectives.

Chacun de ces points est un domaine avec des laboratoires, des conférences et des thèses. Un lycéen curieux peut aujourd’hui reproduire un résultat de robotique apprise sur un bras à 200 € — c’est nouveau.

04 / Faire

Votre premier projet de recherche : cadrer, exécuter, écrire

# Une grille pour choisir et cadrer un sujet (TIPE, projet de fin d'année, stage). Notez chaque critère de 1 à 5.
sujets = {
 "SLAM 2D par graphe sur robot lidar à 100 € vs slam_toolbox": dict(interet=5, faisable_6_mois=4, materiel=4, mesurable=5, nouveau=2),
 "Régulateur LQR vs PID vs RL sur pendule inversé réel, comparaison robustesse": dict(interet=4, faisable_6_mois=5, materiel=4, mesurable=5, nouveau=3),
 "Détection d'obstacles par CNN quantifié sur microcontrôleur (TinyML)": dict(interet=5, faisable_6_mois=3, materiel=5, mesurable=4, nouveau=3),
 "Reproduire un article de RL (PPO) et étudier la sensibilité aux graines": dict(interet=3, faisable_6_mois=5, materiel=5, mesurable=5, nouveau=3),
 "Vérification formelle (Lean) d'un algorithme de tri et d'un contrôleur simple": dict(interet=4, faisable_6_mois=3, materiel=5, mesurable=3, nouveau=3),
 "Solveur SAT maison (CDCL) : mesurer l'effet de chaque heuristique sur les instances du SAT Competition": dict(interet=4, faisable_6_mois=4, materiel=5, mesurable=5, nouveau=2),
 "Construire une IA générale": dict(interet=5, faisable_6_mois=1, materiel=1, mesurable=1, nouveau=5),
}
poids = dict(interet=1.0, faisable_6_mois=2.0, materiel=1.0, mesurable=1.5, nouveau=0.5)     # la faisabilité compte double
for s, c in sorted(sujets.items(), key=lambda kv: -sum(poids[k] * v for k, v in kv[1].items())):
    print(f"{sum(poids[k] * v for k, v in c.items()):5.1f}  {s}")
print("\nUn bon premier sujet : question précise, mesurable, faisable en 6 mois, un peu de nouveauté. La nouveauté vient après.")

Le déroulé d’un projet de 6 mois

Semaines 1-3 : lire 10 articles (trois passes pour 3 d’entre eux), écrire une page : question, état de l’art, plan, ce qui serait un succès et un échec.
Semaines 4-8 : reproduire la baseline. C’est souvent la moitié du travail, et c’est là qu’on apprend le plus.
Semaines 9-16 : implémenter sa contribution, expérimenter, itérer. Tenir le journal. Montrer ses résultats intermédiaires à quelqu’un chaque semaine.
Semaines 17-20 : expériences finales (plusieurs graines, ablations), figures.
Semaines 21-24 : écrire (structure d’un article : 6-10 pages), présenter (10 minutes, 8 diapositives), publier le code.

Encadrement : un professeur, un doctorant contacté par courriel (les chercheurs répondent aux lycéens motivés qui ont lu leurs articles), les concours (Olympiades d’informatique, Prologin, Concours Général, RoboCup Junior, TIPE en prépa).

04 / Faire

Écrire et présenter : la contribution en une phrase, puis tout le reste

Partie	Longueur	Conseil
Titre	10 mots	Dit la contribution, pas le sujet (« X réduit Y de 40 % sur Z »).
Résumé	150-250 mots	Contexte (1 phrase), problème (1), méthode (2), résultat chiffré (1), conséquence (1).
Introduction	1 page	Termine par une liste explicite des contributions.
Figures	Une par idée	Un lecteur pressé ne lit que les figures et leurs légendes : elles doivent se suffire.
Résultats	Tableaux + barres d’erreur	Gras pour le meilleur ; nombre de graines ; test statistique si l’écart est petit.
Limites	Un paragraphe honnête	Ce qui ne marche pas, ce que vous n’avez pas testé. Les relecteurs le trouveront de toute façon.
Présentation	1 diapo/minute	Première diapo : le problème et pourquoi c’est dur. Deuxième : votre résultat principal. Le reste : comment.

Règle de Feynman : si vous ne pouvez pas l’expliquer simplement, vous ne le comprenez pas encore. Écrire est une méthode de recherche, pas un compte rendu : c’est en rédigeant qu’on découvre les trous du raisonnement.

05 / Le chemin

Du lycée à la recherche : les parcours

Étape	Options	Ce qui compte
Lycée (1re-Tle)	Spé maths + NSI ou physique ; maths expertes ; Olympiades (OFM, OFI/Prologin), Concours Général	Bases solides en maths ; un projet personnel abouti (dépôt GitHub, robot, article de vulgarisation)
Prépa (2 ans)	MP2I → MPI (informatique approfondie : C, OCaml, algorithmique, preuves, automates — exactement ce parcours) ; MPSI → MP option info ; PCSI → PSI (SI, contrôle) ; PTSI	Rigueur, vitesse, endurance ; le TIPE est votre premier projet de recherche
Concours	X (polytechnique), ENS (Ulm, Lyon, Paris-Saclay, Rennes : voie recherche), Centrale-Supélec, Mines-Ponts, Télécom, ENSTA, ISAE, ENSEA…	ENS pour la recherche fondamentale ; X pour ingénieur-chercheur ; les écoles d’ingénieurs ont toutes des parcours recherche
Université	Licence maths-info (double licence), CMI, magistère ; Licence → Master → thèse ; ENS via le concours ou l’admission sur dossier	Plus de liberté, plus tôt au contact de la recherche ; excellent pour l’informatique fondamentale et l’IA
Master (bac+5)	MVA (Paris-Saclay, IA), MPRI (Paris, informatique fondamentale), Masters robotique (Sorbonne, Toulouse, Lyon), ETH/EPFL, MIT, Stanford, Berkeley, CMU (robotique)	Le master recherche est la porte de la thèse ; les stages de M1/M2 en laboratoire sont décisifs
Thèse (3 ans)	Laboratoires CNRS/Inria/universités ; thèses CIFRE en entreprise ; laboratoires industriels (DeepMind, FAIR, Anthropic, Boston Dynamics…)	Devenir l’expert mondial d’une question précise ; publier ; enseigner

Ce parcours Lycée → Prépa couvre l’essentiel des programmes de MP2I/MPI en informatique, une bonne part d’un L3 d’informatique, et les fondations des masters d’IA et de robotique. Tout ce qui a été fait ici « dans la page » se refait sur PC avec les vrais outils — c’est la prochaine étape.

05 / Le chemin

Éthique, ouverture, et ce que la recherche doit à la société

Intégrité : ne pas fabriquer, ne pas embellir, citer ses sources, rapporter les échecs. La réputation d’un chercheur est son seul capital.
Ouverture : code, données, articles en accès libre (arXiv, HAL). La science fermée est plus lente et moins fiable. Les logiciels libres qui ont servi dans ce cours (Python, NumPy, ROS, FreeRTOS, OCaml, Git) sont le produit de cette culture — contribuez-y.
Usages : la même vision par ordinateur sert au robot agricole et à la surveillance ; le même RL au traitement du plasma et aux systèmes d’armes. Un chercheur choisit ses sujets et ses financements en connaissance de cause, et parle des conséquences de son travail.
IA et société : biais des données, emplois, concentration du calcul, énergie, désinformation, sûreté des systèmes très capables. Ce sont des problèmes techniques et politiques ; ceux qui comprennent la technique doivent participer au débat.
Diversité : les meilleures équipes mélangent disciplines, origines et façons de penser. L’informatique et la robotique en manquent encore ; vous pouvez y changer quelque chose.

La recherche est un métier de doute méthodique et d’honnêteté radicale, au service de la connaissance de tous. C’est exigeant et c’est l’une des plus belles façons de passer une vie.

Cours

Cours 1 — La méthode expérimentale en informatique : ce qui distingue une mesure d’une anecdote

Question	Mauvaise pratique	Bonne pratique
Combien d’exécutions ?	Une seule, la meilleure	≥ 5 graines aléatoires ; rapporter moyenne et écart-type (ou intervalle de confiance)
Contre quoi comparer ?	Une baseline mal réglée	Une baseline réglée avec le même budget d’hyperparamètres que la méthode
Sur quelles données ?	Le jeu de test consulté pendant le développement	Train / validation / test ; le test est ouvert une fois
Quelle métrique ?	Celle qui avantage la méthode	Les métriques standard du domaine, fixées avant l’expérience
Quelle ablation ?	Aucune	Retirer chaque composant un à un : lequel explique le gain ?
Reproductible ?	« Contactez l’auteur »	Code, graines, versions, commande exacte, données ou script de téléchargement

La statistique minimale. Deux moyennes m_A, m_B sur n exécutions, d’écarts-types s_A, s_B : l’écart est « probablement réel » si |m_A − m_B| dépasse nettement √(s_A²/n + s_B²/n) × 2 (test de Welch approximatif, L11). Sinon, il faut plus d’exécutions — ou reconnaître que les deux méthodes sont équivalentes, ce qui est aussi un résultat.

import numpy as np
rng = np.random.default_rng(7)
def welch(a, b):
    a, b = np.asarray(a, float), np.asarray(b, float)
    se = np.sqrt(a.var(ddof=1) / len(a) + b.var(ddof=1) / len(b)); return (a.mean() - b.mean()) / se
# Deux méthodes réellement égales (moyenne 72 %, bruit 1,5 point) : avec UNE exécution, une "amélioration" de 3 points arrive souvent
gagne_3pts = np.mean([abs(rng.normal(72, 1.5) - rng.normal(72, 1.5)) >= 3 for _ in range(10000)])
print(f"deux méthodes identiques, une exécution chacune : écart ≥ 3 points dans {100 * gagne_3pts:.0f} % des cas")
# Avec 5 graines : le t de Welch
for n in (1, 3, 5, 10):
    if n == 1: continue
    faux_positifs = np.mean([abs(welch(rng.normal(72, 1.5, n), rng.normal(72, 1.5, n))) > 2.5 for _ in range(3000)])
    vrais_positifs = np.mean([welch(rng.normal(73.5, 1.5, n), rng.normal(72, 1.5, n)) > 2.5 for _ in range(3000)])
    print(f"n = {n:2d} graines : faux positifs {100 * faux_positifs:4.1f} %, détection d'un vrai gain de 1,5 pt {100 * vrais_positifs:4.1f} %")

Cours

Cours 2 — Exemple travaillé : un cahier d’expériences reproductible de bout en bout

Le squelette ci-dessous est celui de tout projet de recherche sérieux, et il tient en 40 lignes : une configuration (dict, sauvegardée avec les résultats), une fonction run(config, graine) pure, un journal des résultats (JSON lignes), et un tableau agrégé produit par un script — jamais à la main. Ici, l’« expérience » compare deux stratégies d’exploration sur un bandit à 10 bras (L16).

import numpy as np, json, time
def run(config, graine):
    rng = np.random.default_rng(graine); mu = rng.normal(0, 1, 10); Q = np.zeros(10); N = np.zeros(10); regret = 0.0
    for t in range(1, config["pas"] + 1):
        if config["methode"] == "epsilon": a = rng.integers(10) if rng.random() < config["eps"] else int(np.argmax(Q))
        else: a = int(np.argmax(Q + config["c"] * np.sqrt(np.log(t) / (N + 1e-9))))
        r = rng.normal(mu[a], 1); N[a] += 1; Q[a] += (r - Q[a]) / N[a]; regret += mu.max() - mu[a]
    return {"regret": regret}
journal = []                                                    # sur disque : une ligne JSON par exécution (open("resultats.jsonl", "a"))
configs = [{"methode": "epsilon", "eps": 0.1, "pas": 2000}, {"methode": "epsilon", "eps": 0.01, "pas": 2000}, {"methode": "ucb", "c": 1.0, "pas": 2000}, {"methode": "ucb", "c": 2.0, "pas": 2000}]
t0 = time.time()
for cfg in configs:
    for graine in range(5):
        res = run(cfg, graine); journal.append({"config": cfg, "graine": graine, **res})
print(f"{len(journal)} exécutions en {time.time() - t0:.1f} s ; exemple de ligne :", json.dumps(journal[0]))
# Le tableau est GÉNÉRÉ, avec moyenne ± écart-type — c'est lui qui va dans le rapport
print(f"\n{'configuration':32s} {'regret (5 graines)':>22s}")
for cfg in configs:
    r = np.array([l["regret"] for l in journal if l["config"] == cfg])
    print(f"{json.dumps(cfg):32s} {r.mean():10.1f} ± {r.std(ddof=1):5.1f}")

Chaque nombre du tableau est traçable : configuration exacte + graine → résultat. Si un lecteur relance le script, il obtient les mêmes lignes. C’est le sens précis de « reproductible ».

Cours

Cours 3 — Lire, écrire, évaluer : le cycle de la recherche et vos outils

Étape	Outils	Bonne habitude
Veille	arXiv (cs.RO, cs.LG, cs.AI, cs.DS), Google Scholar (alertes), Semantic Scholar, Papers with Code	Une heure par semaine ; un fichier de notes par article : contribution, méthode, résultat clé, limites, idée que ça me donne
Bibliographie	Zotero + BibTeX	Citer la version publiée (conférence/journal) plutôt que l’arXiv quand elle existe
Rédaction	LaTeX (Overleaf), modèle de la conférence visée	Écrire le résumé et les figures d’abord ; chaque figure a une phrase qui dit ce qu’on doit y voir
Code	Git, README avec la commande de reproduction, licence (MIT/Apache/BSD)	Un tag Git = une version de l’article
Évaluation par les pairs	OpenReview (lire des relectures publiques d’ICLR)	Se relire comme un relecteur : « quelle est la contribution ? est-elle prouvée ? »
Diffusion	Conférences (NeurIPS, ICML, ICLR, CoRL, ICRA, IROS, RSS ; STOC, FOCS, SODA ; PLDI, POPL), journaux (JMLR, IJRR, T-RO), ateliers pour un premier pas	Un atelier de conférence accepte volontiers un travail préliminaire solide

Structure canonique d’un article (8 pages) : Résumé (150 mots : problème, méthode, résultat chiffré) · Introduction (contexte, question, contribution en liste) · Travaux connexes · Méthode · Expériences (protocole, tableaux, ablations) · Limites · Conclusion. Le lecteur doit pouvoir s’arrêter après chaque section et avoir compris quelque chose de complet.

# Un outil de veille minimal : construire une requête arXiv et parser la réponse (Atom XML). Hors ligne ici, on montre le parsing sur un extrait.
import re, xml.etree.ElementTree as ET
requete = "http://export.arxiv.org/api/query?search_query=cat:cs.RO+AND+all:%22loop+closure%22&sortBy=submittedDate&max_results=5"
print("URL à ouvrir (ou urllib.request.urlopen sur PC) :", requete)
extrait = """<feed xmlns="http://www.w3.org/2005/Atom"><entry><title>Robust Loop Closure for Lidar SLAM</title><published>2026-06-02T00:00:00Z</published><author><name>A. Dupont</name></author><author><name>B. Nguyen</name></author><summary>We propose ... 12% fewer false positives.</summary></entry>
<entry><title>Learning Place Recognition from Range Images</title><published>2026-05-28T00:00:00Z</published><author><name>C. Ali</name></author><summary>A transformer over range images ...</summary></entry></feed>"""
ns = {"a": "http://www.w3.org/2005/Atom"}
for e in ET.fromstring(extrait).findall("a:entry", ns):
    auteurs = ", ".join(x.text for x in e.findall("a:author/a:name", ns))
    print(f"- {e.find('a:published', ns).text[:10]}  {e.find('a:title', ns).text}  ({auteurs})")

TP guidé

TP — Reproduire un article, puis en écrire un (sur PC, 2 à 4 semaines)

Choisir l’article. Un article de 4 à 8 pages avec code public et expérience faisable sur votre machine en moins d’une heure. Suggestions : « Playing Atari with Deep RL » sur CartPole (DQN, L16), « Gaussian Process / ICP variants » sur un nuage 2D (L20), une heuristique pour SAT ou TSP (L17), un algorithme de tri ou de hachage récent avec ses benchmarks (L03). Lisez-le en trois passes et remplissez le carnet du cours.
Environnement figé. python -m venv .venv, pip install …, pip freeze > requirements.txt, ou un Dockerfile. Notez la version de Python, du système, du GPU s’il y en a un. Un tag Git v0-setup.
Réimplémenter avant de lire le code. Depuis le texte seulement, écrivez la méthode (Cours 2 comme squelette). Puis comparez avec le code des auteurs : les écarts (détails omis de l’article, astuces non documentées) sont votre première trouvaille — notez-les tous.
Reproduire le tableau principal. 5 graines, moyenne ± écart-type, même métrique. Trois issues possibles, toutes publiables : (a) reproduit ; (b) reproduit partiellement (dites où) ; (c) non reproduit (dites pourquoi, avec preuves). Ajoutez une ablation ou une condition que l’article n’a pas testée.
Écrire. Un rapport de reproduction de 4 pages en LaTeX au format d’une conférence (modèle NeurIPS ou ICRA) : résumé, méthode telle que comprise, protocole, tableau, écarts constatés, limites. Une figure par idée. Faites relire par deux personnes qui ne connaissent pas le sujet : là où elles butent, réécrivez.
Diffuser. Dépôt public avec README de reproduction en une commande, rapport PDF, et — si le résultat est solide — soumettez à un atelier, à la ML Reproducibility Challenge, ou au concours TIPE. Envoyez un courriel court et précis aux auteurs : ils répondent plus souvent qu’on ne croit.
Livrable. Dépôt + rapport + une page « ce que j’ai appris que l’article ne disait pas ».

Exercices

Exercices auto-corrigés — juger une expérience

Exercice 1 — Combien de graines pour conclure ?

Écrivez graines_necessaires(delta, sigma, seuil=2.5, essais=500, rng=None) : la plus petite valeur n ∈ {2, 3, …, 60} telle que, pour deux méthodes d’écart réel delta et de bruit sigma, le t de Welch dépasse seuil dans au moins 80 % des tirages (« puissance » de 0,8). Pour aller vite, tirez les essais expériences d’un coup (tableaux de forme (essais, n)) et calculez le t de Welch vectorisé.

Correction

def graines_necessaires(delta, sigma, seuil=2.5, essais=500, rng=None):
    rng = rng or np.random.default_rng(0)
    for n in range(2, 61):
        a = rng.normal(delta, sigma, (essais, n)); b = rng.normal(0, sigma, (essais, n))
        se = np.sqrt(a.var(axis=1, ddof=1) / n + b.var(axis=1, ddof=1) / n)
        t = (a.mean(axis=1) - b.mean(axis=1)) / se
        if np.mean(t > seuil) >= 0.8: return n
    return 60

Un gain de 3 points sur un bruit de 1,5 se voit en une poignée de graines ; un gain de 1,5 point (une fois le bruit) en demande une vingtaine ; un gain d’un tiers du bruit en demande plus de 45 — au-delà de ce que la plupart des articles rapportent. Voilà pourquoi tant de « +0,5 % » ne se reproduisent pas.

Exercice 2 — Détecter la fuite du jeu de test

Un cahier d’expériences sélectionne, parmi 200 configurations aléatoires, celle qui maximise l’exactitude sur le jeu de test. Simulez : 200 « modèles » dont la vraie exactitude est identique (70 %), chacun évalué sur un test de 500 exemples (binomial). Écrivez meilleure_apparente(rng) qui renvoie l’exactitude du meilleur des 200, et vraie_exactitude(rng) qui renvoie l’exactitude du même modèle sur un nouveau test de 500 exemples. Montrez la fuite : la première dépasse 74 % en moyenne, la seconde reste ≈ 70 %.

Correction

def meilleure_apparente(rng): return rng.binomial(500, 0.70, size=200).max() / 500
def vraie_exactitude(rng): return rng.binomial(500, 0.70) / 500     # le "meilleur" modèle n'est pas meilleur : sur un test neuf, il retombe à 70 %

Le maximum de 200 variables binomiales est biaisé vers le haut de plusieurs points : c’est exactement l’« optimisation sur le jeu de test ». D’où la règle : validation pour choisir, test une seule fois pour rapporter.

Exercices

Exercices auto-corrigés — outiller son travail

Exercice 3 — Un journal d’expériences interrogeable

Écrivez agreger(journal, cles) qui regroupe les lignes du journal (Cours 2) par les clés de configuration données (ex. ["methode"] ou ["methode", "eps"]) et renvoie un dict {tuple des valeurs: (moyenne, écart-type, nombre)} du regret. Les clés absentes d’une config valent None.

Correction

def agreger(journal, cles):
    groupes = {}
    for l in journal: groupes.setdefault(tuple(l["config"].get(k) for k in cles), []).append(l["regret"])
    return {k: (float(np.mean(v)), float(np.std(v, ddof=1)) if len(v) > 1 else 0.0, len(v)) for k, v in groupes.items()}

Exercice 4 — Extraire une bibliographie

Écrivez bibtex_vers_dict(texte) qui lit des entrées BibTeX simples (@type{clé, champ = {valeur}, …}) et renvoie {clé: {"type": …, champs…}}, puis citer(entree) qui produit « Nom1, Nom2 (année). Titre. » avec les noms de famille (les auteurs sont séparés par « and », chaque auteur écrit « Prénom Nom »).

Correction

def bibtex_vers_dict(texte):
    d = {}
    for m in re.finditer(r"@(\w+)\{([^,]+),(.*?)\n\}", texte, re.S):
        champs = dict(re.findall(r"(\w+)\s*=\s*\{([^}]*)\}", m.group(3)))
        d[m.group(2).strip()] = {"type": m.group(1), **champs}
    return d
def citer(e):
    noms = [a.strip().split()[-1] for a in e["author"].split(" and ")]
    return f"{', '.join(noms)} ({e['year']}). {e['title']}."

06 / Défis

Défi ★ — Trois passes sur un article

Consigne

Choisissez l’un de ces articles (tous gratuits) : « Playing Atari with Deep Reinforcement Learning » (Mnih 2013), « Fast Marching Trees » (Janson 2015, planification), « Learning to Walk in Minutes Using Massively Parallel Deep RL » (Rudin 2021), « The Case for Learned Index Structures » (Kraska 2018), « Deep Residual Learning » (He 2015). Faites les trois passes et rendez : contribution en 3 phrases, 3 questions de relecteur avec vos réponses, 1 expérience de 20 lignes qui teste une affirmation de l’article, 5 références à lire ensuite.

06 / Défis

Défi ★★ — Reproduction complète

Consigne

Reproduisez un résultat quantitatif d’un article avec code public (un tableau, une figure) : par exemple l’exactitude d’un petit CNN sur CIFAR-10, ou la courbe d’apprentissage de PPO sur CartPole/LunarLander (Stable-Baselines3), ou un temps d’exécution d’un algorithme de graphe. Rendez un rapport de 4 pages : ce que dit l’article, ce que vous avez obtenu (5 graines, barres d’erreur), les écarts et leurs causes possibles, ce qu’il aurait fallu pour reproduire exactement. Publiez le dépôt.

06 / Défis

Défi ★★★ — Esprit prépa : votre TIPE, ou votre premier article

Consigne

Cadrez, exécutez et écrivez un projet de recherche de 6 mois avec la grille de ce module. Livrables : (1) une page de cadrage à la semaine 3 ; (2) un dépôt avec baseline reproduite à la semaine 8 ; (3) un rapport de 8 pages au format d’une conférence (résumé, introduction avec contributions, méthode, expériences avec ablations et barres d’erreur, limites, références) ; (4) une présentation de 10 minutes ; (5) le code et les données. Faites relire par deux personnes qui ne connaissent pas le sujet et une qui le connaît. Puis : soumettez à un concours (TIPE, Concours Général, Olympiades), envoyez-le à un chercheur du domaine, ou postez-le sur arXiv si un encadrant le juge mûr.

Quelques sujets qui marchent bien à ce niveau

Comparaison rigoureuse de contrôleurs (PID, LQR, MPC, RL) sur un système physique bon marché, avec identification du modèle.
SLAM ou localisation sur robot lidar, comparé aux implémentations ROS.
Un solveur (SAT, CSP, TSP) avec étude expérimentale des heuristiques sur des instances standard.
TinyML : détection sonore ou visuelle sur microcontrôleur, mesure énergie/latence/exactitude.
Étude de reproductibilité d’un résultat d’IA récent.
Vérification formelle d’un petit composant critique (tampon circulaire, protocole) en Lean/Coq/Why3.
Un simulateur physique différentiable et son usage pour l’optimisation de trajectoires.

07 / Vérification

Vous obtenez 74,2 % avec votre méthode contre 71,8 % pour la baseline, en une exécution chacune. Que concluez-vous ?

Deux questions supplémentaires

1. Qu’est-ce qu’une ablation ? Retirer un composant de la méthode et mesurer : elle montre quels composants expliquent le gain.

2. Pourquoi reproduire avant d’innover ? Parce que la baseline est le point de référence ; si elle est mal reproduite, aucun gain n’est interprétable — et parce que c’est là qu’on comprend vraiment la méthode.

Référence

Les mots à retenir

Mot	Définition
Contribution	Ce que l’article apporte de nouveau, en trois phrases.
Trois passes	Survol, lecture, reconstruction.
Baseline	Méthode de référence, à régler aussi bien que la sienne.
Ablation	Retirer un composant pour mesurer sa contribution.
Graines / variance	Répéter pour distinguer effet et bruit.
Reproductibilité	Refaire le résultat avec le code, les données et la config publiés.
Pré-enregistrement	Fixer hypothèse et protocole avant de regarder les données.
arXiv / HAL	Archives ouvertes de prépublications.
TIPE	Projet de recherche personnel de la prépa, évalué aux concours.
MP2I / MPI	Filière de prépa à informatique renforcée.
Intégrité	Ne pas fabriquer, ne pas embellir, citer, rapporter les échecs.

Fin du parcours

Vous avez ce qu’il faut. Le reste est du travail — et il est passionnant.

Trente séances de Python et de robotique au collège, vingt-quatre modules du lycée à la prépa : vous savez coder, prouver, calculer, apprendre, percevoir, contrôler, communiquer, et poser des questions que personne n’a résolues. Ce que vous ferez de tout cela ne dépend plus d’un cours.

Pour continuer, maintenant

Refaire sur PC, avec les vrais outils, chaque module de ce parcours : un dépôt Git par module, tests, README.
Construire un robot complet (séances 27-30 + modules L18-L22) et le documenter comme un projet de recherche.
Lire un article par semaine, en trois passes, et tenir un carnet.
Rejoindre une communauté : club de robotique, Olympiades, un laboratoire ouvert, un projet libre.
Une question ? La pastille WhatsApp reste là.

← L23 Sommaire Lycée → Prépa Partie K : ingénierie de l'IA →