Un modèle entraîné est un objet numérique : il contient des nombres. Ces nombres ne sont pas tous de même nature, et leur confusion est l'une des erreurs les plus fréquentes en début de pratique.
| Catégorie | Origine | Fixé quand | Qui décide |
|---|---|---|---|
| Paramètre | Calculé par la procédure d'optimisation | Pendant l'entraînement | L'algorithme, à partir des données |
| Hyperparamètre | Renseigné avant le lancement de l'entraînement | Avant l'entraînement | L'ingénieur, ou une procédure de recherche |
Le chapitre 008 a distingué l'algorithme, qui est une procédure, du modèle, qui est le résultat de son application à un jeu de données. Les hyperparamètres configurent la procédure ; les paramètres constituent le résultat.
Lecture du diagramme : les hyperparamètres figurent dans le modèle final au même titre que les paramètres, puisqu'ils décrivent sa configuration, mais ils y parviennent par un chemin différent : ils n'ont jamais traversé la procédure d'optimisation.
Quatre objets distincts interviennent dans la confection d'un gâteau, et ils correspondent terme à terme aux quatre objets du Machine Learning.
La recette est la suite d'opérations à conduire : mélanger, incorporer, enfourner, laisser reposer. Elle existe indépendamment de tout gâteau particulier. C'est l'algorithme.
Les réglages sont les décisions prises avant d'enfourner : four à 180 °C, cuisson de 35 minutes, taille du moule. Le pâtissier les fixe en amont ; aucune n'est découverte pendant la cuisson, toutes la conditionnent. Ce sont les hyperparamètres.
Ce que la pâte devient pendant la cuisson — structure de la mie, coloration de la croûte, répartition de l'humidité — n'est décidé par personne : cela résulte de l'interaction entre les ingrédients et les réglages. Ce sont les paramètres appris.
Le gâteau sorti du four est l'objet fini obtenu en appliquant cette recette à ces ingrédients avec ces réglages. C'est le modèle.
Trois conséquences se lisent directement dans l'analogie. Les mêmes ingrédients
et la même recette donnent des gâteaux différents selon les réglages : d'où
l'optimisation des hyperparamètres, traitée au chapitre 035. Il n'existe pas de
température universellement correcte, mais une température adaptée à un gâteau
et à un four : il n'existe pas davantage de max_depth optimal en soi. Enfin,
on ne détermine pas la bonne température en servant le gâteau au jury du
concours puis en recommençant : le jury ne goûte qu'une fois, les essais se font
sur des fournées d'essai. C'est le statut du jeu de test, développé au point 6.
Limite de l'analogie : le pâtissier peut ouvrir le four et observer la cuisson. La formation des paramètres n'est, elle, pas observable pas à pas de façon interprétable. L'analogie décrit les rôles, non la transparence du processus.
Définition rigoureuse
Grandeur interne d'un modèle dont la valeur est déterminée par la procédure d'optimisation appliquée aux données d'entraînement, en vue de minimiser une fonction objectif définie sur ces données. L'ensemble des paramètres, noté usuellement θ, identifie de manière univoque une fonction particulière au sein de la famille de fonctions que l'algorithme est capable de représenter.
Formulation ensembliste
L'algorithme définit une famille de fonctions candidates, appelée espace d'hypothèses et notée H. L'entraînement consiste à sélectionner un élément h ∈ H. Les paramètres sont les coordonnées de cet élément dans H.
Traduction en langage courant
Ce sont les nombres que le modèle a lui-même calculés à partir des données, et qui constituent l'essentiel de ce qu'il a retenu. Ce sont eux qui seront écrits dans le fichier du modèle et rechargés au moment de prédire.
Point de vigilance
Un paramètre n'a de sens que relativement au jeu de données qui l'a produit. Réentraîner le même algorithme sur un autre échantillon produit d'autres paramètres. Un coefficient n'est donc pas une constante physique : c'est une estimation, assortie d'une incertitude d'échantillonnage.
La régression linéaire multiple modélise la cible comme combinaison affine des variables explicatives :
ŷ = b₀ + b₁·x₁ + b₂·x₂ + ... + b_p·x_pLes paramètres appris sont les p coefficients b₁ à et la constante b₀, soit p + 1 valeurs. Aucune autre grandeur n'est mémorisée.
Exemple chiffré — estimation du prix d'un logement
| Variable | Coefficient appris | Interprétation |
|---|---|---|
| Constante (b₀) | 42 300 | Prix de base en dollars, toutes variables nulles |
| Surface habitable (m²) | 2 180 | Chaque m² supplémentaire ajoute 2 180 $ |
| Nombre de chambres | 6 400 | Chaque chambre supplémentaire ajoute 6 400 $ |
| Âge du bien (années) | −870 | Chaque année d'ancienneté retire 870 $ |
| Distance au centre (km) | −3 150 | Chaque km supplémentaire retire 3 150 $ |
Le modèle entier tient dans ces cinq nombres. Pour un logement de 85 m², trois
chambres, douze ans, quatre kilomètres du centre :
ŷ = 42 300 + 2 180×85 + 6 400×3 − 870×12 − 3 150×4 = 224 570 $.
Point de vigilance : la clause « toutes choses égales par ailleurs » suppose que les variables peuvent varier indépendamment les unes des autres, hypothèse rarement vérifiée. La colinéarité est traitée au chapitre 045.
En régression logistique, la structure est identique, la combinaison linéaire étant transformée par une sigmoïde pour produire une probabilité. Les paramètres restent les coefficients et la constante (chapitre 036).
Définition rigoureuse
Dans un perceptron multicouche, chaque neurone d'une couche calcule une somme pondérée des sorties de la couche précédente, augmentée d'un terme constant, puis applique une fonction d'activation non linéaire. Les coefficients de la somme pondérée sont les poids (weights), le terme constant est le biais (bias). Poids et biais constituent l'intégralité des paramètres appris du réseau.
Décompte
Pour une couche recevant m entrées et comportant n neurones, le nombre de paramètres est m × n poids plus n biais.
Traduction en langage courant
Chaque connexion entre deux neurones porte un nombre, qui dit l'importance accordée à ce que transmet la connexion. Chaque neurone porte en plus un nombre qui décale son seuil de déclenchement.
Point de vigilance terminologique
Le mot « biais » possède ici un sens strictement technique : c'est le terme constant d'une transformation affine. Il ne doit pas être confondu avec le biais statistique du compromis biais-variance (chapitre 032), ni avec le biais sociétal d'un modèle discriminatoire (chapitre 080). Trois notions homonymes, trois définitions disjointes.
Exemple chiffré — perceptron multicouche pour un score d'attrition
Architecture : 20 variables en entrée, deux couches cachées de 64 puis 32 neurones, une sortie.
| Transition | Poids | Biais | Total |
|---|---|---|---|
| Entrée → couche 1 | 20 × 64 = 1 280 | 64 | 1 344 |
| Couche 1 → couche 2 | 64 × 32 = 2 048 | 32 | 2 080 |
| Couche 2 → sortie | 32 × 1 = 32 | 1 | 33 |
| Total | 3 360 | 97 | 3 457 |
Ce réseau apprend 3 457 nombres. Le nombre de couches et leur taille — soit
hidden_layer_sizes=(64, 32) — ne sont pas appris : ce sont des
hyperparamètres, et ce sont eux qui déterminent le nombre de paramètres à
apprendre. Un hyperparamètre gouverne donc la quantité de paramètres, ce qui
constitue le lien direct avec la notion de capacité, traitée au point 7.
Un arbre de décision n'a ni coefficient ni poids. Ce qu'il apprend est de nature combinatoire :
Vue partielle : les trois premiers niveaux de l'arbre effectivement obtenu au point 5.3, dont deux branches ont été abrégées.
La valeur 32,50 n'a pas été choisie par un analyste : l'algorithme a évalué les divisions candidates sur chaque variable et retenu celle qui réduisait le plus l'impureté du nœud. Elle est apprise, au même titre qu'un coefficient de régression (mécanisme détaillé au chapitre 037). Ce que l'ingénieur a fixé est le cadre de cette recherche : profondeur maximale, effectif minimal d'une feuille, critère d'impureté.
Définition rigoureuse
Dans la formulation duale d'une machine à vecteurs de support (Boser, Guyon et Vapnik, 1992 ; Cortes et Vapnik, 1995), la solution s'exprime comme une combinaison linéaire de fonctions noyau évaluées sur un sous-ensemble des observations d'entraînement. Les observations dont le coefficient dual est strictement positif sont appelées vecteurs de support : ce sont les seules qui interviennent dans la fonction de décision.
Ce qui est appris
Les coefficients duaux , l'identité des observations retenues comme vecteurs de support, et la constante de décision. Avec un noyau linéaire, ces quantités se recomposent en un vecteur de coefficients homogène à celui d'un modèle linéaire.
Traduction en langage courant
Le modèle retient les exemples d'entraînement situés près de la frontière entre les classes et leur affecte un poids ; les exemples éloignés n'influencent pas la décision.
Point de vigilance
Le nombre de vecteurs de support est un résultat de l'entraînement, jamais une
consigne. Un nombre proche de l'effectif d'entraînement signale une frontière
très irrégulière et un risque de surapprentissage, souvent associé à un gamma
trop grand (chapitre 041).
Définition rigoureuse
Une méthode est dite non paramétrique lorsque la complexité de la fonction apprise n'est pas bornée par un nombre de paramètres fixé a priori, mais croît avec l'effectif des données d'entraînement. Une méthode est dite paresseuse (lazy learning) lorsqu'elle diffère tout calcul de généralisation jusqu'à la requête de prédiction.
Application aux k plus proches voisins
L'appel à fit() sur un KNeighborsClassifier ne calcule aucun coefficient :
il mémorise le jeu d'entraînement et construit éventuellement une structure
d'indexation. Ce qui est « appris » est le jeu de données lui-même : le modèle
ne résume rien, il compare la nouvelle observation aux exemples conservés au
moment de répondre.
Point de vigilance
Non paramétrique ne signifie pas « sans hyperparamètre ». Le nombre de voisins k, la métrique de distance et la pondération sont décisifs (chapitre 040).
| Modèle | Nature des paramètres appris | Nombre pour un cas typique |
|---|---|---|
| Régression linéaire, 20 variables | Coefficients + constante | 21 |
| Régression logistique binaire, 50 variables | Coefficients + constante | 51 |
| Régression logistique, 10 classes, 100 variables | Matrice de coefficients + constantes | 1 010 |
Arbre de décision, max_depth=3 | Variables, seuils, valeurs de feuilles | 15 nœuds dont 8 feuilles |
Arbre de décision, max_depth=10 | Idem | 757 nœuds dont 379 feuilles |
Forêt aléatoire, 300 arbres, max_depth=6 | Idem, agrégé sur 300 arbres | environ 35 000 nœuds |
| Perceptron multicouche (20, 64, 32, 1) | Poids et biais | 3 457 |
| SVM à noyau RBF, 4 000 observations | Vecteurs de support et coefficients duaux | quelques centaines à quelques milliers |
| k plus proches voisins, 4 000 observations | Le jeu d'entraînement mémorisé | 4 000 observations conservées |
Les lignes « arbre » et « forêt » reprennent les valeurs mesurées au point 5. Elles illustrent un fait central : le nombre de paramètres appris n'est pas une propriété de l'algorithme seul, il est déterminé conjointement par les hyperparamètres et par les données.
Définition rigoureuse
Grandeur configurant l'algorithme d'apprentissage, dont la valeur est fixée préalablement à l'exécution de la procédure d'optimisation et n'est pas modifiée par celle-ci. Les hyperparamètres déterminent l'espace d'hypothèses exploré, la fonction objectif effectivement minimisée, la procédure numérique employée et son critère d'arrêt.
Formulation opératoire
Un hyperparamètre est une variable dont la valeur doit être connue pour que l'entraînement puisse commencer, et dont la valeur est inchangée lorsque l'entraînement se termine.
Traduction en langage courant
Ce sont les réglages que l'on écrit soi-même entre les parenthèses du modèle, avant de lancer l'apprentissage.
Origine du préfixe
Le préfixe « hyper- » indique un niveau supérieur : ces grandeurs se situent au-dessus des paramètres, puisqu'elles conditionnent la manière dont ces derniers seront déterminés.
Point de vigilance — homonymie statistique
En statistique bayésienne, « hyperparamètre » désigne un paramètre de la loi de probabilité a priori portant sur les paramètres du modèle. Les deux acceptions partagent la même idée de second niveau, mais ne recouvrent pas les mêmes objets. En contexte d'apprentissage automatique appliqué, c'est l'acception donnée ci-dessus qui prévaut.
| Algorithme | Hyperparamètre | Rôle | Effet d'une augmentation |
|---|---|---|---|
| Régression logistique | C | Inverse de la force de régularisation | Régularisation plus faible, coefficients plus libres, capacité accrue |
| Régression logistique | penalty / l1_ratio | Nature de la pénalité (L1, L2, mixte) | L1 annule des coefficients, L2 les contracte |
| Ridge, Lasso, ElasticNet | alpha | Force de la régularisation | Coefficients plus contraints, capacité réduite |
| Arbre de décision | max_depth | Profondeur maximale | Arbre plus profond, capacité accrue, surapprentissage probable |
| Arbre de décision | min_samples_leaf | Effectif minimal d'une feuille | Feuilles plus peuplées, arbre plus régulier, capacité réduite |
| Arbre de décision | ccp_alpha | Coût de complexité pour l'élagage | Élagage plus agressif, capacité réduite |
| Forêt aléatoire | n_estimators | Nombre d'arbres agrégés | Variance de prédiction réduite, coût de calcul accru |
| Forêt aléatoire | max_features | Variables candidates par division | Arbres plus corrélés entre eux, gain de l'agrégation réduit |
| Gradient boosting | learning_rate | Pas de contraction de chaque arbre | Apprentissage plus rapide, risque de surapprentissage accru |
| Gradient boosting | n_estimators | Nombre d'itérations de boosting | Capacité accrue, surapprentissage possible sans arrêt anticipé |
| Gradient boosting | subsample | Fraction d'observations par itération | Moins de régularisation stochastique lorsqu'elle tend vers 1 |
| k plus proches voisins | n_neighbors (k) | Nombre de voisins consultés | Frontière plus lisse, capacité réduite |
| SVM | C | Pénalisation des violations de marge | Marge plus étroite, ajustement plus strict aux données |
| SVM | kernel, gamma | Forme de la frontière | gamma élevé : frontière très locale, surapprentissage |
| Perceptron multicouche | hidden_layer_sizes | Architecture du réseau | Plus de paramètres à apprendre, capacité accrue |
| Perceptron multicouche | alpha | Régularisation L2 des poids | Poids plus contraints, capacité réduite |
Point de vigilance sur C et alpha : ces deux hyperparamètres régissent
la même chose — la force de la régularisation — mais dans des sens opposés.
alpha est proportionnel à la force de la pénalité ; C en est l'inverse.
Augmenter alpha régularise davantage ; augmenter C régularise moins. Cette
inversion est une source d'erreur constante en entretien technique.
Définition rigoureuse
La régularisation ajoute à la fonction de perte un terme pénalisant la magnitude
des paramètres, afin de restreindre l'espace des solutions admissibles. Le
problème résolu devient la minimisation de
J(θ) = perte_sur_les_données(θ) + λ · pénalité(θ). Ridge et Lasso exposent
directement λ sous le nom alpha ; la régression logistique et les SVM exposent
C, défini comme l'inverse de λ à une constante près.
Traduction en langage courant
alpha est un frein : plus il est grand, plus le modèle est bridé. C est une
autorisation : plus il est grand, plus le modèle est libre de coller aux
données.
Point de vigilance
La régularisation n'a de sens que sur des variables d'échelle comparable : pénaliser des coefficients portant sur des unités hétérogènes revient à pénaliser arbitrairement certaines variables. Standardisation au chapitre 023, régularisation au chapitre 047.
Définition rigoureuse
Coefficient multiplicatif appliqué à la direction de mise à jour des paramètres
à chaque itération d'une optimisation itérative : dans une descente de gradient,
θ_(t+1) = θ_t − η · ∇J(θ_t), où η désigne le taux d'apprentissage. En gradient
boosting, le même réglage s'interprète comme un facteur de contraction appliqué
à la contribution de chaque estimateur ajouté.
Traduction en langage courant
La taille du pas effectué à chaque correction. Un pas trop grand fait manquer le minimum et peut faire diverger l'apprentissage ; un pas trop petit ne progresse pas assez vite pour le budget d'itérations disponible.
Point de vigilance
learning_rate et n_estimators sont couplés en boosting : diviser le taux
d'apprentissage par deux impose approximativement de doubler le nombre
d'itérations pour atteindre un ajustement comparable. Ces deux hyperparamètres
ne doivent donc jamais être réglés indépendamment l'un de l'autre.
Traité au chapitre 039.
Tous les hyperparamètres n'ont pas la même portée. Les classer par fonction évite de les régler au hasard.
Les hyperparamètres de capacité sont déterminants et se règlent en priorité ; ceux d'optimisation pèsent surtout en boosting et en réseaux de neurones ; ceux de structure d'ensemble ont des rendements rapidement décroissants ; ceux de traitement du problème deviennent critiques en contexte déséquilibré ou à coûts d'erreur asymétriques ; ceux d'exécution n'ont aucune incidence en espérance sur la performance.
Point de vigilance sur random_state : cet argument est formellement un
hyperparamètre — il est fixé avant l'entraînement et n'est pas ajusté par la
procédure. Il ne doit cependant jamais être inclus dans une recherche
d'optimisation. Sélectionner la graine qui maximise le score de validation
revient à exploiter le bruit d'échantillonnage, non à améliorer le modèle. Le
rôle légitime de random_state est la reproductibilité.
Une seule question sépare les deux catégories, quelle que soit la bibliothèque ou l'algorithme employé :
Cette grandeur est-elle ajustée par la procédure d'optimisation exécutée pendant
fit(), ou est-elle fixée avant que cette procédure ne démarre ?
Règle normative de la bibliothèque
Dans l'API de scikit-learn, la distinction est matérialisée dans le nommage :
get_params(), modifiables par set_params(), et
leur nom ne comporte pas de suffixe ;fit() portent un nom suffixé par un
caractère de soulignement : coef_, intercept_, feature_importances_,
classes_, tree_, estimators_, support_vectors_.Conséquence pratique
Accéder à un attribut suffixé avant tout appel à fit() lève une exception
NotFittedError. C'est le test le plus rapide pour trancher : un attribut qui
n'existe pas avant l'entraînement est nécessairement appris.
Point de vigilance terminologique
La méthode s'appelle get_params() alors qu'elle retourne les hyperparamètres.
Ce choix de nommage tient à la terminologie générale de la programmation, où
« paramètre » désigne un argument de fonction. Il entretient une confusion
regrettable avec la terminologie statistique. Dans ce cours, et en entretien,
« paramètre » conserve toujours son sens statistique : grandeur estimée à partir
des données.
| Grandeur | Catégorie | Justification |
|---|---|---|
coef_ d'une régression logistique | Paramètre | Calculé par le solveur pour minimiser la perte |
C d'une régression logistique | Hyperparamètre | Doit être connu avant l'appel au solveur |
Seuil 32,50 sur anciennete_mois dans un arbre | Paramètre | Sélectionné par la recherche de division |
max_depth d'un arbre | Hyperparamètre | Borne la recherche, n'est pas issu d'elle |
feature_importances_ d'une forêt | Paramètre dérivé | Calculé à partir de la structure apprise |
n_estimators d'une forêt | Hyperparamètre | Fixe le nombre d'arbres à construire |
max_iter d'un solveur | Hyperparamètre | Budget accordé avant démarrage |
n_iter_ d'un solveur | Résultat d'exécution | Nombre d'itérations réellement consommées |
mean_ et scale_ d'un StandardScaler | Paramètre du transformateur | Estimés sur les données d'entraînement |
k d'un KNeighborsClassifier | Hyperparamètre | Fixé avant, jamais optimisé par fit() |
| Nombre de vecteurs de support obtenus | Résultat d'exécution | Conséquence de l'optimisation duale |
| Nombre de composantes d'une ACP | Hyperparamètre | Choisi avant ; les axes, eux, sont appris |
| Seuil de décision à 0,50 | Hyperparamètre de décision | Convention par défaut, non issue de fit() |
random_state | Hyperparamètre d'exécution | Fixé avant, mais ne doit pas être optimisé |
Cas limite 1 — Les statistiques d'un préprocesseur. La moyenne et l'écart
type d'un StandardScaler sont estimés à partir des données : ce sont des
paramètres au sens de la procédure fit(), même s'ils n'appartiennent pas au
modèle prédictif. Conséquence décisive : ils s'estiment sur le seul jeu
d'entraînement puis s'appliquent tels quels aux autres jeux. Les estimer sur
l'ensemble des données constitue une fuite d'information (chapitre 028).
Cas limite 2 — L'arrêt anticipé. Avec early_stopping=True, le nombre
d'itérations retenu est déterminé par la procédure elle-même, en observant la
perte sur un jeu de validation interne. La frontière semble se brouiller ; elle
ne se brouille pas. La décision d'activer l'arrêt anticipé, la taille de ce jeu
interne, la patience et la métrique surveillée restent des hyperparamètres fixés
en amont ; le nombre d'itérations retenu est un résultat.
Cas limite 3 — Les hyperparamètres optimisés automatiquement. Qu'une
recherche sur grille détermine max_depth ne le transforme pas en paramètre :
la recherche est une boucle externe qui relance des entraînements complets,
chacun avec une valeur fixée d'avance. Un paramètre est ajusté à l'intérieur
d'un entraînement, un hyperparamètre est choisi entre plusieurs entraînements
(chapitre 035).
Cas limite 4 — Les paramètres dérivés. feature_importances_ n'est pas
optimisé directement : c'est une statistique calculée après coup à partir des
réductions d'impureté de la structure apprise. Elle relève néanmoins des
grandeurs apprises, puisqu'elle n'existe pas avant fit() et dépend entièrement
des données. Même remarque pour le coef_ d'une SVM linéaire, recomposé à
partir des coefficients duaux.
get_params() contre coef_ et feature_importances_Le jeu de données de démonstration décrit 4 000 clients d'un opérateur télécom,
avec cinq variables explicatives et une cible binaire a_resilie dont le taux
de positifs vaut 0,3795.
get_params()from sklearn.linear_model import LogisticRegression
from sklearn.preprocessing import StandardScaler
import pandas as pd, numpy as np
Xs = pd.DataFrame(StandardScaler().fit_transform(X), columns=X.columns)
lr = LogisticRegression(C=1.0, max_iter=1000, random_state=0)
lr.fit(Xs, y)
for k, v in sorted(lr.get_params().items()):
print(f"{k}: {v!r}")C: 1.0
class_weight: None
dual: False
fit_intercept: True
intercept_scaling: 1
l1_ratio: 0.0
max_iter: 1000
n_jobs: None
penalty: 'deprecated'
random_state: 0
solver: 'lbfgs'
tol: 0.0001
verbose: 0
warm_start: FalseInterprétation. Quatorze réglages sont exposés alors que trois seulement ont
été renseignés ; les onze autres sont les valeurs par défaut de l'estimateur.
Toutes étaient connues avant fit() et aucune n'a été modifiée par lui : un
second appel après entraînement retourne le même dictionnaire.
Point de vigilance sur les valeurs par défaut. Un modèle instancié sans
argument n'est pas un modèle « sans hyperparamètres » : c'est un modèle dont
tous les hyperparamètres ont pris leur valeur par défaut, qui sont des
conventions de bibliothèque et non des optima. C=1.0 régularise déjà
substantiellement.
Point de vigilance sur les versions. La sortie provient de scikit-learn 1.8,
où penalty est en cours de dépréciation au profit de l1_ratio, la valeur
0.0 désignant une pénalité L2 pure ; les versions antérieures affichent
penalty: 'l2'. Les hyperparamètres appartiennent à l'interface d'une
bibliothèque et évoluent avec elle ; les paramètres appris relèvent de la
formulation mathématique du modèle et ne changent pas de nom.
coef_ et intercept_print(pd.Series(np.round(lr.coef_[0], 4), index=X.columns).to_string())
print("intercept_:", np.round(lr.intercept_, 4))
print("n_iter_:", lr.n_iter_)
print("classes_:", lr.classes_)anciennete_mois -0.8957
facture_mensuelle 0.5515
nb_appels_support 0.5829
satisfaction -0.7586
data_go_moyen -0.0216
intercept_: [-0.6809]
n_iter_: [6]
classes_: [0 1]Interprétation. Ces six nombres — cinq coefficients et une constante — constituent l'intégralité de ce que le modèle a appris, et aucun n'a été écrit par l'ingénieur. Les variables ayant été standardisées, les coefficients sont comparables entre eux : l'ancienneté domine, la consommation de données est négligeable.
| Variable | Coefficient | Rapport de cotes | Lecture métier |
|---|---|---|---|
anciennete_mois | −0,8957 | 0,41 | Un écart type d'ancienneté supplémentaire divise la cote de résiliation par 2,4 |
satisfaction | −0,7586 | 0,47 | Un écart type de satisfaction supplémentaire divise la cote par 2,1 |
nb_appels_support | +0,5829 | 1,79 | Un écart type d'appels supplémentaire multiplie la cote par 1,8 |
facture_mensuelle | +0,5515 | 1,74 | Effet comparable, de même sens |
data_go_moyen | −0,0216 | 0,98 | Aucun effet exploitable |
Point de vigilance. n_iter_ et classes_ portent un underscore final et
n'existent qu'après fit(), sans être de même nature que coef_. n_iter_ est
un diagnostic de convergence : la valeur 6, très inférieure au budget
max_iter=1000, indique une convergence sans interruption. Une valeur égale à
max_iter signalerait un arrêt sur épuisement du budget, donc un modèle non
convergé.
from sklearn.tree import DecisionTreeClassifier, export_text
dt = DecisionTreeClassifier(max_depth=3, min_samples_leaf=50, random_state=0)
dt.fit(X, y)
print("noeuds:", dt.tree_.node_count, "profondeur:", dt.get_depth(),
"feuilles:", dt.get_n_leaves())
print(export_text(dt, feature_names=list(X.columns), decimals=2))
print(pd.Series(np.round(dt.feature_importances_, 4), index=X.columns).to_string())noeuds: 15 profondeur: 3 feuilles: 8
|--- anciennete_mois <= 32.50
| |--- satisfaction <= 2.50
| | |--- nb_appels_support <= 0.50
| | | |--- class: 1
| | |--- nb_appels_support > 0.50
| | | |--- class: 1
| |--- satisfaction > 2.50
| | |--- facture_mensuelle <= 59.15
| | | |--- class: 0
| | |--- facture_mensuelle > 59.15
| | | |--- class: 1
|--- anciennete_mois > 32.50
| |--- satisfaction <= 2.50
| | |--- nb_appels_support <= 1.50
| | | |--- class: 0
| | |--- nb_appels_support > 1.50
| | | |--- class: 1
| |--- satisfaction > 2.50
| | |--- facture_mensuelle <= 59.45
| | | |--- class: 0
| | |--- facture_mensuelle > 59.45
| | | |--- class: 0
anciennete_mois 0.4497
facture_mensuelle 0.1065
nb_appels_support 0.1156
satisfaction 0.3282
data_go_moyen 0.0000Ce qui a été imposé. Deux valeurs seulement, max_depth=3 et
min_samples_leaf=50. La profondeur obtenue vaut exactement 3 : la contrainte
est active, sans elle l'arbre aurait continué de croître.
Ce qui a été appris. Sept divisions internes, chacune définie par un couple
(variable, seuil), et huit feuilles avec leur distribution de classes. Les
valeurs 32,50, 2,50, 59,15, 0,50, 1,50 et 59,45 sont toutes issues de la
recherche de division. Que facture_mensuelle soit coupée à 59,15 dans une
branche et à 59,45 dans une autre montre qu'il s'agit de grandeurs estimées
localement, non de seuils métier.
Les importances. feature_importances_ est un vecteur sommant à 1 qui
répartit la réduction totale d'impureté entre les variables. data_go_moyen
obtient 0,0000 : sous cette contrainte de profondeur, la variable n'a jamais été
retenue pour une division. Ce zéro ne signifie donc pas « sans lien avec la
cible » mais « jamais sélectionnée dans ces conditions » ; une profondeur
supérieure lui attribuerait une importance non nulle. Limites de cet indicateur
au chapitre 080.
Deux paires de sous-branches aboutissent à la même classe prédite. La division a malgré tout été retenue parce qu'elle réduit l'impureté : les probabilités prédites diffèrent, même lorsque la classe majoritaire coïncide (chapitre 029).
for d in [2, 3, 5, 10, None]:
m = DecisionTreeClassifier(max_depth=d, random_state=0).fit(X, y)
print(f"max_depth={str(d):>4} -> noeuds={m.tree_.node_count:>5}"
f" feuilles={m.get_n_leaves():>5} acc_train={m.score(X, y):.4f}")max_depth= 2 -> noeuds= 7 feuilles= 4 acc_train=0.6980
max_depth= 3 -> noeuds= 15 feuilles= 8 acc_train=0.7202
max_depth= 5 -> noeuds= 63 feuilles= 32 acc_train=0.7445
max_depth= 10 -> noeuds= 757 feuilles= 379 acc_train=0.8498
max_depth=None -> noeuds= 2033 feuilles= 1017 acc_train=1.0000Interprétation. Un unique hyperparamètre fait passer le modèle de 7 à 2 033 nœuds appris, soit un facteur 290, et l'exactitude d'entraînement progresse jusqu'à 1,0000 : l'arbre non contraint isole chaque observation. Cette valeur n'est pas une réussite mais une mémorisation — sur des données bruitées où le taux de positifs vaut 0,38, aucun modèle honnête ne classe parfaitement son jeu d'entraînement (chapitre 031).
for C in [0.001, 0.01, 0.1, 1.0, 100.0]:
m = LogisticRegression(C=C, max_iter=1000).fit(Xs, y)
print(f"C={C:<8} coef_={np.round(m.coef_[0], 3)} "
f"norme_L2={np.linalg.norm(m.coef_):.3f}")C=0.001 coef_=[-0.336 0.205 0.22 -0.283 -0.002] norme_L2=0.533
C=0.01 coef_=[-0.737 0.451 0.479 -0.623 -0.014] norme_L2=1.168
C=0.1 coef_=[-0.877 0.539 0.57 -0.742 -0.021] norme_L2=1.392
C=1.0 coef_=[-0.896 0.551 0.583 -0.759 -0.022] norme_L2=1.422
C=100.0 coef_=[-0.898 0.553 0.584 -0.76 -0.022] norme_L2=1.425Interprétation. C ne figure jamais dans coef_ mais en gouverne
l'amplitude : la norme des coefficients passe de 0,533 à 1,425 lorsque C croît
de 0,001 à 100. La contraction est uniforme et conserve l'ordre des variables.
Au-delà de C=1, les coefficients ne bougent pratiquement plus : la pénalité
est devenue négligeable devant le terme de perte. Explorer C=10 000 serait
sans effet ici, ce qui justifie les grilles logarithmiques bornées
(chapitre 035).
Formulation à retenir : les hyperparamètres ne sont pas dans le modèle à côté des paramètres, ils sont les contraintes sous lesquelles les paramètres ont été calculés.
Régler un hyperparamètre suppose de comparer plusieurs entraînements et de retenir le meilleur, ce qui exige un jeu non utilisé pour l'ajustement des paramètres. La tentation est d'employer le jeu de test, puisque c'est lui qui porte l'estimation de performance. C'est précisément l'usage qui lui est interdit.
Toute décision prise en regardant un jeu de données transfère de l'information de ce jeu vers le modèle. Ce jeu cesse alors d'être inédit, et le score qu'il produit cesse d'estimer la performance sur des données nouvelles.
| Jeu | Ce qui y est décidé | Nombre de consultations | Ce que son score estime |
|---|---|---|---|
| Entraînement | Les paramètres du modèle | Une fois par entraînement | La capacité à restituer les données vues, sans valeur prédictive |
| Validation | Les hyperparamètres, l'algorithme, le seuil, les variables retenues | Une fois par configuration essayée | Une performance optimiste, biaisée par la sélection |
| Test | Rien | Une seule fois, à la fin | La performance attendue sur données nouvelles |
Le score obtenu sur un jeu fini est entaché d'une variabilité d'échantillonnage : sur 800 observations de validation, l'écart type d'une exactitude voisine de 0,75 vaut environ 0,015. Comparer K configurations et retenir le maximum revient à sélectionner, parmi K tirages bruités, celui dont le bruit est le plus favorable.
| Configurations comparées | Écart attendu entre le maximum observé et la vraie performance |
|---|---|
| 1 | environ 0,000 |
| 10 | environ +0,023 |
| 50 | environ +0,032 |
| 200 | environ +0,040 |
Ces ordres de grandeur correspondent à l'espérance du maximum de K variables gaussiennes centrées d'écart type 0,015. La conclusion est structurelle et ne dépend pas du soin apporté à la démarche : le score de la configuration retenue est optimiste par construction. Un jeu supplémentaire, resté hors de toute décision, est donc nécessaire pour obtenir une estimation non biaisée.
Renvois : la construction des trois jeux est traitée au chapitre 026, les schémas de découpage particuliers au chapitre 027, la validation croisée au chapitre 034, les procédures de recherche d'hyperparamètres au chapitre 035, et le choix du seuil de décision au chapitre 062.
Définition rigoureuse
Mesure de la richesse de la famille de fonctions qu'un algorithme, configuré d'une certaine manière, est en mesure de représenter. Elle est formalisée par la dimension de Vapnik-Chervonenkis (Vapnik et Chervonenkis, 1971) — cardinal du plus grand ensemble de points que la famille peut séparer selon tous les étiquetages possibles — ou par des mesures apparentées telles que la complexité de Rademacher.
Rôle respectif des deux catégories de grandeurs
Les hyperparamètres délimitent l'espace d'hypothèses H ; les paramètres sélectionnent un élément h à l'intérieur de H. Augmenter la capacité, c'est élargir H.
Traduction en langage courant
Jusqu'à quel point un modèle peut épouser la forme des données. Une capacité insuffisante l'empêche de représenter le phénomène ; une capacité excessive lui permet d'épouser aussi le bruit.
Point de vigilance
La capacité n'est pas la performance : un arbre non contraint atteint une exactitude parfaite sur l'entraînement et peut être médiocre sur données nouvelles (point 5.4).
| Hyperparamètre | Augmenter sa valeur | Capacité | Risque dominant si poussé à l'extrême |
|---|---|---|---|
max_depth | Arbre plus profond | Augmente | Surapprentissage |
min_samples_leaf | Feuilles plus peuplées | Diminue | Sous-apprentissage |
alpha (Ridge, Lasso, MLP) | Pénalité plus forte | Diminue | Sous-apprentissage |
C (logistique, SVM) | Pénalité plus faible | Augmente | Surapprentissage |
n_neighbors (k) | Voisinage plus large | Diminue | Sous-apprentissage |
hidden_layer_sizes | Réseau plus large ou plus profond | Augmente | Surapprentissage |
gamma (noyau RBF) | Influence plus locale | Augmente | Surapprentissage marqué |
learning_rate (boosting) | Pas plus grand | Augmente à budget d'itérations fixé | Surapprentissage |
n_estimators (forêt aléatoire) | Plus d'arbres agrégés | Stabilise la variance | Coût de calcul, sans dégradation notable |
Point de vigilance sur n_estimators. La dernière ligne fait exception.
Dans une forêt aléatoire, augmenter le nombre d'arbres réduit la variance de
l'agrégat sans accroître le surapprentissage, avec des rendements rapidement
décroissants. En boosting, chaque itération corrige les résidus des
précédentes : n_estimators y augmente la capacité et doit être borné, par
arrêt anticipé ou par validation. Une même dénomination recouvre donc deux
comportements opposés selon la famille d'algorithmes.
Le compromis. Une capacité insuffisante produit une erreur systématique, le biais : le modèle échoue aussi bien sur l'entraînement que sur le test. Une capacité excessive produit une sensibilité au jeu d'entraînement particulier, la variance : le modèle réussit sur l'entraînement et échoue sur données nouvelles. Régler les hyperparamètres de capacité revient à arbitrer entre ces deux régimes. Compromis biais-variance au chapitre 032, surapprentissage et sous-apprentissage au chapitre 031, leviers de correction au chapitre 033.
Ces cinq notions sont introduites ici parce qu'elles sont indissociables de la distinction précédente : la perte est ce que l'optimisation minimise pour produire les paramètres, la métrique est ce que la validation compare pour choisir les hyperparamètres, le seuil et la référence naïve sont deux décisions d'ingénierie que rien n'apprend. Chacune est traitée en profondeur plus loin.
Définition rigoureuse
Fonction ℓ(y, ŷ) associant à un couple formé d'une valeur observée et d'une valeur prédite un réel positif mesurant le coût de l'écart. Sa moyenne sur le jeu d'entraînement constitue le risque empirique, quantité effectivement minimisée par la procédure d'optimisation. On parle indifféremment de fonction de coût, de fonction objectif ou de critère.
Traduction en langage courant
La mesure de l'erreur que le modèle cherche à faire diminuer pendant qu'il apprend. Ce sont les points perdus, et l'apprentissage consiste à en perdre le moins possible.
Contrainte technique
Une fonction de perte doit être optimisable par la procédure employée : le plus souvent différentiable, ou au moins décomposable en critères locaux, ce qui exclut la plupart des métriques métier.
Point de vigilance
La perte est calculée sur le jeu d'entraînement pendant l'apprentissage. Une perte faible sur l'entraînement ne renseigne en rien sur la généralisation. La comparaison des pertes d'entraînement et de validation est traitée au chapitre 030.
| Tâche | Perte usuelle | Ce qu'elle pénalise |
|---|---|---|
| Régression | Erreur quadratique moyenne (MSE) | Le carré de l'écart, donc fortement les grands écarts |
| Régression robuste | Erreur absolue (MAE), perte de Huber | Linéairement, donc moins sensible aux valeurs extrêmes |
| Classification probabiliste | Entropie croisée, log loss | La confiance accordée à une prédiction fausse |
| SVM | Perte charnière (hinge) | Les violations de la marge |
| Division d'un arbre | Impureté de Gini, entropie | L'hétérogénéité des classes dans un nœud |
Définition rigoureuse
Grandeur calculée à partir des prédictions d'un modèle et des valeurs observées, destinée à qualifier sa performance en vue d'une comparaison ou d'une décision. Elle n'intervient pas dans l'optimisation des paramètres et n'est soumise à aucune contrainte de dérivabilité.
Traduction en langage courant
Le chiffre que l'on présente pour dire si le modèle est bon, et selon quel critère.
Distinction avec la perte
La perte sert à l'apprentissage, la métrique sert au jugement. Un classifieur peut minimiser l'entropie croisée tout en étant évalué au rappel : ce sont deux grandeurs différentes calculées sur les mêmes prédictions.
Point de vigilance
La métrique s'aligne sur l'enjeu métier, pas sur la commodité mathématique. Le choix de la métrique est traité aux chapitres 052 à 075, et le principe directeur du cours est rappelé au chapitre 075 : la question n'est pas quelle métrique est la meilleure, mais quelle erreur coûte le plus cher.
| Critère | Fonction de perte | Métrique d'évaluation |
|---|---|---|
| Finalité | Guider l'optimisation | Qualifier et communiquer |
| Utilisatrice | La procédure fit() | L'ingénieur et le décideur métier |
| Contrainte | Optimisable, généralement dérivable | Aucune |
| Moment du calcul | À chaque itération de l'entraînement | Après prédiction, sur un jeu réservé |
| Exemples | MSE, log loss, hinge, Gini | Exactitude, précision, rappel, F1, AUC, MAE, R² |
| Choisie par | Largement imposée par l'algorithme | L'ingénieur, selon le coût des erreurs |
Un étudiant révise pour un examen. Le barème de correction lui dit combien de points il perd sur chaque type d'erreur : c'est ce qu'il cherche à minimiser en travaillant. C'est la fonction de perte.
La mention portée sur son relevé — passable, bien, très bien — est ce que l'employeur regardera. C'est la métrique.
Les deux se calculent sur la même copie et ne coïncident pas : deux copies ayant perdu le même nombre de points peuvent recevoir des appréciations différentes selon la répartition des erreurs entre les épreuves.
Optimiser le barème sans jamais regarder la mention est une erreur de méthode courante : un modèle dont la perte diminue régulièrement peut voir sa métrique métier stagner ou se dégrader.
Définition rigoureuse
Le terme recouvre deux acceptions distinctes qu'il convient de ne jamais confondre.
Acception 1 — score de sortie du modèle. Valeur continue produite par le
modèle pour une observation, avant toute décision : probabilité estimée
retournée par predict_proba(), ou valeur non calibrée retournée par
decision_function(). Un score n'est pas une classe.
Acception 2 — score de performance. Valeur numérique d'une métrique
d'évaluation sur un jeu de données. C'est le sens de model.score(X, y) en
scikit-learn, qui retourne l'exactitude pour un classifieur et le coefficient de
détermination R² pour un régresseur.
Convention de scikit-learn
Les fonctions d'évaluation suivent la règle « plus grand est meilleur ». Les
métriques d'erreur, qu'il faut minimiser, sont donc exposées sous forme
négative : neg_mean_squared_error, neg_log_loss. Une valeur négative
affichée par une recherche sur grille n'est pas une anomalie.
Point de vigilance
Annoncer « le score du modèle est de 0,91 » n'a aucune valeur informative tant que la métrique et le jeu de données ne sont pas nommés.
Définition rigoureuse
Valeur de coupure appliquée au score continu produit par un classifieur pour convertir ce score en décision discrète. Pour un problème binaire, l'observation est affectée à la classe positive lorsque le score estimé est supérieur ou égal au seuil.
Traduction en langage courant
À partir de quel niveau de probabilité on décide d'agir.
Statut au regard du chapitre
Le seuil n'est pas appris. La valeur 0,50 est une convention par défaut, non un optimum. Le seuil est un hyperparamètre de décision, dont le réglage se conduit sur un jeu de validation, jamais sur le jeu de test.
Point de vigilance
Abaisser le seuil augmente le nombre de positifs prédits, donc le rappel, au détriment de la précision ; l'élever produit l'effet inverse. Le réglage relève d'un arbitrage économique entre le coût d'un faux positif et celui d'un faux négatif. Traité aux chapitres 029 et 062.
Définition rigoureuse
Modèle de référence délibérément trivial, servant de borne inférieure à laquelle comparer tout modèle candidat. Sa performance constitue le seuil en deçà duquel un modèle appris n'apporte aucune valeur.
Références usuelles
| Tâche | Référence naïve | Mise en oeuvre |
|---|---|---|
| Classification | Prédire systématiquement la classe majoritaire | DummyClassifier(strategy="most_frequent") |
| Classification | Tirer au hasard selon les fréquences observées | DummyClassifier(strategy="stratified") |
| Régression | Prédire la moyenne de la cible | DummyRegressor(strategy="mean") |
| Régression | Prédire la médiane de la cible | DummyRegressor(strategy="median") |
| Séries temporelles | Reconduire la dernière valeur observée | Modèle de persistance |
| Contexte industriel | La règle métier actuellement en production | Réimplémentation de la règle existante |
Traduction en langage courant
Avant d'affirmer qu'un modèle est performant, il faut vérifier qu'il fait mieux qu'une stratégie idiote.
Point de vigilance
Sur un jeu déséquilibré à 2 % de positifs, la référence naïve « classe majoritaire » atteint 98 % d'exactitude sans rien apprendre. Une exactitude de 97 % annoncée pour un modèle sophistiqué constitue alors une régression. C'est la raison pour laquelle toute évaluation commence par le calcul de la référence. Traité aux chapitres 049 et 050.
| Notion | Rôle dans la chaîne | Qui la détermine | Chapitre de traitement |
|---|---|---|---|
| Fonction de perte | Guide l'ajustement des paramètres | Imposée par l'algorithme, parfois configurable | 030 |
| Métrique | Compare les modèles et les configurations | L'ingénieur, selon l'enjeu métier | 052 à 075 |
| Score | Sortie continue, ou valeur d'une métrique | Le modèle, ou la métrique choisie | 029, 061, 063 |
| Seuil | Convertit un score en décision | L'ingénieur, sur jeu de validation | 062, 088 |
| Référence naïve | Fixe la borne de valeur ajoutée | L'ingénieur, avant toute modélisation | 049 |
L'expression « j'ai paramétré mon modèle avec max_depth égal à 5 » est
ambiguë et la méthode get_params() entretient la confusion, puisqu'elle
retourne en réalité les hyperparamètres. La terminologie de la programmation et
celle de la statistique divergent ici.
Formulation correcte : « J'ai fixé l'hyperparamètre max_depth à 5. Les
paramètres du modèle sont les seuils et la structure de l'arbre, que
l'entraînement a déterminés. »
Aucune valeur d'hyperparamètre n'est optimale en soi. La valeur adéquate dépend de l'effectif, du nombre de variables, du niveau de bruit et de la structure du phénomène. Une valeur reprise d'un billet de blog ou d'un projet antérieur est une hypothèse de départ, pas un réglage.
Formulation correcte : « max_depth=5 s'est révélé le meilleur compromis
sur ce jeu de données, à l'issue d'une recherche validée par validation
croisée. »
Le jeu de test doit rester à l'écart de toute décision. Dès qu'une configuration y est comparée à une autre, il exerce la fonction d'un jeu de validation et le score final devient optimiste. La contamination est progressive et ne produit aucun signal d'alerte.
Formulation correcte : « Les hyperparamètres ont été sélectionnés par validation croisée sur le jeu d'entraînement. Le jeu de test n'a été consulté qu'une fois, pour l'estimation finale. »
La moyenne et l'écart type d'un StandardScaler, les modalités retenues par un
encodeur, les valeurs d'imputation sont estimées à partir des données. Les
calculer sur l'ensemble du jeu avant le découpage transfère de l'information du
test vers l'entraînement.
Formulation correcte : « Ces statistiques sont des grandeurs apprises. Elles s'estiment sur le seul jeu d'entraînement, à l'intérieur d'un pipeline, et s'appliquent ensuite aux autres jeux. » Traité aux chapitres 028 et 076.
Une perte d'entraînement qui diminue régulièrement ne garantit ni la généralisation, ni la satisfaction du critère métier. Les deux grandeurs répondent à des finalités différentes et peuvent évoluer en sens contraire.
Formulation correcte : « Le modèle minimise l'entropie croisée pendant l'entraînement ; il est évalué au rappel, parce que le coût d'un faux négatif domine dans ce cas d'usage. »
Un arbre non contraint atteint une exactitude de 1,0000 sur ses données d'entraînement, comme le montre le point 5.4. Cette valeur mesure une mémorisation, non une aptitude à généraliser. Au-delà d'un certain niveau de capacité, l'erreur sur données nouvelles augmente.
Formulation correcte : « Au-delà d'un certain niveau de capacité, le modèle ajuste le bruit du jeu d'entraînement ; l'erreur de généralisation se dégrade alors que l'erreur d'entraînement continue de diminuer. »
La graine aléatoire est fixée avant l'entraînement, ce qui en fait formellement un hyperparamètre, mais elle ne porte aucune information sur le phénomène. Retenir la graine qui maximise le score de validation revient à sélectionner du bruit et produit un gain qui ne se reproduira pas.
Formulation correcte : « random_state est fixé pour garantir la
reproductibilité. La sensibilité du modèle à la graine se mesure, elle ne
s'optimise pas. »
predict() applique une convention par défaut. Le modèle produit un score
continu ; c'est la bibliothèque, non l'apprentissage, qui le coupe à 0,50.
Formulation correcte : « Le seuil est une décision d'ingénierie, réglée sur un jeu de validation en fonction du coût respectif des faux positifs et des faux négatifs. »
LES DEUX CATÉGORIES
PARAMÈTRE appris par la procédure d'optimisation, pendant fit()
coefficients, poids et biais, seuils et structure d'un arbre,
coefficients duaux et vecteurs de support
HYPERPARAMÈTRE fixé par l'ingénieur, avant fit()
max_depth, n_estimators, k, learning_rate, alpha, C
LE CRITÈRE UNIQUE DE DISTINCTION
Cette grandeur est-elle ajustée par la procédure d'optimisation,
ou devait-elle être connue pour que cette procédure démarre ?
LA CONVENTION SCIKIT-LEARN
get_params() -> les hyperparamètres
attribut_ (underscore) -> les grandeurs apprises
coef_, intercept_, feature_importances_, tree_, support_vectors_
Avant fit(), ces attributs n'existent pas : NotFittedError.
L'ANALOGIE DE RÉFÉRENCE
recette = algorithme
réglages du four = hyperparamètres
ce que la pâte devient = paramètres appris
gâteau = modèle
CE QUE GOUVERNENT LES HYPERPARAMÈTRES
la capacité max_depth, C, alpha, k, hidden_layer_sizes
l'optimisation learning_rate, solver, max_iter, tol
la structure d'ensemble n_estimators, max_features, subsample
le traitement du problème class_weight, criterion, seuil
l'exécution n_jobs, verbose, random_state
CAPACITÉ
Les hyperparamètres délimitent l'espace d'hypothèses H.
Les paramètres sélectionnent un élément h dans H.
Capacité trop faible -> biais élevé, sous-apprentissage.
Capacité trop forte -> variance élevée, surapprentissage.
RÈGLE DE PROTOCOLE
Entraînement -> ajuste les paramètres
Validation -> choisit les hyperparamètres et le seuil
Test -> estime la performance, consulté une seule fois
Un jeu sur lequel on décide cesse d'être un jeu d'évaluation.
LE VOCABULAIRE CONNEXE
perte ce que l'optimisation minimise pour produire les paramètres
métrique ce que l'on compare pour choisir les hyperparamètres
score sortie continue du modèle, ou valeur d'une métrique
seuil coupure appliquée au score, convention 0,50, non apprise
référence naïve borne en deçà de laquelle le modèle n'apporte rienÉnoncé de synthèse
Un modèle entraîné se lit sur deux niveaux : les hyperparamètres, fixés avant l'apprentissage, délimitent la famille de fonctions accessibles et la manière dont la recherche y sera conduite ; les paramètres, produits par cette recherche, désignent la fonction finalement retenue. Les premiers se règlent par comparaison d'entraînements successifs sur un jeu de validation, jamais sur le jeu de test, dont l'unique consultation constitue la seule estimation non biaisée de la performance attendue.
Quiz associés
009.1-quiz-parametre-appris.md009.2-quiz-hyperparametre.md009.3-quiz-critere-de-distinction.md009.4-quiz-inspection-scikit-learn.md009.5-quiz-reglage-et-jeu-de-test.md009.6-quiz-capacite-biais-variance.md009.7-quiz-loss-metric-score-seuil-baseline.mdChapitre suivant : 010-classification-ou-regression.md