Cette page a été traduite par l'API Cloud Translation.

Présentation des réglages d'hyperparamètres

Dans le machine learning, le réglage des hyperparamètres identifie un ensemble d'hyperparamètres optimaux pour l'algorithme d'apprentissage. Un hyperparamètre est un argument du modèle dont la valeur est définie avant le début du processus d'apprentissage. À l'inverse, les valeurs des autres paramètres, tels que les coefficients d'un modèle linéaire, sont apprises.

Le réglage des hyperparamètres vous permet de passer moins de temps à itérer manuellement les hyperparamètres, mais davantage à vous concentrer sur l'exploration des insights obtenus à partir des données.

Vous pouvez spécifier des options de réglage des hyperparamètres pour les types de modèles suivants :

Pour ces types de modèles, le réglage des hyperparamètres est activé lorsque vous spécifiez une valeur pour l'option NUM_TRIALS dans l'instruction CREATE MODEL.

Pour essayer le réglage des hyperparamètres sur un modèle de régression linéaire, consultez la page Utiliser le réglage des hyperparamètres BigQuery ML pour améliorer les performances d'un modèle.

Les modèles suivants sont également compatibles avec les réglages d'hyperparamètres, mais ne vous permettent pas de spécifier de valeurs :

Les réglages d'hyperparamètres sont intégrés par défaut dans l'entraînement des modèles AutoML Tables.
Les modèles ARIMA_PLUS vous permettent de définir l'argument AUTO_ARIMA pour effectuer un réglage d'hyperparamètres à l'aide de l'algorithme auto.ARIMA. Cet algorithme effectue le réglage des hyperparamètres pour le module de tendance. Les réglages d'hyperparamètres ne sont pas compatibles avec l'ensemble du pipeline de modélisation.

Pour en savoir plus sur les instructions et les fonctions SQL compatibles avec chaque type de modèle, consultez la section Parcours utilisateur de bout en bout pour chaque modèle.

Emplacements

Pour en savoir plus sur les emplacements compatibles avec les réglages d'hyperparamètres, consultez la page Emplacements BigQuery ML.

Définir des hyperparamètres

Pour régler un hyperparamètre, vous devez spécifier pour cet hyperparamètre une plage de valeurs que le modèle peut utiliser pour un ensemble d'essais. Pour ce faire, utilisez l'un des mots clés suivants lorsque vous définissez l'hyperparamètre dans l'instruction CREATE MODEL, plutôt que de fournir une seule valeur :

HPARAM_RANGE : valeur ARRAY(FLOAT64) à deux éléments qui définit les limites minimale et maximale de l'espace de recherche de valeurs continues pour un hyperparamètre. Utilisez cette option pour spécifier une plage de valeurs pour un hyperparamètre, par exemple LEARN_RATE = HPARAM_RANGE(0.0001, 1.0).
HPARAM_CANDIDATES : valeur ARRAY(STRUCT) qui spécifie l'ensemble de valeurs discrètes pour l'hyperparamètre. Utilisez cette option pour spécifier un ensemble de valeurs pour un hyperparamètre, par exemple OPTIMIZER = HPARAM_CANDIDATES(['ADAGRAD', 'SGD', 'FTRL']).

Hyperparamètres et objectifs

Le tableau suivant répertorie les hyperparamètres et les objectifs compatibles, pour chaque type de modèle compatible avec les réglages d'hyperparamètres :

Type de modèle	Objectifs d'hyperparamètre	Hyperparamètre	Plage valide	Plage par défaut	Type d'échelle
`LINEAR_REG`	`MEAN_ABSOLUTE_ERROR` `MEAN_SQUARED_ERROR` `MEAN_SQUARED_LOG_ERROR` `MEDIAN_ABSOLUTE_ERROR` `R2_SCORE` (par défaut) `EXPLAINED_VARIANCE`	`L1_REG` `L2_REG`	`(0, ∞]` `(0, ∞]`	`(0, 10]` `(0, 10]`	`LOG` `LOG`
`LOGISTIC_REG`	`PRECISION` `RECALL` `ACCURACY` `F1_SCORE` `LOG_LOSS` `ROC_AUC` (par défaut)	`L1_REG` `L2_REG`	`(0, ∞]` `(0, ∞]`	`(0, 10]` `(0, 10]`	`LOG` `LOG`
`KMEANS`	`DAVIES_BOULDIN_INDEX`	`NUM_CLUSTERS`	`[2, 100]`	`[2, 10]`	`LINEAR`
`MATRIX_ FACTORIZATION` (explicite)	`MEAN_SQUARED_ERROR`	`NUM_FACTORS` `L2_REG`	`[2, 200]` `(0, ∞)`	`[2, 20]` `(0, 10]`	`LINEAR` `LOG`
`MATRIX_ FACTORIZATION` (implicite)	`MEAN_AVERAGE_PRECISION` (par défaut) `MEAN_SQUARED_ERROR` `NORMALIZED_DISCOUNTED_CUMULATIVE_GAIN` `AVERAGE_RANK`	`NUM_FACTORS` `L2_REG` `WALS_ALPHA`	`[2, 200]` `(0, ∞)` `[0, ∞)`	`[2, 20]` `(0, 10]` `[0, 100]`	`LINEAR` `LOG` `LINEAR`
`AUTOENCODER`	`MEAN_ABSOLUTE_ERROR` `MEAN_SQUARED_ERROR` (par défaut) `MEAN_SQUARED_LOG_ERROR`	`LEARN_RATE` `BATCH_SIZE` `L1_REG` `L2_REG` `L1_REG_ACTIVATION` `DROPOUT` `HIDDEN_UNITS` `OPTIMIZER` `ACTIVATION_FN`	`[0, 1]` `(0, ∞)` `(0, ∞)` `(0, ∞)` `(0, ∞)` `[0, 1)` Tableau de `[1, ∞)` {`ADAM`, `ADAGRAD`, `FTRL`, `RMSPROP`, `SGD`} {`RELU`, `RELU6`, `CRELU`, `ELU`, `SELU`, `SIGMOID`, `TANH`}	`[0, 1]` `[16, 1024]` `(0, 10]` `(0, 10]` `(0, 10]` `[0, 0.8]` N/A {`ADAM`, `ADAGRAD`, `FTRL`, `RMSPROP`, `SGD`} N/A	`LOG` `LOG` `LOG` `LOG` `LOG` `LINEAR` N/A N/A N/A
`DNN_CLASSIFIER`	`PRECISION` `RECALL` `ACCURACY` `F1_SCORE` `LOG_LOSS` `ROC_AUC` (par défaut)	`BATCH_SIZE` `DROPOUT` `HIDDEN_UNITS` `LEARN_RATE` `OPTIMIZER` `L1_REG` `L2_REG` `ACTIVATION_FN`	`(0, ∞)` `[0, 1)` Tableau de `[1, ∞)` `[0, 1]` {`ADAM`, `ADAGRAD`, `FTRL`, `RMSPROP`, `SGD`} `(0, ∞)` `(0, ∞)` {`RELU`, `RELU6`, `CRELU`, `ELU`, `SELU`, `SIGMOID`, `TANH`}	`[16, 1024]` `[0, 0.8]` N/A `[0, 1]` {`ADAM`, `ADAGRAD`, `FTRL`, `RMSPROP`, `SGD`} `(0, 10]` `(0, 10]` N/A	`LOG` `LINEAR` N/A `LINEAR` N/A `LOG` `LOG` N/A
`DNN_REGRESSOR`	`MEAN_ABSOLUTE_ERROR` `MEAN_SQUARED_ERROR` `MEAN_SQUARED_LOG_ERROR` `MEDIAN_ABSOLUTE_ERROR` `R2_SCORE` (par défaut) `EXPLAINED_VARIANCE`				`LOG` `LINEAR` N/A `LINEAR` N/A `LOG` `LOG` N/A
`DNN_LINEAR_ COMBINED_ CLASSIFIER`	`PRECISION` `RECALL` `ACCURACY` `F1_SCORE` `LOG_LOSS` `ROC_AUC` (par défaut)	`BATCH_SIZE` `DROPOUT` `HIDDEN_UNITS` `L1_REG` `L2_REG` `ACTIVATION_FN`	`(0, ∞)` `[0, 1)` Tableau de `[1, ∞)` `(0, ∞)` `(0, ∞)` {`RELU`, `RELU6`, `CRELU`, `ELU`, `SELU`, `SIGMOID`, `TANH`}	`[16, 1024]` `[0, 0.8]` N/A `(0, 10]` `(0, 10]` N/A	`LOG` `LINEAR` N/A `LOG` `LOG` N/A
`DNN_LINEAR_ COMBINED_ REGRESSOR`	`MEAN_ABSOLUTE_ERROR` `MEAN_SQUARED_ERROR` `MEAN_SQUARED_LOG_ERROR` `MEDIAN_ABSOLUTE_ERROR` `R2_SCORE` (par défaut) `EXPLAINED_VARIANCE`			`[16, 1024]` `[0, 0.8]` N/A `(0, 10]` `(0, 10]` N/A	`LOG` `LINEAR` N/A `LOG` `LOG` N/A
`BOOSTED_TREE_ CLASSIFIER`	`PRECISION` `RECALL` `ACCURACY` `F1_SCORE` `LOG_LOSS` `ROC_AUC` (par défaut)	`LEARN_RATE` `L1_REG` `L2_REG` `DROPOUT` `MAX_TREE_DEPTHMAX_TREE_DEPTH` `SUBSAMPLE` `MIN_SPLIT_LOSS` `NUM_PARALLEL_TREE` `MIN_TREE_CHILD_WEIGHT` `COLSAMPLE_BYTREE` `COLSAMPLE_BYLEVEL` `COLSAMPLE_BYNODE` `BOOSTER_TYPE` `DART_NORMALIZE_TYPE` `TREE_METHOD`	`[0, ∞)` `(0, ∞)` `(0, ∞)` `[0, 1]` `[1, 20]` `(0, 1]` `[0, ∞)` `[1, ∞)` `[0, ∞)` `[0, 1]` `[0, 1]` `[0, 1]` {`GBTREE`, `DART`} {`TREE`, `FOREST`} {`AUTO`, `EXACT`, `APPROX`, `HIST`}	`[0, 1]` `(0, 10]` `(0, 10]` N/A `[1, 10]` `(0, 1]` N/A N/A N/A N/A N/A N/A N/A N/A N/A	`LINEAR` `LOG` `LOG` `LINEAR` `LINEAR` `LINEAR` `LINEAR` `LINEAR` `LINEAR` `LINEAR` `LINEAR` `LINEAR` N/A N/A N/A
`BOOSTED_TREE_ REGRESSOR`	`MEAN_ABSOLUTE_ERROR` `MEAN_SQUARED_ERROR` `MEAN_SQUARED_LOG_ERROR` `MEDIAN_ABSOLUTE_ERROR` `R2_SCORE` (par défaut) `EXPLAINED_VARIANCE`
`RANDOM_FOREST_ CLASSIFIER`	`PRECISION` `RECALL` `ACCURACY` `F1_SCORE` `LOG_LOSS` `ROC_AUC` (par défaut)	`L1_REG` `L2_REG` `MAX_TREE_DEPTH` `SUBSAMPLE` `MIN_SPLIT_LOSS` `NUM_PARALLEL_TREE` `MIN_TREE_CHILD_WEIGHT` `COLSAMPLE_BYTREE` `COLSAMPLE_BYLEVEL` `COLSAMPLE_BYNODE` `TREE_METHOD`	`(0, ∞)` `(0, ∞)` `[1, 20]` `(0, 1)` `[0, ∞)` `[2, ∞)` `[0, ∞)` `[0, 1]` `[0, 1]` `[0, 1]` {`AUTO`, `EXACT`, `APPROX`, `HIST`}	`(0, 10]` `(0, 10]` `[1, 20]` `(0, 1)` N/A `[2, 200]` N/A N/A N/A N/A N/A	`LOG` `LOG` `LINEAR` `LINEAR` `LINEAR` `LINEAR` `LINEAR` `LINEAR` `LINEAR` `LINEAR` N/A
`RANDOM_FOREST_ REGRESSOR`	`MEAN_ABSOLUTE_ERROR` `MEAN_SQUARED_ERROR` `MEAN_SQUARED_LOG_ERROR` `MEDIAN_ABSOLUTE_ERROR` `R2_SCORE` (par défaut) `EXPLAINED_VARIANCE`

La plupart des hyperparamètres à l'échelle LOG utilisent la limite inférieure ouverte de 0. Vous pouvez toujours définir 0 comme limite inférieure en utilisant le mot clé HPARAM_RANGE pour définir la plage d'hyperparamètre. Par exemple, dans un modèle classificateur à arbre de décision à boosting, vous pouvez définir la plage de l'hyperparamètre L1_REG sur L1_REG = HPARAM_RANGE(0, 5). Une valeur 0 sera convertie en 1e-14.

Les hyperparamètres conditionnels sont acceptés. Par exemple, dans un modèle régresseur à arbre de décision à boosting, vous ne pouvez ajuster l'hyperparamètre DART_NORMALIZE_TYPE que lorsque la valeur de l'hyperparamètre BOOSTER_TYPE est DART. Dans ce cas, vous spécifiez les espaces de recherche et les conditions sont gérées automatiquement, comme indiqué dans l'exemple suivant :

BOOSTER_TYPE = HPARAM_CANDIDATES(['DART', 'GBTREE'])
DART_NORMALIZE_TYPE = HPARAM_CANDIDATES(['TREE', 'FOREST'])

Point de départ de la recherche

Si vous ne spécifiez pas d'espace de recherche pour un hyperparamètre en utilisant HPARAM_RANGE ou HPARAM_CANDIDATES, la recherche commence à partir de la valeur par défaut de cet hyperparamètre, comme indiqué dans l'article CREATE MODEL pour ce type de modèle. Par exemple, si vous exécutez un réglage d'hyperparamètres pour un modèle d'arbre de décision à boosting et que vous ne spécifiez pas de valeur pour l'hyperparamètre L1_REG, la recherche commence par 0, la valeur par défaut.

Si vous spécifiez un espace de recherche pour un hyperparamètre en utilisnat HPARAM_RANGE ou HPARAM_CANDIDATES, les points de départ de la recherche varient selon que l'espace de recherche spécifié inclut la valeur par défaut de cet hyperparamètre, telle qu'indiquée dans l'article CREATE MODELpour ce type de modèle :

Si la plage spécifiée contient la valeur par défaut, c'est là que la recherche commence. Par exemple, si vous exécutez un réglage d'hyperparamètres pour un modèle de factorisation matricielle implicite, et que vous spécifiez la valeur [20, 30, 40, 50] pour l'hyperparamètre WALS_ALPHA, la recherche commence à 40, la valeur par défaut.
Si la plage spécifiée ne contient pas la valeur par défaut, la recherche commence à partir du point de la plage spécifiée le plus proche de la valeur par défaut. Par exemple, si vous spécifiez la valeur [10, 20, 30] pour l'hyperparamètre WALS_ALPHA, la recherche commence par 30, qui est la valeur la plus proche de la valeur par défaut 40.

Répartition des données

Lorsque vous spécifiez une valeur pour l'option NUM_TRIALS, le service identifie que vous effectuez des réglages d'hyperparamètres et effectue automatiquement une répartition à trois voies sur les données d'entrée afin de les diviser en ensembles d'entraînement, d'évaluation et de test. Par défaut, les données d'entrée sont randomisées puis réparties à raison de 80 % pour l'entraînement, 10 % pour l'évaluation et 10 % pour le test.

Les ensembles d'entraînement et d'évaluation sont utilisés pour chaque essai d'entraînement, comme pour les modèles sans réglage d'hyperparamètres. Les suggestions d'hyperparamètres d'essai sont calculées en fonction des métriques d'évaluation du modèle pour ce type de modèle. À la fin de chaque essai d'entraînement, l'ensemble de test est utilisé pour tester l'essai et enregistrer ses métriques dans le modèle. Cela garantit l'objectivité des métriques d'évaluation finales en utilisant des données qui n'ont pas encore été analysées par le modèle. Les données d'évaluation sont utilisées pour calculer les métriques intermédiaires pour la suggestion d'hyperparamètre, tandis que les données de test sont utilisées pour calculer les métriques finales et objectives du modèle.

Si vous souhaitez n'utiliser qu'un ensemble d'entraînement, spécifiez NO_SPLIT pour l'option DATA_SPLIT_METHOD de l'instruction CREATE MODEL.

Si vous souhaitez utiliser uniquement des ensembles d'entraînement et d'évaluation, spécifiez 0 pour l'option DATA_SPLIT_TEST_FRACTION de l'instruction CREATE MODEL. Lorsque l'ensemble de test est vide, l'ensemble d'évaluation est utilisé comme ensemble de test pour le rapport final sur les métriques d'évaluation.

Les métriques de modèle générées par un job d'entraînement normal et celles générées par un job d'entraînement de réglage d'hyperparamètres ne sont comparables que si la répartition des données est la même. Par exemple, les modèles suivants sont comparables :

Sans réglage des hyperparamètres : DATA_SPLIT_METHOD='RANDOM', DATA_SPLIT_EVAL_FRACTION=0.2
Avec réglage des hyperparamètres : DATA_SPLIT_METHOD='RANDOM', DATA_SPLIT_EVAL_FRACTION=0.2, DATA_SPLIT_TEST_FRACTION=0

Performances

Les performances d'un modèle avec réglage d'hyperparamètres ne sont généralement pas meilleures que les performances s'il utilise l'espace de recherche par défaut sans réglage des hyperparamètres. Un modèle qui utilise l'espace de recherche par défaut sans réglage des hyperparamètres utilise toujours les hyperparamètres par défaut pour le premier essai.

Pour confirmer les améliorations de performances résultant du réglage des hyperparamètres, comparez l'essai optimal du modèle avec réglage des hyperparamètres au premier essai du modèle sans réglage des hyperparamètres.

Apprentissage par transfert

L'apprentissage par transfert est activé par défaut lorsque vous définissez l'option HPARAM_TUNING_ALGORITHM sur VIZIER_DEFAULT dans l'instruction CREATE MODEL. Le réglage des hyperparamètres d'un modèle ne peut bénéficier d'un apprentissage basé sur des modèles précédemment réglés que s'il répond aux exigences suivantes :

Il est du même type que les modèles précédemment réglés.
Il réside dans le même projet que les modèles précédemment réglés.
Il utilise le même espace de recherche d'hyperparamètres OU un sous-ensemble de l'espace de recherche d'hyperparamètres des modèles précédemment réglés. Un sous-ensemble utilise les mêmes noms et types d'hyperparamètres, mais pas nécessairement les mêmes plages. Par exemple, (a:[0, 10]) est considéré comme un sous-ensemble de (a:[-1, 1], b:[0, 1]).

L'apprentissage par transfert ne nécessite pas que les données d'entrée soient identiques.

L'apprentissage par transfert permet de résoudre le problème de démarrage à froid, où le système effectue une exploration aléatoire lors du premier lot d'essais. L'apprentissage par transfert fournit au système des connaissances initiales sur les hyperparamètres et leurs objectifs. Pour améliorer continuellement la qualité d'un modèle, entraînez toujours votre nouveau modèle avec réglage des hyperparamètres en utilisant les mêmes hyperparamètres, ou un sous-ensemble de ces hyperparamètres.

L'apprentissage par transfert permet d'accélérer la convergence des réglages d'hyperparamètres, plutôt que d'accélérer la convergence des sous-modèles.

Gestion des exceptions

Le réglage des hyperparamètres gère les erreurs des manières suivantes :

Annulation : si un job d'entraînement est annulé pendant son exécution, tous les essais réussis restent utilisables.
Entrée non valide : si l'entrée utilisateur n'est pas valide, le service renvoie une erreur utilisateur.
Hyperparamètres non valides : si les hyperparamètres ne sont pas valides pour un essai, celui-ci est ignoré et marqué comme INFEASIBLE dans la sortie de la fonction ML.TRIAL_INFO.
Erreur interne d'essai : si plus de 10 % des essais de la valeur NUM_TRIALS échouent en raison d'une INTERNAL_ERROR, le job d'entraînement s'arrête et renvoie une erreur utilisateur.
Si moins de 10 % des essais de la valeur NUM_TRIALS échouent en raison d'une INTERNAL_ERROR, l'entraînement se poursuit avec les essais ayant échoué marqués comme FAILED dans la sortie de la fonction ML.TRIAL_INFO.

Fonctions de mise en service de modèle

Vous pouvez utiliser les modèles obtenus par réglage des hyperparamètres avec un certain nombre de fonctions de mise en service de modèle existantes. Pour utiliser ces fonctions, suivez les règles ci-dessous :

Lorsque la fonction prend des données d'entrée, seul le résultat d'un essai est renvoyé. Par défaut, il s'agit de l'essai optimal, mais vous pouvez également choisir un essai spécifique en spécifiant TRIAL_ID comme argument pour la fonction en question. Vous pouvez trouver le TRIAL_ID dans la sortie de la fonction ML.TRIAL_INFO. Les fonctions suivantes sont prises en charge :
Lorsque la fonction ne prend pas de données d'entrée, tous les résultats sont renvoyés et la première colonne de sortie contient TRIAL_ID. Les fonctions suivantes sont prises en charge :

La sortie de ML.FEATURE_INFO ne change pas, car tous les essais partagent les mêmes données d'entrée.

Les métriques d'évaluation de ML.EVALUATE et ML.TRIAL_INFO peuvent être différentes du fait de la manière dont les données d'entrée sont réparties. Par défaut, ML.EVALUATE s'exécute sur les données de test, tandis que ML.TRIAL_INFO s'exécute sur les données d'évaluation. Pour en savoir plus, consultez la page Répartition des données.

Fonctions non compatibles

La fonction ML.TRAINING_INFO renvoie des informations pour chaque itération, et les résultats des itérations ne sont pas enregistrés dans les modèles de réglage des hyperparamètres. Les résultats de l'essai sont enregistrés à la place. Vous pouvez utiliser la fonction ML.TRIAL_INFO pour obtenir des informations sur les résultats de l'essai.

Exportation de modèles

Vous pouvez exporter des modèles obtenus par réglage des hyperparamètres vers des emplacements Cloud Storage en utilisant l'instruction EXPORT MODEL. Vous pouvez exporter l'essai optimal par défaut ou n'importe quel autre essai spécifié.

Tarifs

Le coût de l'entraînement de réglage des hyperparamètres correspond à la somme du coût de tous les essais exécutés. La tarification de chaque essai est conforme au modèle de tarification BigQuery ML existant.

Questions fréquentes

Cette section fournit des réponses à certaines questions fréquentes sur le réglage des hyperparamètres.

Combien d'essais dois-je effectuer pour régler un modèle ?

Nous vous recommandons d'utiliser au moins 10 essais pour un hyperparamètre. Le nombre total d'essais doit donc être d'au moins 10 * num_hyperparameters. Si vous utilisez l'espace de recherche par défaut, référez-vous à la colonne Hyperparamètres de la table Hyperparamètres et objectifs pour connaître le nombre d'hyperparamètres réglés par défaut pour un type de modèle donné.

Que faire si je ne constate pas d'amélioration des performances grâce au réglage des hyperparamètres ?

Assurez-vous de suivre les instructions du présent document pour obtenir une comparaison équitable. Si vous ne voyez toujours pas d'améliorations des performances, cela peut signifier que les hyperparamètres par défaut fonctionnent déjà correctement. Vous pouvez vous concentrer sur l'ingénierie des caractéristiques ou essayer d'autres types de modèles avant de lancer une autre série de réglages d'hyperparamètres.

Que faire si je souhaite continuer à régler le modèle ?

Entraînez un nouveau modèle avec réglage des hyperparamètres dans le même espace de recherche. L'apprentissage par transfert intégré permet de poursuivre le réglage sur la base de vos modèles précédemment réglés.

Dois-je réentraîner le modèle avec toutes les données et en utilisant les hyperparamètres optimaux ?

Cela dépend des facteurs suivants :

Les modèles de k-moyennes utilisent déjà toutes les données pour l'entraînement. Il n'est donc pas nécessaire de réentraîner le modèle.
Pour les modèles de factorisation matricielle, vous pouvez réentraîner le modèle en utilisant les hyperparamètres sélectionnés avec l'intégralité des données d'entrée pour une meilleure couverture des utilisateurs et des éléments.
Pour tous les autres types de modèles, le réentraînement n'est généralement pas nécessaire. Le service conserve déjà 80 % des données d'entrée pour l'entraînement lors de la répartition randomisée des données appliquée par défaut. Vous pouvez ré-entraîner le modèle avec davantage de données d'entraînement et en utilisant des hyperparamètres choisis si votre ensemble de données est petit, mais le fait de ne conserver que peu de données d'évaluation peut aggraver le surapprentissage en cas d'arrêt prématuré.

Étapes suivantes

Pour vous essayer au réglage des hyperparamètres, consultez la page Utiliser le réglage des hyperparamètres BigQuery ML pour améliorer les performances d'un modèle.