Le cours introduit environ deux cents termes, chacun à l'endroit où il devient utile. Cette annexe les rassemble : une définition courte, et le module où la notion est développée. Elle sert à deux choses — retrouver une définition croisée trois modules plus loin, et vérifier avant d'attaquer un module qu'on possède bien le vocabulaire qu'il suppose.

Conventions de notation

Le cours suit les conventions usuelles de la littérature statistique et du machine learning. Elles ne sont pas universelles — un article peut noter les vecteurs en gras, un autre non — mais elles sont cohérentes d'un bout à l'autre de ces pages.

DONNÉES
  n            nombre d'observations (lignes)
  p, d         nombre de variables (colonnes), dimension
  X            matrice des variables explicatives, n lignes × p colonnes
  x_i          l'observation i (un vecteur de taille p)
  y            vecteur des valeurs à prédire ;  y_i  une valeur
  ŷ            valeur prédite (le « chapeau » = estimé, pas observé)
  T            indicateur de traitement 0/1 (module 11)

MODÈLE ET APPRENTISSAGE
  θ, w, β      paramètres du modèle (θ en général, w ou β en linéaire)
  θ̂            estimateur de θ à partir de l'échantillon
  f(x; θ)      prédiction du modèle de paramètres θ
  L, ℓ         fonction de perte (L totale, ℓ sur un exemple)
  R(θ)         risque = perte espérée sur la vraie distribution
  R̂(θ)         risque empirique = perte moyenne sur l'échantillon
  η, α         taux d'apprentissage
  λ            force de régularisation
  ∇            gradient ;  ∇_θ L  = gradient de L par rapport à θ

PROBABILITÉS
  P(A)         probabilité de A
  p(x)         densité de probabilité
  E[X]         espérance ;  Var(X)  variance ;  Cov(X,Y)  covariance
  X ~ N(μ, σ²) X suit une loi normale de moyenne μ et variance σ²
  X ⊥⊥ Y | Z   X et Y sont indépendants conditionnellement à Z
  do(X = x)    intervention : on FORCE X à x (module 11)
  ∝            proportionnel à (la constante de normalisation est omise)

ALGÈBRE ET ANALYSE
  ‖v‖₂         norme euclidienne ;  ‖v‖₁  somme des valeurs absolues
  Aᵀ           transposée ;  A⁻¹  inverse ;  tr(A)  trace
  ⟨u, v⟩       produit scalaire
  argmin f     la valeur qui MINIMISE f (pas le minimum lui-même)
  O(n²)        ordre de grandeur du coût quand n grandit

A – C

• A/B test — expérience où les unités sont affectées au hasard à deux variantes, ce qui rend les groupes comparables et autorise une conclusion causale (module 9).
• ACF, PACF — autocorrélogramme et sa version partielle : les deux graphiques qui révèlent la structure temporelle d'une série et guident le choix d'un modèle ARIMA (module 17).
• Adam — algorithme d'optimisation qui adapte un taux d'apprentissage par paramètre à partir des moments du gradient. Le défaut raisonnable en deep learning (module 8).
• Aléatoire (incertitude) — incertitude irréductible, due au bruit intrinsèque du phénomène. S'oppose à l'incertitude épistémique, qui se réduit avec plus de données (module 10).
• Apprentissage actif — stratégie qui choisit les exemples à faire annoter, plutôt que d'annoter au hasard, pour maximiser le gain par étiquette (module 13).
• Apprentissage auto-supervisé — fabriquer la supervision à partir des données elles-mêmes (masquer un mot, prédire la suite), pour apprendre des représentations sans étiquettes (module 13).
• Arrow — format de représentation d'un tableau colonne en mémoire, partagé entre outils, qui permet de s'échanger des données sans copie. À distinguer de Parquet, qui est un format de disque (module 7).
• ARIMA — modèle classique de série temporelle combinant auto-régression, différenciation et moyenne mobile (module 17).
• ATE, ATT, CATE, LATE — effets moyens d'un traitement : sur toute la population, sur les traités seulement, conditionnellement à un profil, ou sur le sous-groupe qu'un instrument a fait changer de comportement (module 11).
• Attention — mécanisme par lequel chaque élément d'une séquence pondère tous les autres selon leur pertinence. Le cœur du Transformer (module 16).
• AUC / ROC — aire sous la courbe taux de vrais positifs contre taux de faux positifs : la probabilité qu'un positif tiré au hasard reçoive un score supérieur à un négatif (module 8).
• Autoencodeur — réseau qui apprend à reconstruire son entrée à travers un goulot d'étranglement, et dont la couche centrale fournit une représentation compressée (module 16).
• Backfill — rejouer un traitement sur une période passée, par exemple après correction d'un bug. Possible seulement si les tâches sont paramétrées par la date et idempotentes (module 7).
• Bagging — entraîner plusieurs modèles sur des rééchantillonnages des données et moyenner leurs prédictions, pour réduire la variance (module 14).
• Bandit (contextuel) — cadre où l'on choisit une action et n'observe que sa conséquence, ce qui impose d'arbitrer entre explorer et exploiter en continu (module 24).
• Biais (statistique) — écart systématique entre l'espérance d'un estimateur et la vraie valeur. Différent du biais au sens de l'équité (module 27).
• Biais-variance — décomposition de l'erreur d'un modèle en erreur systématique et instabilité. Le cadre qui explique sur- et sous-apprentissage (module 14).
• BF16 — format flottant sur 16 bits conservant la plage d'exposant de FP32 au prix de la précision. Le défaut actuel pour l'entraînement en précision mixte (module 25).
• Boosting — construire des modèles successifs, chacun corrigeant les erreurs des précédents. XGBoost, LightGBM, CatBoost (module 14).
• Bootstrap — rééchantillonner avec remise pour estimer la variabilité d'une statistique sans hypothèse de loi (module 9).
• Broadcasting — règle NumPy qui aligne automatiquement des tableaux de formes différentes lors d'une opération, sans copie explicite (module 3).
• Calibration — propriété d'un modèle dont les probabilités prédites correspondent aux fréquences observées : parmi les cas annoncés à 70 %, environ 70 % se réalisent (module 10).
• Censure — situation où l'on sait qu'un événement n'est pas encore survenu au moment de l'observation, sans connaître sa date future. Le problème central de l'analyse de survie (module 17).
• Clustering — regrouper des observations semblables sans étiquettes : k-moyennes, DBSCAN, mélanges gaussiens (module 14).
• CNN — réseau convolutif, qui exploite la localité et la translation-invariance des images en partageant les mêmes filtres partout (module 16).
• Collisionneur — variable influencée par deux autres. Conditionner dessus crée une corrélation artificielle entre ses causes : la source de biais la plus contre-intuitive (module 9).
• Confondant — variable qui influence à la fois le traitement et le résultat, et qui fabrique une association sans lien causal (module 9).
• Conteneur — unité d'exécution isolée qui partage le noyau de l'hôte, contrairement à une machine virtuelle qui embarque son propre système (module 5).
• Contrat de données — spécification vérifiée automatiquement de ce qu'une table doit contenir : colonnes, types, plages, unicité. Placé à la frontière du système (module 7).
• Cross-fitting — prédire chaque observation avec un modèle entraîné sans elle, pour éliminer le biais de surapprentissage dans une estimation causale (module 11).
• CTE — clause WITH de SQL, qui nomme un résultat intermédiaire et rend une requête complexe lisible (module 4).
• CUPED — technique qui retranche d'une métrique d'expérience la part prédictible par une mesure antérieure, réduisant la variance sans introduire de biais (module 11).

D – I

• DAG — graphe orienté sans cycle. Désigne soit un graphe causal (module 11), soit un graphe de tâches d'orchestration (module 7), soit le graphe de calcul d'un moteur paresseux (module 3).
• Dask — bibliothèque qui découpe un calcul pandas ou NumPy en morceaux traités hors mémoire ou en parallèle (module 3).
• dbt — outil qui traite les transformations SQL comme du code : dépendances déduites, tests, documentation, versionnement (module 7).
• Décorateur — fonction qui prend une fonction et en renvoie une version modifiée. La syntaxe @nom n'est qu'un raccourci de réaffectation (module 1).
• Dérive — évolution dans le temps de la distribution des données (dérive de covariables) ou de la relation apprise (dérive de concept). La première cause de dégradation silencieuse d'un modèle (module 26).
• Descente de gradient — se déplacer pas à pas dans la direction opposée au gradient de la fonction de perte. Le mécanisme d'apprentissage de presque tous les modèles paramétriques (module 8).
• Différences de différences — comparer l'évolution avant/après d'un groupe traité à celle d'un groupe témoin, pour éliminer à la fois les différences de niveau et la tendance commune (module 11).
• Dimension VC — mesure de la capacité d'une famille de modèles : le plus grand nombre de points qu'elle peut séparer de toutes les façons possibles (module 15).
• Double descente — phénomène où l'erreur de test remonte puis redescend quand la capacité du modèle dépasse le nombre d'observations, contredisant la courbe en U classique (module 15).
• Double machine learning — estimer un effet causal en résidualisant résultat et traitement par des modèles de ML, avec découpage croisé (module 11).
• DuckDB — moteur SQL analytique en processus, sans serveur, capable d'interroger directement des fichiers Parquet (module 4).
• Eckart–Young — théorème établissant que tronquer la SVD donne la meilleure approximation de rang donné. Le fondement de la PCA et de la compression (module 8).
• ELT / ETL — charger puis transformer, ou transformer puis charger. Le basculement vers ELT découle de l'effondrement du coût du stockage (module 7).
• Embedding — représentation d'un objet (mot, image, utilisateur) par un vecteur dense où la proximité géométrique traduit une proximité sémantique (module 22).
• Épistémique (incertitude) — incertitude due au manque de données ou de connaissance du modèle. Réductible, contrairement à l'incertitude aléatoire (module 10).
• Erreur type — écart-type d'un estimateur, qui décroît en \(1/\sqrt{n}\). À ne pas confondre avec l'écart-type des individus, qui ne décroît pas (module 9).
• Feature store — service imposant une définition unique des variables, servie à la fois pour l'entraînement et pour la prédiction, afin d'éviter le décalage entre les deux (module 7).
• Filtre de Kalman — estimation récursive de l'état caché d'un système à partir d'observations bruitées (module 17).
• Fonction de fenêtre — en SQL, calcul d'une agrégation sur un sous-ensemble de lignes sans réduire le nombre de lignes renvoyées (module 4).
• Forêt aléatoire — bagging d'arbres de décision, avec tirage aléatoire de variables à chaque nœud pour décorréler les arbres (module 14).
• Fuite de données — présence dans les variables d'une information indisponible au moment de la prédiction réelle. Produit des performances excellentes en validation et nulles en production (module 12).
• Générateur — fonction contenant yield, qui produit ses valeurs une à une sans les stocker. Permet de traiter un flux plus gros que la mémoire (module 1).
• GIL — verrou global de CPython qui empêche deux threads d'exécuter du bytecode Python simultanément. Sans effet sur les attentes d'entrée-sortie et sur le code natif qui le relâche (module 2).
• GNN — réseau de neurones sur graphe, qui construit la représentation d'un nœud en agrégant celles de ses voisins (module 18).
• Gradient boosting — boosting où chaque modèle ajouté approche le gradient de la perte. Le meilleur choix par défaut sur données tabulaires (module 14).
• HNSW — index de recherche approchée de plus proches voisins fondé sur un graphe hiérarchique. La structure derrière la plupart des bases vectorielles (module 22).
• Idempotence — propriété d'un traitement qui, relancé sur la même période, produit le même résultat au lieu de le dupliquer. Ce qui rend un pipeline rejouable (module 7).
• Ignorabilité — hypothèse selon laquelle, à covariables données, l'affectation au traitement est indépendante des résultats potentiels. Invérifiable, et centrale (module 11).
• Index (base de données) — structure auxiliaire accélérant la recherche au prix d'un coût en écriture et en espace (module 4).
• Inférence variationnelle — approcher une loi a posteriori en cherchant, dans une famille simple, la distribution qui s'en rapproche le plus. Plus rapide que MCMC, au prix d'une approximation (module 10).
• Instrument — variable qui influence le traitement sans agir autrement sur le résultat, utilisée pour estimer un effet en présence de confondants non mesurés (module 11).
• IPW — pondération par l'inverse de la probabilité de traitement, qui reconstruit une pseudo-population équilibrée (module 11).
• Itérateur — objet muni de __next__, qui se consomme une fois. À distinguer de l'itérable, qui sait en fournir un nouveau à chaque parcours (module 1).

J – P

• Jinja — moteur de gabarits qui insère des valeurs Python dans un texte à trous. Utilisé pour produire du HTML (module 6) et pour générer du SQL dans dbt (module 7).
• Jointure — opération SQL qui combine deux tables sur une condition. Le piège usuel est la duplication de lignes quand la clé n'est pas unique des deux côtés (module 4).
• Jumeau numérique — modèle d'un système physique, maintenu à jour par ses données de fonctionnement, servant à simuler et à décider (module 21).
• Kafka — journal distribué en écriture seule, partitionné, où les consommateurs avancent à leur rythme et peuvent rejouer l'historique (module 7).
• Kubernetes — orchestrateur déclaratif de conteneurs : on décrit l'état souhaité, le système s'efforce en permanence de l'atteindre (module 5).
• Lac de données — stockage de fichiers bon marché où l'on dépose les données brutes sans schéma imposé. S'oppose à l'entrepôt, structuré et modélisé (module 7).
• Lakehouse — lac de données doté de transactions, d'évolution de schéma et de voyage dans le temps, grâce à un format de table ouvert (Delta, Iceberg) (module 7).
• Learning to rank — apprendre à ordonner une liste plutôt qu'à prédire un score isolé, en optimisant une métrique de position (module 23).
• LoRA, QLoRA — adaptation d'un grand modèle par ajout de matrices de faible rang, en gelant les poids d'origine. QLoRA y ajoute la quantification (module 22).
• LSTM — réseau récurrent muni de portes, conçu pour atténuer la disparition du gradient sur les longues séquences (module 16).
• MAP — estimation du paramètre le plus probable a posteriori. Équivaut au maximum de vraisemblance pénalisé : régulariser, c'est mettre un a priori (module 10).
• MCMC — famille d'algorithmes qui échantillonnent une loi a posteriori par une chaîne de Markov. NUTS en est la variante moderne (module 10).
• Médiateur — variable par laquelle transite l'effet d'un traitement. Conditionner dessus supprime précisément l'effet qu'on cherche à mesurer (module 9).
• Métamodèle — modèle statistique rapide qui remplace une simulation coûteuse, entraîné sur un petit nombre d'exécutions (module 21).
• MLE — maximum de vraisemblance : choisir les paramètres qui rendent les données observées les plus probables (module 10).
• MLflow — outil de suivi d'expériences : paramètres, métriques, artefacts et versions de modèles (module 26).
• Momentum — accumulation d'une moyenne des gradients passés, qui lisse la trajectoire et accélère la descente dans les vallées étroites (module 8).
• Monte-Carlo — estimer une quantité par tirage aléatoire répété. Sa précision décroît en \(1/\sqrt{N}\), indépendamment de la dimension (module 21).
• Normalisation (bases) — organiser un schéma relationnel pour qu'une information ne soit stockée qu'à un seul endroit. S'oppose au schéma en étoile, pensé pour la lecture (module 4).
• Noyau — fonction mesurant une similarité entre deux points, qui permet de travailler implicitement dans un espace de grande dimension. Au cœur des SVM (module 14) et des processus gaussiens (module 19).
• OLTP / OLAP — bases orientées transactions (beaucoup d'écritures courtes) contre bases orientées analyse (peu d'écritures, grosses lectures). Deux architectures opposées (module 4).
• Optimisation bayésienne — optimiser une fonction coûteuse en construisant un modèle probabiliste de ses valeurs et en choisissant le point suivant par une fonction d'acquisition (module 19).
• Orchestrateur — outil qui exécute des tâches selon leurs dépendances, réessaie les échecs et conserve l'historique. Airflow, Dagster, Prefect (module 7).
• PAC — cadre théorique « probablement approximativement correct », qui borne l'écart entre erreur empirique et erreur réelle (module 15).
• Parquet — format de fichier colonne, compressé, typé, doté de statistiques par bloc. Le défaut raisonnable dès qu'un fichier est relu par un programme (module 7).
• PCA — projection sur les directions de variance maximale, obtenue par la SVD des données centrées. Sert à visualiser, compresser et décorréler (module 8).
• PINN — réseau dont la fonction de perte inclut le résidu d'une équation aux dérivées partielles, ce qui contraint la solution par la physique (module 16).
• polars — bibliothèque de manipulation de tableaux fondée sur Arrow, à évaluation paresseuse et parallèle par défaut (module 3).
• Positivité — hypothèse causale exigeant que chaque profil ait une chance non nulle d'être traité et de ne pas l'être. Vérifiable, contrairement à l'ignorabilité (module 11).
• pre-commit — mécanisme exécutant des vérifications automatiques avant chaque commit Git, pour ne jamais versionner du code non formaté (module 1).
• Prédiction conforme — méthode produisant des intervalles de prédiction avec une garantie de couverture valable sans hypothèse sur le modèle ni sur la loi des données (module 10).
• Processus gaussien — loi de probabilité sur des fonctions, qui fournit une prédiction et son incertitude, croissante loin des points observés (module 19).
• Score de propension — probabilité d'être traité compte tenu du profil. Conditionner sur ce seul nombre suffit à rendre les groupes comparables, sous ignorabilité (module 11).
• Pydantic — bibliothèque qui valide et convertit des données d'entrée à partir d'annotations de type, en échouant tôt et avec un message précis (module 6).
• p-value — probabilité d'observer un écart au moins aussi extrême si l'hypothèse nulle était vraie. Ce n'est pas la probabilité que l'hypothèse soit vraie (module 9).

Q – Z

• Q-learning — apprentissage de la valeur de chaque couple état-action par mise à jour itérative, sans modèle de l'environnement (module 20).
• Quantification — représenter les poids d'un modèle sur moins de bits (8 ou 4) pour réduire mémoire et latence, au prix d'une légère perte de qualité (module 22).
• Quasi-Monte-Carlo — remplacer les tirages aléatoires par une suite à faible discrépance, qui couvre l'espace plus régulièrement et converge plus vite (module 21).
• RAG — répondre en récupérant d'abord des documents pertinents, puis en les fournissant au modèle de langage comme contexte (module 22).
• Randomisation — affecter le traitement au hasard, ce qui élimine d'un coup tous les confondants, y compris ceux qu'on n'a pas mesurés (module 11).
• Régression sur discontinuité — exploiter un seuil administratif comme quasi-expérience : les individus juste en dessous et juste au-dessus sont comparables (module 11).
• Régularisation — pénaliser la complexité d'un modèle pour réduire sa variance. Ridge pénalise la norme au carré, Lasso la norme absolue et annule des coefficients (module 14).
• Rétropropagation — application de la règle de dérivation en chaîne qui calcule tous les gradients d'un réseau en un seul parcours arrière (module 16).
• Roofline — diagramme opposant intensité arithmétique et performance atteignable, qui indique si un calcul est limité par le calcul ou par la mémoire (module 25).
• ruff — formateur et analyseur statique Python, très rapide, qui remplace plusieurs outils historiques (module 1).
• Schéma en étoile — table de faits centrale entourée de tables de dimensions, organisation dénormalisée pensée pour minimiser les jointures à la lecture (module 7).
• SCD — dimension à évolution lente : trois stratégies (écraser, historiser par ligne, garder la valeur précédente) pour gérer un attribut qui change dans le temps (module 7).
• SGD — descente de gradient stochastique : estimer le gradient sur un petit lot plutôt que sur toutes les données. Son bruit joue un rôle régularisant (module 8).
• SHAP — attribution de la prédiction d'un modèle à ses variables, fondée sur les valeurs de Shapley. Explique la prédiction, pas la causalité (module 14).
• Simpson (paradoxe de) — inversion d'une conclusion entre les sous-groupes et l'agrégat, due à un confondant (module 9).
• slots — option de classe qui remplace le dictionnaire d'attributs par des emplacements fixes : moins de mémoire, accès plus rapide, pas d'attribut ajouté à la volée (module 1).
• Stationnarité — propriété d'une série dont les caractéristiques statistiques ne dépendent pas du temps. Condition d'application des modèles ARIMA (module 17).
• Streaming — traiter chaque événement à mesure qu'il arrive, plutôt que par lots périodiques. Justifié seulement quand la fraîcheur a une valeur mesurable (module 7).
• SUTVA — hypothèse causale d'absence d'interférence entre unités et d'unicité de la version du traitement. Violée par les effets de réseau (module 11).
• SVD — décomposition d'une matrice en rotation, dilatation, rotation. Le résultat d'algèbre linéaire le plus utile en data science (module 8).
• SVM — classifieur cherchant l'hyperplan de marge maximale, étendu aux frontières non linéaires par l'astuce du noyau (module 14).
• TF-IDF — pondération d'un terme par sa fréquence dans un document et sa rareté dans le corpus. Toujours une baseline solide en recherche textuelle (module 18).
• Transaction ACID — garanties d'atomicité, cohérence, isolation et durabilité d'une base de données (module 4).
• Transfert (apprentissage par) — réutiliser un modèle pré-entraîné sur une grande base et l'adapter à une tâche voisine avec peu d'exemples (module 13).
• Transformer — architecture fondée sur l'attention, qui traite une séquence entière en parallèle plutôt que pas à pas (module 16).
• Uplift — effet individuel d'une action, qui permet de cibler ceux qu'elle fait basculer plutôt que ceux qui auraient agi de toute façon (module 24).
• UTC — référence temporelle sans fuseau ni heure d'été. La seule forme non ambiguë de stockage d'un instant (module 7).
• UV — gestionnaire d'environnements et de dépendances Python, rapide, avec fichier de verrouillage reproductible (module 1).
• Valeur E — force minimale qu'un confondant non mesuré devrait avoir pour annuler un effet observé. Mesure la fragilité d'une conclusion causale (module 11).
• Validation croisée — découper les données en plis, entraîner sur les uns, évaluer sur l'autre, et faire tourner. Le schéma doit respecter la structure des données : temporelle, groupée, stratifiée (module 12).
• Vraisemblance — probabilité des données observées vue comme fonction des paramètres. Le pont entre modélisation probabiliste et optimisation (module 10).
• Vue et copie — en NumPy, une tranche partage la mémoire d'origine (vue) tandis qu'une indexation par masque la duplique (copie). Source classique de modifications inattendues (module 3).
• XGBoost — implémentation historique du gradient boosting, avec régularisation explicite et gestion native des valeurs manquantes (module 14).
• Zero-shot — résoudre une tâche sans aucun exemple étiqueté, en s'appuyant sur les connaissances déjà présentes dans un grand modèle pré-entraîné (module 13).

What this appendix contains

• A notation reference: the symbols used throughout the course for data, models, probability and linear algebra, plus the three conventions that are easiest to confuse (hat versus no hat, upper versus lower case, conditioning versus intervening).
• About 140 alphabetical entries, each a one-line definition with a link to the module where the notion is developed — from A/B testing and Arrow to zero-shot learning.
• A note on which English terms the course keeps untranslated, and why.

Course outline

1. Modern Python: typing, decorators, iterators and tooling
2. Concurrency in Python: the GIL, threads, processes, asyncio
3. Numerical toolbox: NumPy, pandas, polars, Dask
4. SQL and databases
5. Docker, Compose and Kubernetes
6. Serving a model: FastAPI, Pydantic, Jinja
7. Data engineering: formats, pipelines and streams
8. Math for ML: optimisation, linear algebra, SVD and PCA
9. Inferential statistics: estimate, test, decide
10. Probability, Bayesian inference and uncertainty quantification
11. Causal inference: measuring the effect of an action
12. Data science in practice: from problem to dataset
13. Learning with few labels
14. Classical machine learning
15. Learning theory: why generalisation happens
16. Deep learning
17. Time series, signals and time-to-event data
18. Non-tabular data: text, images, audio, graphs
19. Gaussian processes and Bayesian optimisation
20. Reinforcement learning
21. Machine learning for simulation and engineering
22. LLMs, embeddings, RAG and adaptation
23. Search, ranking and recommendation
24. From scores to decisions
25. Scaling up: GPUs, distributed training, performance
26. MLOps: taking a model to production
27. Fairness, robustness, privacy and security
28. End-to-end project: property listings, from scraping to price prediction