Organisation du cours

Le cours se compose de trois chapitres, Probabilités, Estimation, Détection, et d'une collection de mini-projets qui les mettent en œuvre. Le fil conducteur est unique : la méthode choisie dépend des hypothèses que nous acceptons de faire, et quand le modèle manque, les données en tiennent lieu.

Le fil du cours

Toute méthode de ce cours, et tous les mini-projets, suivent la même chaîne en quatre temps :

1. Le modèle. Les hypothèses que nous acceptons de faire : une loi $p(x;\theta )$, un signal $s[n;\theta ]$, deux lois concurrentes $H_0$/$H_1$, ou, quand le modèle manque, une base d'exemples qui en tient lieu. C'est le choix décisif, la méthode découle des hypothèses, jamais l'inverse.
2. Le critère de performance. La quantité qui dit ce que « bien » veut dire : biais, variance et MSE pour une estimation, $P_{FA}$, $P_D$ et courbe ROC pour une décision. Le critère joue deux rôles : il juge une méthode existante, et, minimisé, il en construit une, c'est alors la loss.
3. L'optimisation. La recherche du minimum : une forme fermée quand elle existe, les équations normales du modèle linéaire, et des algorithmes numériques sinon, grille, descente de gradient, stratégie en deux temps, minimisations alternées.
4. Les tests. Rien ne se croit sans vérification : chaque résultat théorique est confronté à une simulation de Monte-Carlo, chaque seuil se calibre ou se vérifie sous $H_0$, et chaque fonction des notebooks s'accompagne de tests automatiques. Les tests d'hypothèses eux-mêmes ne sont que cette vérification, outillée et quantifiée.

Ce squelette se répète à toutes les échelles : il ordonne les chapitres, le premier construit les modèles, les deux suivants déroulent critères puis optimisations, les sections d'un chapitre, Hypothèses, Expression, Propriétés, Exemple, et chaque mini-projet. Un étudiant perdu peut toujours se demander où il se trouve dans la chaîne : modèle, critère, optimisation ou test.

Acquis d'apprentissage visés (AAV)

À l'issue du module, l'étudiant sera capable de :

• AAV1, Modéliser et estimer : modéliser des données par une loi paramétrée $p(\mathbf{x};\theta )$ adaptée, en justifiant les hypothèses (chapitre 1) ; estimer ses paramètres en minimisant une loss (MLE, moindres carrés, MAP, estimateur appris), quantifier la performance (biais, variance, MSE, CRLB) et construire puis interpréter un intervalle de confiance (chapitre 2).
• AAV2, Estimer : mener une régression linéaire multiple en maîtrisant ses fondements, moindres carrés, équations normales, fonctions de base, et diagnostiquer le surapprentissage puis le corriger par régularisation (chapitre 2).
• AAV3, Décider : construire le détecteur adapté aux hypothèses disponibles (Neyman-Pearson, GLRT, filtre adapté, bayésien, appris), et relier ce cadre aux tests d'hypothèse classiques, p-value, test t, ${\chi }^2$, ANOVA, en explicitant leur portée et leurs limites (chapitre 3, projet Tests classiques).
• AAV4, Réduire la dimension : comprendre la PCA comme un problème de moindres carrés à base inconnue, la mettre en œuvre à la main puis avec les outils standard, et interpréter la représentation réduite (projet PCA).
• AAV6, Évaluer : juger la qualité d'un modèle, adéquation d'une loi, probabilités de fausse alarme et de détection, courbe ROC et AUC, matrice de confusion, précision et rappel, et vérifier tout résultat par simulation de Monte-Carlo (chapitres 2 et 3).

S'y ajoute une compétence transversale, travaillée dans tous les mini-projets : implémenter chaque méthode à la main en NumPy, retrouver le résultat avec la bibliothèque de référence, et accompagner chaque fonction de tests automatiques.

Notations

Les conventions suivent Kay, Vol. I & II, et sont utilisées partout, sans exception. La table complète, ensembles et événements, variables aléatoires, lois, moments, estimation, détection, vit sur une page dédiée : Notations.

Pile technologique et imports

Python ≥ 3.11, NumPy, Matplotlib et seaborn pour les figures, scipy.stats pour les lois et les tests, et scikit-learn ponctuellement, pour les réseaux de neurones (MLPRegressor, MLPClassifier) et les métriques ROC des chapitres 2 et 3.

Les imports sont standardisés une fois pour toutes ; tous les blocs de code du cours les supposent faits :

import numpy as np
import scipy.stats as sta
import matplotlib.pyplot as plt
import seaborn as sns
# sklearn : import par sous-module explicite, ex.
# from sklearn.neural_network import MLPRegressor

La règle from scratch → bibliothèque

Chaque notion codée dans ce cours l'est deux fois, et les deux versions doivent coïncider numériquement :

1. from scratch : une implémentation NumPy courte, qui montre exactement ce que fait la méthode ;
2. bibliothèque : l'équivalent en une à trois lignes avec l'outil de référence ;
3. vérification : un np.allclose(...), les écarts éventuels étant commentés.

Ces miroirs sont rendus en onglets. Exemple avec les équations normales du modèle linéaire :

from scratch

theta = np.linalg.solve(H.T @ H, H.T @ x)

numpy

theta_lstsq, *_ = np.linalg.lstsq(H, x, rcond=None)
# >>> np.allclose(theta, theta_lstsq)  ->  True

Le vocabulaire des bibliothèques s'installe au fil de l'eau : fit = estimer $\hat{\mathit{\theta }}$, predict = appliquer le modèle, score = mesurer la performance.

Mini-projets

Les mini-projets appliquent chaque chapitre à un problème complet, de la roulette au décodeur DTMF. Tous suivent la même structure imposée, décrite dans leurs modalités communes : le modèle (une classe au gabarit de scipy.stats), le critère, l'algorithme à la main, le bon outil, la validation Monte-Carlo, et des tests automatiques systématiques. Le livrable est toujours un notebook reproductible, exécutable de bout en bout, graine fixée.