Algorithme, modèle, entraînement et prédiction

25 min
Bloc 1 — Le vocabulaire fondamental
Objectif
définir rigoureusement l'algorithme d'apprentissage et le modèle, établir la distinction stricte entre les deux, caractériser l'entraînement comme procédure de sélection dans un espace d'hypothèses et la prédiction comme évaluation d'une fonction, et identifier ce qui est effectivement versionné, sérialisé et déployé en production.
Durée estimée
35 minutes
Prérequis
chapitres 001 à 007
Quiz associés
008.1-quiz-algorithme-apprentissage.md à 008.6-quiz-cycle-complet.md

1. L'algorithme d'apprentissage

1.1 Le problème du vocabulaire

Les quatre énoncés suivants sont couramment relevés dans des comptes rendus de projet. Trois sont incorrects.

ÉnoncéStatutMotif
« Nous avons entraîné un Random Forest sur 40 000 observations. »AcceptableEllipse admise : entraîner avec l'algorithme Random Forest
« L'algorithme prédit une probabilité de résiliation de 0,72. »IncorrectUn algorithme ne prédit pas ; le modèle produit la prédiction
« Nous avons déployé un XGBoost en production. »IncorrectCe 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. »IncorrectL'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).

1.2 Définitions

DÉFINITION — Algorithme, au sens général

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 — Algorithme d'apprentissage (learning algorithm, learner)

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.

1.3 L'espace d'hypothèses et le biais inductif

DÉFINITION — Espace d'hypothèses (hypothesis space, H)

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 — Biais inductif (inductive bias)

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.

1.4 Les principales familles d'algorithmes

AlgorithmeEspace d'hypothèses HForme d'une hypothèseBiais inductif principal
Régression linéaireFonctions affines de XSomme pondérée des variablesLinéarité et additivité des effets
Régression logistiqueLogistiques de fonctions affinesSigmoïde d'une combinaison linéaireFrontière de décision linéaire
Arbre de décision (CART)Partitions de X par découpes orthogonales aux axesSuite de tests seuil, constante par feuilleDécoupes parallèles aux axes, préférence pour les arbres courts
k plus proches voisinsFonctions constantes par voisinageVote ou moyenne localeContinuité locale : deux observations proches ont des cibles proches
Naive BayesDistributions conditionnelles factoriséesProduit de vraisemblances par variableIndépendance conditionnelle des variables sachant la classe
Perceptron multicoucheCompositions d'applications affines et de non-linéaritésGraphe de calcul à couchesCompositionnalité 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.


2. Le modèle comme artefact paramétré

2.1 Définition

DÉFINITION — Modèle (model, modèle entraîné, fitted model)

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.

2.2 Structure et paramètres

Famille de modèlesStructure fixée par l'algorithme et λParamètres ajustés sur les donnéesOrdre de grandeur
Régression linéaire à p variablesUne équation affinep coefficients et une constantep + 1
Régression logistique à p variablesUne équation affine composée d'une logistiquep coefficients et une constantep + 1
Arbre de décisionUn arbre binaire de profondeur bornéeVariable et seuil de chaque nœud, valeur de chaque feuille10¹ à 10³
Forêt aléatoire de 200 arbres200 arbres agrégés par vote ou moyenneTous les paramètres des 200 arbres10⁴ à 10⁷
k plus proches voisinsUne métrique et un entier kAucun au sens strict : le jeu d'entraînement est mémorisén × p valeurs stockées
Perceptron multicoucheNombre de couches, largeurs, activationsPoids et biais de toutes les connexions10³ à 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.

2.3 Lecture d'un modèle en Python

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.

python
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.


3. La distinction et ses conséquences en production

3.1 Tableau de distinction

CritèreAlgorithme d'apprentissageModèle
NatureUne procédureUn artefact
Moment d'existenceAvant toute donnéeAprès l'entraînement
Dépendance aux donnéesNulleTotale
ContenuDes instructionsUne structure et des valeurs de paramètres
Déterminé parUn choix de conception humainLes données d'entraînement
Support matérielDu code, une bibliothèque installéeUn objet en mémoire, un fichier sérialisé
UnicitéUn algorithme, de nombreux modèlesUn 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înerOui
VieillissementPar obsolescence de la bibliothèquePar dérive de la distribution des données (chapitre 082)

3.2 L'analogie de la recette et du gâteau

ANALOGIE — La recette et le gâteau

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 culinaireCorrespondant en apprentissage superviséJustification
La recette écriteL'algorithme d'apprentissageProcédure reproductible, indépendante de toute exécution
Les ingrédientsLe jeu de données d'entraînementMatière première consommée par la procédure
Le réglage du four et le temps de cuissonLes hyperparamètresFixés avant l'exécution, par un humain, non déduits de la matière
L'acte de cuissonL'entraînementExécution de la procédure sur la matière première
Le gâteau obtenuLe modèleRésultat unique, daté, dépendant intégralement des ingrédients
Une part servie à un conviveUne prédictionUsage du résultat sur un cas particulier
Envoyer la recette à un convive affaméDéployer l'algorithme au lieu du modèleLe 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 fraisLe réentraînementMê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).

3.3 Un même algorithme, deux jeux de données, deux modèles

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.

python
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.8

Interpré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é.

3.4 Ce qui est effectivement déployé

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 — Sérialisation d'un modèle

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.

python
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.42

Interpré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.


4. L'entraînement comme procédure de sélection

4.1 Définition

DÉFINITION — Entraînement (training, apprentissage, ajustement, fit)

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).

4.2 Les trois composantes d'une procédure d'entraînement

Modifier l'une de ces trois composantes produit un modèle différent, à jeu de données constant.

4.3 Formes de recherche et reproductibilité

AlgorithmeStratégie de recherche dans HDéterminisme à données constantes
Régression linéaire (moindres carrés)Solution analytique ou décomposition matricielleOui
Régression logistiqueOptimisation numérique convexe itérativeOui, à solveur et tolérance fixés
Arbre de décisionRecherche gloutonne, découpe optimale locale par nœudOui si aucun tirage aléatoire de variables
Forêt aléatoireArbres construits sur échantillons et sous-espaces tirés au hasardNon, sauf graine fixée
Gradient boostingAjout séquentiel d'apprenants corrigeant les résidusNon, sauf graine fixée
k plus proches voisinsAucune recherche : mémorisation du jeu d'entraînementOui
Perceptron multicoucheDescente de gradient stochastique par rétropropagationNon, 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.


5. La prédiction et l'inférence

5.1 Définition

DÉFINITION — Prédiction (prediction, scoring)

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.

5.2 Le modèle comme fonction entrée vers sortie

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).

5.3 Les formes de sortie

AppelSortie produiteFormeDisponibilité
predict(X)Classe prédite ou valeur numériqueVecteur de longueur nTous les estimateurs supervisés
predict_proba(X)Probabilités estimées par classeMatrice n × K, lignes de somme 1Classifieurs à sortie probabiliste
decision_function(X)Score non borné, non calibréVecteur de longueur nModèles à marge, SVM et modèles linéaires
transform(X)Représentation transformée des entréesMatrice 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).

5.4 Inférence au sens du Machine Learning et au sens statistique

DÉFINITION — Inférence : deux acceptions distinctes

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èreInférence au sens MLInférence au sens statistique
Objet viséUne observation individuelleUn paramètre de population
Question poséeQuelle valeur pour ce cas précis ?Quelle est la valeur de θ dans la population, et avec quelle incertitude ?
Sortie produiteUne 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 vuesPropriétés de l'estimateur : biais, convergence, couverture
Hypothèses mobiliséesObservations i.i.d., stabilité de la distributionModèle génératif spécifié, conditions de régularité
Contexte d'emploiIngénierie, production, MLOpsStatistique, é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.

6. Le cycle complet, du jeu de données au modèle sérialisé

ÉtapeEntrée consomméeArtefact produitChapitre
CadrageUne question métierTâche T et métrique P explicitées012
Constitution du jeu de donnéesSources opérationnellesJeu de données étiqueté X, y005 à 007
SéparationJeu completSous-ensembles entraînement, validation, test026, 027
Préparation ajustéeXtrainX_{\mathrm{train}}Transformateurs ajustés022, 023
Choix de l'algorithmeNature du problème et contraintesEspace H et biais inductif retenus049
Sélection des hyperparamètresEntraînement et validationConfiguration λ retenue034, 035
Entraînement finalXtrainX_{\mathrm{train}}, ytrainy_{\mathrm{train}}Modèle ĥ029
ÉvaluationXtestX_{\mathrm{test}}, ytesty_{\mathrm{test}}Mesures de performance en généralisation052 à 075
SérialisationPipeline complet et métadonnéesFichier d'artefact versionné081
ServiceObservations de productionPrédictions081
SurveillanceFlux de productionAlertes de dérive, décision de réentraînement082

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.


7. Erreurs de raisonnement fréquentes

ERREUR — Dire « nous avons déployé un Random Forest »

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. »

ERREUR — Attribuer l'apprentissage à l'algorithme

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. »

ERREUR — Confondre réentraîner et reprogrammer

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. »

ERREUR — Sérialiser l'estimateur sans son pipeline de préparation

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. »

ERREUR — Employer « inférence » sans préciser l'acception

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. »


8. Synthèse

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.md
  • 008.2-quiz-modele-artefact.md
  • 008.3-quiz-distinction-production.md
  • 008.4-quiz-entrainement.md
  • 008.5-quiz-prediction-inference.md
  • 008.6-quiz-cycle-complet.md

Chapitre suivant : 009-parametres-hyperparametres.md