Les quatre énoncés suivants sont couramment relevés dans des comptes rendus de projet. Trois sont incorrects.
| Énoncé | Statut | Motif |
|---|---|---|
| « Nous avons entraîné un Random Forest sur 40 000 observations. » | Acceptable | Ellipse admise : entraîner avec l'algorithme Random Forest |
| « L'algorithme prédit une probabilité de résiliation de 0,72. » | Incorrect | Un algorithme ne prédit pas ; le modèle produit la prédiction |
| « Nous avons déployé un XGBoost en production. » | Incorrect | Ce qui est déployé est un modèle issu de XGBoost, non la bibliothèque |
| « L'algorithme a appris que l'ancienneté réduit le risque. » | Incorrect | L'algorithme exécute une procédure ; l'information apprise réside dans les paramètres du modèle |
L'écart n'est pas purement lexical : ce qui est versionné, ce qui est reproductible, ce qui doit être réexécuté lorsque les données évoluent et ce qui est transmis à l'exploitation ne sont pas les mêmes objets selon que l'on parle de l'algorithme ou du modèle (point 3).
Définition rigoureuse. Suite finie et non ambiguë d'opérations élémentaires permettant, à partir d'entrées appartenant à un domaine spécifié, de produire une sortie en un nombre fini d'étapes. La caractérisation classique retient cinq propriétés (Knuth, The Art of Computer Programming, 1968) : finitude, définition non ambiguë de chaque étape, entrées spécifiées, sorties spécifiées, effectivité des opérations.
Traduction en langage courant. Une méthode écrite une fois pour toutes, décrivant ce qu'il faut faire et dans quel ordre, indépendamment des valeurs sur lesquelles elle sera exécutée.
Point de vigilance. Un algorithme est une description de procédure : il n'a pas d'état, ne contient aucune connaissance sur un domaine particulier et ne change pas lorsque les données changent.
Définition rigoureuse. Cas particulier du précédent : procédure qui, appliquée à un jeu de données D = {(x₁, y₁), …, (xₙ, yₙ)} et à une configuration d'hyperparamètres λ, sélectionne un élément ĥ d'un espace d'hypothèses H selon un critère explicite évalué sur D. Formellement, A : (D, λ) ⟼ ĥ ∈ H.
Traduction en langage courant. La méthode qui, à partir d'un tableau d'exemples déjà étiquetés, fabrique la règle de décision. Elle décrit comment chercher, non ce qui sera trouvé. Trois éléments doivent être nommés pour qu'elle soit spécifiée : l'espace d'hypothèses parcouru (point 1.3), le critère évalué sur les données, et la stratégie de recherche (point 4.2).
Point de vigilance. L'algorithme est identique pour tous les projets qui
l'emploient : RandomForestClassifier est le même chez tous les utilisateurs d'une
version donnée de scikit-learn. Ce qui diffère d'un projet à l'autre est le modèle
produit, jamais l'algorithme.
Définition rigoureuse. Ensemble H de toutes les fonctions candidates
h : X → Y que l'algorithme est structurellement capable de produire, X désignant
l'espace des variables explicatives et Y celui de la variable cible. H est
déterminé conjointement par la famille de fonctions retenue et par les
hyperparamètres qui en contraignent la forme : fixer max_depth=3 ne modifie pas
l'algorithme, mais restreint H aux arbres de profondeur au plus 3.
Traduction en langage courant. L'ensemble de toutes les règles que la méthode a le droit de fabriquer : elle ne produira jamais une règle absente de cet ensemble, quelle que soit la quantité de données fournie. Pour une régression linéaire à deux variables, H est l'ensemble des fonctions h(x) = β₀ + β₁x₁ + β₂x₂, de cardinal infini mais paramétré par trois réels ; aucun jeu de données ne permettra d'y produire une fonction en escalier ou périodique.
Point de vigilance. Un modèle sous-performant l'est pour deux raisons distinctes : la bonne fonction n'appartient pas à H (erreur d'approximation, liée au choix de l'algorithme), ou elle y appartient sans avoir été trouvée (erreur d'estimation, liée aux données et à l'optimisation) — chapitre 032.
Définition rigoureuse (Mitchell, 1980). Ensemble des hypothèses supplémentaires, non déductibles des données d'entraînement, qu'un algorithme mobilise pour préférer certaines généralisations à d'autres parmi celles compatibles avec les données observées. Il se manifeste sous deux formes : la restriction de l'espace d'hypothèses et la préférence au sein de H, par exemple pour l'hypothèse la plus simple à performance égale.
Traduction en langage courant. Un jeu d'exemples ne détermine jamais une seule règle : une infinité de règles passent par les mêmes points. Le biais inductif est l'ensemble des préférences intégrées à la méthode, qui tranchent entre ces règles.
Résultat associé (Wolpert, 1996 — No Free Lunch). Moyenné sur l'ensemble de tous les problèmes possibles, aucun algorithme n'est supérieur à un autre : sa performance sur un problème donné provient de l'adéquation entre son biais inductif et la structure réelle du phénomène. Choisir un algorithme revient donc à parier sur cette structure (chapitre 049).
Point de vigilance. Un apprentissage sans biais inductif est impossible : un algorithme dépourvu de toute préférence ne pourrait rien affirmer sur une observation absente du jeu d'entraînement.
| Algorithme | Espace d'hypothèses H | Forme d'une hypothèse | Biais inductif principal |
|---|---|---|---|
| Régression linéaire | Fonctions affines de X | Somme pondérée des variables | Linéarité et additivité des effets |
| Régression logistique | Logistiques de fonctions affines | Sigmoïde d'une combinaison linéaire | Frontière de décision linéaire |
| Arbre de décision (CART) | Partitions de X par découpes orthogonales aux axes | Suite de tests seuil, constante par feuille | Découpes parallèles aux axes, préférence pour les arbres courts |
| k plus proches voisins | Fonctions constantes par voisinage | Vote ou moyenne locale | Continuité locale : deux observations proches ont des cibles proches |
| Naive Bayes | Distributions conditionnelles factorisées | Produit de vraisemblances par variable | Indépendance conditionnelle des variables sachant la classe |
| Perceptron multicouche | Compositions d'applications affines et de non-linéarités | Graphe de calcul à couches | Compositionnalité et régularité des fonctions représentables |
Lecture : chaque ligne décrit un pari différent sur la structure du phénomène. Un effet de seuil marqué sera mal servi par une régression linéaire et bien servi par un arbre ; un phénomène additif et lisse, l'inverse.
Définition rigoureuse. Élément ĥ ∈ H sélectionné par l'algorithme A à l'issue de son exécution sur un jeu de données D avec des hyperparamètres λ. Le modèle est entièrement spécifié par deux composantes : une structure — la forme fonctionnelle, fixée par A et λ — et un jeu de valeurs de paramètres ajusté à partir de D.
Définition opérationnelle. Artefact logiciel implémentant une fonction déterministe des variables explicatives vers l'espace de sortie, dont le comportement dépend intégralement du jeu de données sur lequel il a été ajusté, et qui peut être sérialisé, versionné, transporté et évalué indépendamment de la procédure qui l'a produit.
Traduction en langage courant. Le résultat de l'entraînement : une règle de décision figée, en mémoire ou en fichier, qui répond à une question précise pour une observation donnée.
Point de vigilance. Le modèle n'est pas le fichier : celui-ci n'en est qu'un
support de sérialisation, au même titre qu'une partition n'est pas la musique. Un
même modèle s'exporte en joblib, en ONNX ou en PMML sans changer de nature.
| Famille de modèles | Structure fixée par l'algorithme et λ | Paramètres ajustés sur les données | Ordre de grandeur |
|---|---|---|---|
| Régression linéaire à p variables | Une équation affine | p coefficients et une constante | p + 1 |
| Régression logistique à p variables | Une équation affine composée d'une logistique | p coefficients et une constante | p + 1 |
| Arbre de décision | Un arbre binaire de profondeur bornée | Variable et seuil de chaque nœud, valeur de chaque feuille | 10¹ à 10³ |
| Forêt aléatoire de 200 arbres | 200 arbres agrégés par vote ou moyenne | Tous les paramètres des 200 arbres | 10⁴ à 10⁷ |
| k plus proches voisins | Une métrique et un entier k | Aucun au sens strict : le jeu d'entraînement est mémorisé | n × p valeurs stockées |
| Perceptron multicouche | Nombre de couches, largeurs, activations | Poids et biais de toutes les connexions | 10³ à 10¹¹ |
Point de vigilance — les k plus proches voisins. Cet algorithme ne produit pas de paramètres au sens usuel : il conserve les observations d'entraînement et diffère tout calcul au moment de la prédiction (modèle paresseux, lazy learner). La définition du modèle comme artefact reste valide : la structure est la règle de vote sur les k voisins, le contenu ajusté est l'ensemble mémorisé (chapitre 040).
La frontière entre ce qui est réglé par l'humain et ce qui est appris fait l'objet du chapitre 009 ; le principe est ici que les hyperparamètres définissent H et que les paramètres désignent l'élément retenu dans H.
Dans scikit-learn, les attributs dont le nom se termine par un caractère de soulignement n'existent qu'après l'entraînement : leur présence est le critère opérationnel distinguant un algorithme instancié d'un modèle.
from sklearn.linear_model import LinearRegression
def appris(objet):
return [a for a in dir(objet) if a.endswith("_") and not a.startswith("_")]
estimateur = LinearRegression()
print("Avant fit — hyperparamètres :", estimateur.get_params())
print("Avant fit — attributs appris :", appris(estimateur))
estimateur.fit(X, y)
print("Après fit — attributs appris :", appris(estimateur))Avant fit — hyperparamètres : {'copy_X': True, 'fit_intercept': True,
'n_jobs': None, 'positive': False, 'tol': 1e-06}
Avant fit — attributs appris : []
Après fit — attributs appris : ['coef_', 'feature_names_in_', 'intercept_',
'n_features_in_', 'rank_', 'singular_']Interprétation : avant l'appel, l'objet matérialise l'algorithme et l'espace
d'hypothèses, ses hyperparamètres étant renseignés et sa connaissance nulle. Après,
coef_ et intercept_ portent l'information induite des données, et
n_features_in_ comme feature_names_in_ enregistrent le schéma d'entrée attendu
(point 5.2). Le même objet joue successivement deux rôles : scikit-learn nomme
estimator l'objet avant comme après le fit.
| Critère | Algorithme d'apprentissage | Modèle |
|---|---|---|
| Nature | Une procédure | Un artefact |
| Moment d'existence | Avant toute donnée | Après l'entraînement |
| Dépendance aux données | Nulle | Totale |
| Contenu | Des instructions | Une structure et des valeurs de paramètres |
| Déterminé par | Un choix de conception humain | Les données d'entraînement |
| Support matériel | Du code, une bibliothèque installée | Un objet en mémoire, un fichier sérialisé |
| Unicité | Un algorithme, de nombreux modèles | Un modèle pour un entraînement daté |
| Ce qui est versionné | Une dépendance logicielle (scikit-learn==1.8.0) | Un livrable identifié (modele_attrition_v3.joblib) |
| Ce qui est déployé | Non, sauf pour réentraîner | Oui |
| Vieillissement | Par obsolescence de la bibliothèque | Par dérive de la distribution des données (chapitre 082) |
Une recette est un texte : elle ne se mange pas, ne se périme pas, reste identique quel que soit le nombre de fois où elle est exécutée et se photocopie sans perte. Le gâteau est un objet : il résulte de l'exécution de la recette sur des ingrédients précis, dans un four réglé d'une certaine manière, un jour donné. Deux gâteaux issus de la même recette diffèrent si les ingrédients diffèrent ; le gâteau se transporte, se date, se périme.
| Élément culinaire | Correspondant en apprentissage supervisé | Justification |
|---|---|---|
| La recette écrite | L'algorithme d'apprentissage | Procédure reproductible, indépendante de toute exécution |
| Les ingrédients | Le jeu de données d'entraînement | Matière première consommée par la procédure |
| Le réglage du four et le temps de cuisson | Les hyperparamètres | Fixés avant l'exécution, par un humain, non déduits de la matière |
| L'acte de cuisson | L'entraînement | Exécution de la procédure sur la matière première |
| Le gâteau obtenu | Le modèle | Résultat unique, daté, dépendant intégralement des ingrédients |
| Une part servie à un convive | Une prédiction | Usage du résultat sur un cas particulier |
| Envoyer la recette à un convive affamé | Déployer l'algorithme au lieu du modèle | Le convive devrait acheter les ingrédients et cuire lui-même |
| Le gâteau emballé et livré | Le modèle sérialisé et déployé | Ce qui est effectivement transmis au consommateur |
| Refaire une fournée avec des ingrédients frais | Le réentraînement | Même recette, nouvelle matière, nouveau résultat |
Limites de l'analogie. Le gâteau est un objet passif, alors que le modèle est une fonction entrée vers sortie (point 5.2) ; une part consommée n'est plus disponible, alors qu'un modèle produit un nombre illimité de prédictions sans s'épuiser ; enfin le gâteau se périme par altération physique, alors que le fichier d'un modèle ne se dégrade pas — c'est la distribution des données de production qui s'écarte de celle de l'entraînement (chapitre 082).
Le code suivant applique un algorithme unique à deux jeux de données décrivant le même phénomène — le prix d'un logement selon sa surface, son nombre de pièces et son âge — sur deux marchés immobiliers distincts.
Chaque jeu comporte 800 transactions décrites par trois variables explicatives.
import pandas as pd
from sklearn.linear_model import LinearRegression
VARIABLES = ["surface_m2", "nb_pieces", "age_bien"]
lyon, nantes = pd.read_csv("marche_lyon.csv"), pd.read_csv("marche_nantes.csv")
X_lyon, y_lyon = lyon[VARIABLES], lyon["prix"]
X_nantes, y_nantes = nantes[VARIABLES], nantes["prix"]
modele_lyon = LinearRegression().fit(X_lyon, y_lyon)
modele_nantes = LinearRegression().fit(X_nantes, y_nantes)
print("Même classe d'algorithme :", type(modele_lyon) is type(modele_nantes))
for nom, m in [("LYON", modele_lyon), ("NANTES", modele_nantes)]:
print(f"{nom:7s} constante = {m.intercept_:>10,.1f} | " +
" | ".join(f"{v} = {c:,.1f}" for v, c in zip(X_lyon.columns, m.coef_)))
bien = pd.DataFrame([{"surface_m2": 85, "nb_pieces": 4, "age_bien": 12}])
print("Prédiction Lyon :", round(float(modele_lyon.predict(bien)[0]), 1))
print("Prédiction Nantes :", round(float(modele_nantes.predict(bien)[0]), 1))Même classe d'algorithme : True
LYON constante = 43,617.1 | surface_m2 = 3,201.6 | nb_pieces = 8,090.7 | age_bien = -878.3
NANTES constante = 30,521.4 | surface_m2 = 1,904.5 | nb_pieces = 4,658.9 | age_bien = -1,473.9
Prédiction Lyon : 337575.3
Prédiction Nantes : 193349.8Interprétation. Une seule classe d'algorithme a été instanciée, sans modifier aucun hyperparamètre. Les deux objets partagent le même type et la même structure — une équation affine à trois variables — et diffèrent uniquement par les valeurs de leurs quatre paramètres, issues intégralement des données. L'écart est de nature métier : le modèle lyonnais valorise le mètre carré à environ 3 200 unités monétaires, le nantais à environ 1 900, et la décote liée à l'âge est près de 1,7 fois plus forte sur le second marché. Interrogés sur le même bien, ils répondent 337 575 et 193 350 : aucun ne se trompe, ils encodent deux marchés différents.
Conséquence directe : « nous utilisons une régression linéaire » n'identifie pas un système de prédiction, mais nomme le biais inductif retenu. Le système est identifié par le couple (modèle, jeu d'entraînement), daté.
Le modèle au sens strict — structure et paramètres de l'estimateur final — ne suffit pas à produire une prédiction en production. Une observation brute doit subir exactement les mêmes transformations que les données d'entraînement : imputation avec les mêmes valeurs de remplacement, encodage avec les mêmes modalités de référence, mise à l'échelle avec les mêmes moyennes et écarts-types. Ces transformations comportent elles-mêmes des paramètres ajustés sur l'entraînement : elles font partie de ce qui est appris et doivent être sérialisées avec l'estimateur.
Définition rigoureuse. Conversion de l'état complet d'un objet en mémoire — structure et valeurs de paramètres — en une séquence d'octets persistante, permettant sa reconstitution ultérieure dans un processus distinct avec un comportement fonctionnellement identique.
Traduction en langage courant. Enregistrer le modèle dans un fichier de manière
à pouvoir le recharger plus tard, ailleurs, sans avoir à le réentraîner. Les formats
usuels sont joblib et pickle (écosystème Python, dépendants des versions), ONNX
(interopérable entre langages et moteurs d'exécution), PMML (standard XML, familles
de modèles limitées) et les formats natifs de bibliothèque, tel Booster.save_model
pour XGBoost et LightGBM.
Point de vigilance. Un fichier joblib ou pickle reconstruit des objets Python
arbitraires à la lecture : le charger sans en maîtriser la provenance équivaut à
exécuter du code non vérifié. Par ailleurs, la désérialisation sous une version de
bibliothèque différente n'est pas garantie : la version doit être enregistrée dans
les métadonnées et vérifiée au chargement.
import os, joblib, sklearn, numpy as np
from sklearn.compose import ColumnTransformer
from sklearn.ensemble import RandomForestClassifier
from sklearn.impute import SimpleImputer
from sklearn.pipeline import Pipeline
from sklearn.preprocessing import OneHotEncoder, StandardScaler
num = ["anciennete_mois", "facture_mensuelle", "nb_appels_support"]
cat = ["type_forfait"]
pipeline = Pipeline([
("preparation", ColumnTransformer([
("num", Pipeline([("imputation", SimpleImputer(strategy="median")),
("mise_a_echelle", StandardScaler())]), num),
("cat", OneHotEncoder(handle_unknown="ignore"), cat)])),
("modele", RandomForestClassifier(n_estimators=200, max_depth=8,
random_state=42))]).fit(df, y)
artefact = {"pipeline": pipeline, "version_sklearn": sklearn.__version__,
"colonnes_attendues": num + cat, "seuil_decision": 0.42,
"date_entrainement": "2026-08-22"}
joblib.dump(artefact, "modele_attrition_v3.joblib", compress=3)
print("Taille :", round(os.path.getsize("modele_attrition_v3.joblib")/1024, 1), "Ko")
recharge = joblib.load("modele_attrition_v3.joblib")
p_memoire = pipeline.predict_proba(df.head(5))[:, 1]
p_recharge = recharge["pipeline"].predict_proba(df.head(5))[:, 1]
print("Probabilités rechargées :", np.round(p_recharge, 4))
print("Identité stricte :", np.array_equal(p_memoire, p_recharge))
print("Version et seuil :", recharge["version_sklearn"], recharge["seuil_decision"])Taille : 1242.5 Ko
Probabilités rechargées : [0.0678 0.0711 0.0735 0.2408 0.0108]
Identité stricte : True
Version et seuil : 1.8.0 0.42Interprétation. Le fichier pèse 1,2 Mo alors que le jeu d'entraînement ne comporte que quelques milliers de lignes : ce volume est celui des 200 arbres, c'est-à-dire des paramètres appris, et dépend de la structure retenue, non du volume de données. Le rechargement restitue des probabilités strictement identiques : un modèle est déterministe, et toute variation observée en production sans réentraînement signale une différence dans les entrées ou l'environnement d'exécution, jamais dans le modèle. Enfin l'artefact ne se réduit pas au pipeline : le seuil de décision (chapitre 062) est une décision métier extérieure aux paramètres, et la version de bibliothèque comme la liste ordonnée des colonnes conditionnent la validité du chargement.
Définition rigoureuse. Exécution de l'algorithme A sur un jeu de données D avec des hyperparamètres λ, consistant à sélectionner dans H l'hypothèse ĥ qui optimise un critère explicite évalué sur D, éventuellement assorti d'un terme de régularisation :
ĥ = argmin sur h ∈ H de [ (1/n) · Σᵢ L(h(xᵢ), yᵢ) + Ω(h) ]
où L désigne la fonction de coût et Ω un terme pénalisant la complexité de l'hypothèse. Ce cadre est celui de la minimisation du risque empirique (Vapnik). La quantité minimisée est mesurée sur l'échantillon d'entraînement, non sur la population : cet écart est l'origine du surapprentissage (chapitre 031).
Traduction en langage courant. La phase d'étude : l'algorithme parcourt les exemples corrigés, ajuste ses paramètres pour se tromper le moins possible sur ces exemples, et s'arrête lorsque le critère ne s'améliore plus significativement.
Ce que l'entraînement ne fait pas. Il ne modifie pas les hyperparamètres, qui
restent tels que fournis ; il n'accumule pas les appels successifs, un second fit
écrasant intégralement l'état antérieur sauf recours à partial_fit ou
warm_start ; il n'évalue pas le modèle produit, l'évaluation exigeant des données
non vues.
Point de vigilance. Le critère optimisé pendant l'entraînement (la fonction de coût) et le critère d'évaluation métier (la métrique) sont distincts et coïncident rarement (chapitre 030).
Modifier l'une de ces trois composantes produit un modèle différent, à jeu de données constant.
| Algorithme | Stratégie de recherche dans H | Déterminisme à données constantes |
|---|---|---|
| Régression linéaire (moindres carrés) | Solution analytique ou décomposition matricielle | Oui |
| Régression logistique | Optimisation numérique convexe itérative | Oui, à solveur et tolérance fixés |
| Arbre de décision | Recherche gloutonne, découpe optimale locale par nœud | Oui si aucun tirage aléatoire de variables |
| Forêt aléatoire | Arbres construits sur échantillons et sous-espaces tirés au hasard | Non, sauf graine fixée |
| Gradient boosting | Ajout séquentiel d'apprenants corrigeant les résidus | Non, sauf graine fixée |
| k plus proches voisins | Aucune recherche : mémorisation du jeu d'entraînement | Oui |
| Perceptron multicouche | Descente de gradient stochastique par rétropropagation | Non, sauf graine fixée et exécution déterministe imposée |
Point de vigilance : pour les algorithmes marqués « Non », deux entraînements
successifs sur le même jeu avec les mêmes hyperparamètres produisent deux modèles
différents. La fixation d'une graine (random_state) conditionne la reproductibilité
du livrable et doit figurer dans les métadonnées.
Définition rigoureuse. Évaluation de la fonction ĥ en un point x de l'espace des variables explicatives, produisant une valeur ŷ = ĥ(x) de l'espace de sortie. L'observation x n'appartient pas nécessairement au jeu d'entraînement ; l'intérêt opérationnel réside précisément dans le cas où elle n'y appartient pas.
Traduction en langage courant. Donner une réponse pour un cas nouveau, en appliquant la règle apprise. La convention distingue y, valeur réelle observée, et ŷ, valeur produite par le modèle ; leur différence est le résidu (chapitre 066).
Point de vigilance. Le terme ne comporte aucune connotation temporelle. Un modèle diagnostiquant une pathologie sur des données présentes produit une prédiction au sens technique, bien qu'aucun futur ne soit en jeu.
Trois propriétés caractérisent cette fonction. Déterminisme : deux appels avec la même entrée produisent la même sortie, le modèle ne comportant aucun élément aléatoire à la prédiction même lorsque son entraînement en comportait. Absence d'état : une prédiction ne modifie pas le modèle, et l'adaptation aux données nouvelles exige un réentraînement, opération distincte. Fermeture sur son schéma d'entrée : le modèle n'accepte que des entrées conformes au schéma enregistré à l'entraînement — mêmes variables, même ordre, mêmes types, mêmes modalités catégorielles connues, et transformations appliquées avec les paramètres appris sur l'entraînement, non recalculés (chapitre 028).
Point de vigilance : le mode de défaillance le plus coûteux n'est pas l'erreur d'exécution, qui est visible, mais la prédiction produite sans erreur à partir d'une entrée mal transformée. Un pipeline unique sérialisé, plutôt qu'une suite d'étapes reproduites manuellement en production, élimine cette classe de défaillance par construction (chapitres 076 à 079).
| Appel | Sortie produite | Forme | Disponibilité |
|---|---|---|---|
predict(X) | Classe prédite ou valeur numérique | Vecteur de longueur n | Tous les estimateurs supervisés |
predict_proba(X) | Probabilités estimées par classe | Matrice n × K, lignes de somme 1 | Classifieurs à sortie probabiliste |
decision_function(X) | Score non borné, non calibré | Vecteur de longueur n | Modèles à marge, SVM et modèles linéaires |
transform(X) | Représentation transformée des entrées | Matrice n × p′ | Transformateurs, non estimateurs finaux |
Point de vigilance : predict applique par défaut un seuil de 0,5 sur la
probabilité estimée. Ce seuil est une convention d'implémentation, non un optimum ;
sa révision est un levier majeur (chapitres 062 et 029).
Acception 1 — inférence au sens du Machine Learning (inference, serving). Opération consistant à évaluer un modèle entraîné sur des données nouvelles pour produire des prédictions. Synonyme de prédiction, le terme s'oppose à l'entraînement et domine le vocabulaire de l'ingénierie de production : inference server, inference latency, batch inference.
Acception 2 — inférence au sens statistique (statistical inference). Démarche consistant à estimer les caractéristiques d'une population à partir d'un échantillon et à quantifier l'incertitude associée : estimation ponctuelle, intervalle de confiance, test d'hypothèse, significativité. Tradition de Fisher, Neyman et Pearson.
Origine de l'ambiguïté. Les deux communautés emploient le même mot pour des opérations dont les objets s'opposent : une observation individuelle d'un côté, un paramètre de population de l'autre. La distinction est développée par Breiman (2001, Statistical Modeling: The Two Cultures) et Shmueli (2010, To Explain or to Predict?).
Point de vigilance. Un modèle très performant en prédiction ne fournit aucune garantie inférentielle : un coefficient élevé n'établit ni la significativité de l'effet, ni sa direction causale (chapitre 016).
| Critère | Inférence au sens ML | Inférence au sens statistique |
|---|---|---|
| Objet visé | Une observation individuelle | Un paramètre de population |
| Question posée | Quelle valeur pour ce cas précis ? | Quelle est la valeur de θ dans la population, et avec quelle incertitude ? |
| Sortie produite | Une prédiction ŷ | Une estimation, un intervalle de confiance, une décision de test |
| Critère de qualité | Erreur de généralisation sur données non vues | Propriétés de l'estimateur : biais, convergence, couverture |
| Hypothèses mobilisées | Observations i.i.d., stabilité de la distribution | Modèle génératif spécifié, conditions de régularité |
| Contexte d'emploi | Ingénierie, production, MLOps | Statistique, épidémiologie, économétrie |
Recommandation de formulation : employer « produire une prédiction » ou « servir le modèle » pour la première acception, et nommer explicitement « inférence statistique » la seconde.
| Étape | Entrée consommée | Artefact produit | Chapitre |
|---|---|---|---|
| Cadrage | Une question métier | Tâche T et métrique P explicitées | 012 |
| Constitution du jeu de données | Sources opérationnelles | Jeu de données étiqueté X, y | 005 à 007 |
| Séparation | Jeu complet | Sous-ensembles entraînement, validation, test | 026, 027 |
| Préparation ajustée | Transformateurs ajustés | 022, 023 | |
| Choix de l'algorithme | Nature du problème et contraintes | Espace H et biais inductif retenus | 049 |
| Sélection des hyperparamètres | Entraînement et validation | Configuration λ retenue | 034, 035 |
| Entraînement final | , | Modèle ĥ | 029 |
| Évaluation | , | Mesures de performance en généralisation | 052 à 075 |
| Sérialisation | Pipeline complet et métadonnées | Fichier d'artefact versionné | 081 |
| Service | Observations de production | Prédictions | 081 |
| Surveillance | Flux de production | Alertes de dérive, décision de réentraînement | 082 |
Lecture du cycle. Deux boucles de nature différente apparaissent. La boucle courte, entre sélection des hyperparamètres et entraînement, explore plusieurs espaces d'hypothèses pendant le développement. La boucle longue, de la surveillance vers le jeu de données, est déclenchée par la dégradation des performances en production : elle réexécute le même algorithme sur des données actualisées pour produire un nouveau modèle, versionné distinctement. Réentraîner ne consiste donc jamais à modifier l'algorithme, mais à produire un nouvel artefact.
Ce qui est déployé est un artefact — structure et valeurs de paramètres — issu de l'exécution de l'algorithme Random Forest sur un jeu de données déterminé, à une date déterminée. L'algorithme réside dans la bibliothèque installée.
Formulation correcte : « Nous avons déployé le modèle attrition_v3, obtenu
par entraînement d'une forêt aléatoire sur les données de janvier à juin. »
L'algorithme exécute une procédure de recherche et ne conserve rien à l'issue de son exécution ; la connaissance induite réside dans les paramètres du modèle produit.
Formulation correcte : « L'algorithme a sélectionné, dans l'espace d'hypothèses, un modèle dont les coefficients indiquent une association négative entre ancienneté et résiliation. »
Réentraîner consiste à réexécuter le même algorithme, avec les mêmes hyperparamètres, sur des données actualisées : aucune ligne de code n'est modifiée. La confusion conduit à sous-estimer le coût réel du cycle de maintenance.
Formulation correcte : « Le réentraînement mensuel produit une nouvelle version du modèle sans modification du code d'entraînement. »
Les transformations de préparation comportent des paramètres appris sur les données d'entraînement : médianes d'imputation, modalités d'encodage, moyennes et écarts-types. Un estimateur sérialisé seul, alimenté par des transformations réimplémentées manuellement, produit des prédictions fausses sans erreur visible.
Formulation correcte : « L'artefact sérialisé est le pipeline complet, de la donnée brute à la prédiction, accompagné de ses métadonnées. »
Le terme désigne, selon la communauté, la production d'une prédiction sur une observation ou l'estimation d'un paramètre de population assortie d'une mesure d'incertitude : ni le même objet, ni les mêmes critères de validité.
Formulation correcte : « Le serveur d'inférence produit des prédictions. Les conclusions relatives à la population relèveraient d'une inférence statistique, que ce dispositif ne fournit pas. »
LES DEUX OBJETS
ALGORITHME D'APPRENTISSAGE — une procédure. A : (D, λ) → ĥ ∈ H
Existe avant les données, ne contient aucune connaissance,
versionné comme une dépendance logicielle.
MODÈLE — un artefact. Structure fixée par A et λ,
paramètres ajustés sur D. N'existe qu'après l'entraînement,
dépend intégralement de D, versionné comme un livrable daté.
LES TROIS COMPOSANTES D'UN ALGORITHME D'APPRENTISSAGE
1. Un espace d'hypothèses H quelles règles sont candidates
2. Un critère d'optimisation comment mesurer leur qualité sur D
3. Une stratégie de recherche comment parcourir H
BIAIS INDUCTIF (Mitchell, 1980)
Les préférences non déduites des données qui permettent de choisir
une généralisation parmi celles compatibles avec D. Sans biais,
aucune généralisation n'est possible. No Free Lunch (Wolpert, 1996) :
aucun biais n'est universellement supérieur ; choisir un algorithme,
c'est parier sur la forme du phénomène.
LES DEUX OPÉRATIONS
ENTRAÎNEMENT D, λ → ĥ sélection dans H
PRÉDICTION x → ŷ = ĥ(x) évaluation d'une fonction
LE MODÈLE COMME FONCTION
ENTRÉE (variables) → [ MODÈLE ] → SORTIE (prédiction)
déterministe · sans état · fermé sur son schéma d'entrée
ANALOGIE CULINAIRE
recette → algorithme ingrédients → jeu d'entraînement
four → hyperparamètres cuisson → entraînement
gâteau → modèle part servie → prédiction
gâteau emballé et livré → artefact sérialisé déployé
DEUX SENS DU MOT INFÉRENCE
Sens ML produire une prédiction pour une observation
Sens statistique estimer un paramètre de population avec
quantification de l'incertitude
CE QUI EST EFFECTIVEMENT DÉPLOYÉ
Non pas l'estimateur seul, mais le pipeline complet (imputation,
encodage, mise à l'échelle, estimateur) et ses métadonnées :
version de bibliothèque, schéma d'entrée, seuil de décision,
graine aléatoire, date, périmètre de validité.
LE TEST DE VOCABULAIRE
« La procédure » se substitue au terme → l'algorithme.
« Le fichier entraîné » se substitue → le modèle.Énoncé de synthèse
L'algorithme d'apprentissage est une procédure qui, à partir d'un jeu de données et d'hyperparamètres, sélectionne dans un espace d'hypothèses la règle optimisant un critère ; le modèle est cette règle une fois sélectionnée, artefact composé d'une structure et de paramètres ajustés, dépendant intégralement des données qui l'ont produit ; l'entraînement est l'opération de sélection, la prédiction est l'évaluation de la fonction obtenue sur une observation nouvelle, et ce qui est versionné, sérialisé et déployé en production n'est jamais l'algorithme mais le modèle accompagné de son pipeline de préparation et de ses métadonnées.
Quiz associés
008.1-quiz-algorithme-apprentissage.md008.2-quiz-modele-artefact.md008.3-quiz-distinction-production.md008.4-quiz-entrainement.md008.5-quiz-prediction-inference.md008.6-quiz-cycle-complet.mdChapitre suivant : 009-parametres-hyperparametres.md