Les traductions sont fournies par des outils de traduction automatique. En cas de conflit entre le contenu d'une traduction et celui de la version originale en anglais, la version anglaise prévaudra.
# Qualité des modèles
Les tâches de surveillance de la qualité des modèles contrôlent les performances d’un modèle en comparant les prédictions réalisées par le modèle aux étiquettes réelles Ground Truth que le modèle tente de prédire. Pour ce faire, la surveillance de la qualité des modèles fusionne les données capturées à partir de l'inférence en temps réel ou par lots avec les étiquettes réelles que vous stockez dans un compartiment Amazon S3, puis compare les prédictions aux étiquettes réelles.
Pour mesurer la qualité du modèle, Model Monitor utilise des métriques qui dépendent du type de problème ML. Par exemple, s'il s'agit d'un problème de régression, l'une des métriques évaluées est l'erreur quadratique moyenne (mse). Pour plus d’informations sur les métriques utilisées pour les différents types de problèmes ML, consultez [Indicateurs de qualité des modèles et CloudWatch surveillance d'Amazon](model-monitor-model-quality-metrics.md).
La surveillance de la qualité des modèles suit les mêmes étapes que la surveillance de la qualité des données, mais ajoute une étape consistant à fusionner les étiquettes réelles Amazon S3 avec les prédictions capturées à partir du point de terminaison d'inférence en temps réel ou de la tâche de transformation par lots. Pour contrôler la qualité du modèle, procédez comme suit :
+ Activez la capture de données. Les entrées et sorties d'inférence sont capturées à partir d'un point de terminaison d'inférence en temps réel ou d'une tâche de transformation par lots et les données sont stockées dans Amazon S3. Pour de plus amples informations, veuillez consulter [Capture des données](model-monitor-data-capture.md).
+ Créez une tâche de référence. Dans cette étape, vous exécutez une tâche de référence qui compare les prédictions du modèle aux étiquettes Ground Truth d'un jeu de données de référence. La tâche de référence crée automatiquement des règles et des contraintes statistiques de référence qui définissent les seuils par rapport auxquels les performances du modèle sont évaluées. Pour de plus amples informations, veuillez consulter [Création d’une référence de qualité des modèles](model-monitor-model-quality-baseline.md).
+ Définissez et planifiez des tâches de surveillance de la qualité du modèle. Pour obtenir des informations spécifiques et des exemples de code sur les tâches de surveillance de la qualité des modèles, consultez [Planification des tâches de surveillance de la qualité des modèles](model-monitor-model-quality-schedule.md). Pour des informations générales sur les tâches de surveillance, consultez [Planification des tâches de surveillance](model-monitor-scheduling.md).
+ Ingérez les étiquettes Ground Truth que Model Monitor fusionne avec les données de prédiction capturées à partir d’un point de terminaison d’inférence en temps réel ou d’une tâche de transformation par lots. Pour de plus amples informations, veuillez consulter [Ingestion et fusion des étiquettes Ground Truth avec des prédictions](model-monitor-model-quality-merge.md).
+ Intégrez le suivi de la qualité des modèles à Amazon CloudWatch. Pour de plus amples informations, veuillez consulter [Surveillance des indicateurs de qualité des modèles avec CloudWatch](model-monitor-model-quality-metrics.md#model-monitor-model-quality-cw).
+ Interprétez les résultats d'une tâche de surveillance. Pour de plus amples informations, veuillez consulter [Interprétation des résultats](model-monitor-interpreting-results.md).
+ Utilisez SageMaker Studio pour contrôler la qualité des modèles et visualiser les résultats. Pour de plus amples informations, veuillez consulter [Visualisez les résultats pour les points de terminaison en temps réel dans Amazon Studio SageMaker](model-monitor-interpreting-visualize-results.md).
**Topics**
+ [Création d’une référence de qualité des modèles](model-monitor-model-quality-baseline.md)
+ [Planification des tâches de surveillance de la qualité des modèles](model-monitor-model-quality-schedule.md)
+ [Ingestion et fusion des étiquettes Ground Truth avec des prédictions](model-monitor-model-quality-merge.md)
+ [Indicateurs de qualité des modèles et CloudWatch surveillance d'Amazon](model-monitor-model-quality-metrics.md)
# Création d’une référence de qualité des modèles
Créez une tâche de référence qui compare les prédictions de votre modèle aux étiquettes Ground Truth d'un jeu de données de référence que vous avez stocké dans Amazon S3. En règle générale, vous utilisez un jeu de données d'entraînement comme jeu de données de référence. La tâche de référence calcule les métriques pour le modèle et suggère des contraintes à utiliser pour contrôler l'écart dans la qualité du modèle.
Pour créer une tâche de référence, vous devez disposer d'un jeu de données contenant des prédictions de votre modèle et des étiquettes Ground Truth de vos données.
Pour créer une tâche de référence, utilisez la `ModelQualityMonitor` classe fournie par le SDK SageMaker Python et effectuez les étapes suivantes.
**Pour créer une tâche de référence de qualité de modèle**
1. Tout d'abord, créez une instance de la classe `ModelQualityMonitor`. L'exemple de code suivant vous montre comment procéder.
```
from sagemaker import get_execution_role, session, Session
from sagemaker.model_monitor import ModelQualityMonitor
role = get_execution_role()
session = Session()
model_quality_monitor = ModelQualityMonitor(
role=role,
instance_count=1,
instance_type='ml.m5.xlarge',
volume_size_in_gb=20,
max_runtime_in_seconds=1800,
sagemaker_session=session
)
```
1. Maintenant, appelez la méthode `suggest_baseline` de l'objet `ModelQualityMonitor` pour exécuter une tâche de référence. L'extrait de code suivant suppose que le jeu de données de référence dont vous disposez contient des prédictions et des étiquettes stockées dans Amazon S3.
```
baseline_job_name = "MyBaseLineJob"
job = model_quality_monitor.suggest_baseline(
job_name=baseline_job_name,
baseline_dataset=baseline_dataset_uri, # The S3 location of the validation dataset.
dataset_format=DatasetFormat.csv(header=True),
output_s3_uri = baseline_results_uri, # The S3 location to store the results.
problem_type='BinaryClassification',
inference_attribute= "prediction", # The column in the dataset that contains predictions.
probability_attribute= "probability", # The column in the dataset that contains probabilities.
ground_truth_attribute= "label" # The column in the dataset that contains ground truth labels.
)
job.wait(logs=False)
```
1. Une fois la tâche de référence terminée, les contraintes générées par la tâche s'affichent. Tout d'abord, obtenez les résultats de la tâche de référence en appelant la méthode `latest_baselining_job` de l'objet `ModelQualityMonitor`.
```
baseline_job = model_quality_monitor.latest_baselining_job
```
1. La tâche de référence suggère des contraintes, qui sont des seuils pour les métriques mesurées par Model Monitor. Si une métrique dépasse le seuil suggéré, Model Monitor signale une violation. Pour afficher les contraintes générées par la tâche de référence, appelez la méthode `suggested_constraints` de la tâche de référence. L'extrait de code suivant charge les contraintes pour un modèle de classification binaire dans un dataframe Pandas.
```
import pandas as pd
pd.DataFrame(baseline_job.suggested_constraints().body_dict["binary_classification_constraints"]).T
```
Nous vous recommandons d'afficher les contraintes générées et de les modifier si nécessaire avant de les utiliser pour la surveillance. Par exemple, si une contrainte est trop agressive, vous pourrez obtenir un nombre excessif d’alertes de violation.
Si votre contrainte contient des nombres exprimés en notation scientifique, vous devrez les convertir en nombres à virgule flottante. L'exemple de [script de prétraitement](https://docs.aws.amazon.com/sagemaker/latest/dg/model-monitor-pre-and-post-processing.html#model-monitor-pre-processing-script) Python suivant montre comment convertir des nombres en notation scientifique en nombres à virgule flottante.
```
import csv
def fix_scientific_notation(col):
try:
return format(float(col), "f")
except:
return col
def preprocess_handler(csv_line):
reader = csv.reader([csv_line])
csv_record = next(reader)
#skip baseline header, change HEADER_NAME to the first column's name
if csv_record[0] == “HEADER_NAME”:
return []
return { str(i).zfill(20) : fix_scientific_notation(d) for i, d in enumerate(csv_record)}
```
Vous pouvez ajouter votre script de prétraitement à une base de référence ou à un calendrier de surveillance en tant que `record_preprocessor_script`, tel que défini dans la documentation de [Model Monitor](https://sagemaker.readthedocs.io/en/stable/api/inference/model_monitor.html).
1. Lorsque les contraintes vous conviennent, transmettez-les comme paramètre `constraints` dans le programme de surveillance que vous créez. Pour de plus amples informations, veuillez consulter [Planification des tâches de surveillance de la qualité des modèles](model-monitor-model-quality-schedule.md).
Les contraintes de référence suggérées sont contenues dans le fichier constraints.json à l'emplacement que vous spécifiez avec `output_s3_uri`. Pour plus d’informations sur le schéma de ce fichier, consultez [Schéma des contraintes (fichier constraints.json)](model-monitor-byoc-constraints.md).
# Planification des tâches de surveillance de la qualité des modèles
Après avoir créé votre base de référence, vous pouvez appeler la méthode `create_monitoring_schedule()` de votre instance de classe `ModelQualityMonitor` pour planifier une surveillance horaire de la qualité des modèles. Les sections suivantes expliquent comment créer une surveillance de la qualité des modèles pour un modèle déployé sur un point de terminaison en temps réel ainsi que pour une tâche de transformation par lots.
**Important**
Vous pouvez spécifier une entrée de transformation par lots ou une entrée de point de terminaison, mais pas les deux, lorsque vous créez votre planification de surveillance.
Contrairement à la surveillance de la qualité des données, vous devez fournir des étiquettes Ground Truth si vous souhaitez contrôler la qualité des modèles. Cependant, les étiquettes Ground Truth pourraient être retardées. Pour résoudre ce problème, spécifiez les décalages lorsque vous créez votre programme de surveillance.
## Décalages de Model Monitor
Les tâches de surveillance de la qualité du modèle comprennent `StartTimeOffset` et `EndTimeOffset`, qui sont des champs du paramètre `ModelQualityJobInput` de la méthode `create_model_quality_job_definition` qui fonctionnent comme suit :
+ `StartTimeOffset` - Si spécifié, les tâches soustraient ce temps de l'heure de début.
+ `EndTimeOffset` - Si spécifié, les tâches soustraient ce temps de l’heure de fin.
Le format des décalages est, par exemple, PT7 -H, où 7H correspond à 7 heures. Vous pouvez utiliser -PT\$1H ou -P\$1D, où H=heures, D=jours, M=minutes et \$1 est le nombre. De plus, le décalage doit être dans le [format de durée ISO 8601](https://en.wikipedia.org/wiki/ISO_8601#Durations).
Par exemple, si votre tâche Ground Truth commence au bout d'un jour, mais ne se termine pas en une semaine, définissez `StartTimeOffset` sur `-P8D` et `EndTimeOffset` sur `-P1D`. Ensuite, si vous planifiez une tâche pour qu'elle s'exécute à `2020-01-09T13:00`, les données sont analysées entre `2020-01-01T13:00` et `2020-01-08T13:00`.
**Important**
La cadence de planification doit être telle qu'une exécution se termine avant le début de la suivante, ce qui permet aux tâches de fusion et de surveillance Ground Truth de s'exécuter. La durée maximale d’une exécution est divisée entre les deux tâches. Pour une tâche de surveillance horaire de la qualité du modèle, la valeur de `MaxRuntimeInSeconds` spécifiée en tant que partie de `StoppingCondition` ne doit donc pas dépasser 1 800.
## Surveillance de la qualité des modèles pour les modèles déployés sur des points de terminaison en temps réel
Pour planifier une surveillance de la qualité des modèles pour un point de terminaison en temps réel, transmettez votre instance `EndpointInput` à l'argument `endpoint_input` de votre instance `ModelQualityMonitor`, comme indiqué dans l'exemple de code suivant :
```
from sagemaker.model_monitor import CronExpressionGenerator
model_quality_model_monitor = ModelQualityMonitor(
role=sagemaker.get_execution_role(),
...
)
schedule = model_quality_model_monitor.create_monitoring_schedule(
monitor_schedule_name=schedule_name,
post_analytics_processor_script=s3_code_postprocessor_uri,
output_s3_uri=s3_report_path,
schedule_cron_expression=CronExpressionGenerator.hourly(),
statistics=model_quality_model_monitor.baseline_statistics(),
constraints=model_quality_model_monitor.suggested_constraints(),
schedule_cron_expression=CronExpressionGenerator.hourly(),
enable_cloudwatch_metrics=True,
endpoint_input=EndpointInput(
endpoint_name=endpoint_name,
destination="/opt/ml/processing/input/endpoint",
start_time_offset="-PT2D",
end_time_offset="-PT1D",
)
)
```
## Surveillance de la qualité des modèles pour les tâches de transformation par lots
Pour planifier une surveillance de la qualité des modèles pour une tâche de transformation par lots, transmettez votre instance `BatchTransformInput` à l'argument `batch_transform_input` de votre instance `ModelQualityMonitor`, comme indiqué dans l'exemple de code suivant :
```
from sagemaker.model_monitor import CronExpressionGenerator
model_quality_model_monitor = ModelQualityMonitor(
role=sagemaker.get_execution_role(),
...
)
schedule = model_quality_model_monitor.create_monitoring_schedule(
monitor_schedule_name=mon_schedule_name,
batch_transform_input=BatchTransformInput(
data_captured_destination_s3_uri=s3_capture_upload_path,
destination="/opt/ml/processing/input",
dataset_format=MonitoringDatasetFormat.csv(header=False),
# the column index of the output representing the inference probablity
probability_attribute="0",
# the threshold to classify the inference probablity to class 0 or 1 in
# binary classification problem
probability_threshold_attribute=0.5,
# look back 6 hour for transform job outputs.
start_time_offset="-PT6H",
end_time_offset="-PT0H"
),
ground_truth_input=gt_s3_uri,
output_s3_uri=s3_report_path,
problem_type="BinaryClassification",
constraints = constraints_path,
schedule_cron_expression=CronExpressionGenerator.hourly(),
enable_cloudwatch_metrics=True,
)
```
# Ingestion et fusion des étiquettes Ground Truth avec des prédictions
La surveillance de la qualité du modèle compare les prédictions réalisées par votre modèle aux étiquettes Ground Truth afin de mesurer la qualité du modèle. Pour que cela fonctionne, vous étiquetez périodiquement les données capturées par votre point de terminaison ou votre tâche de transformation par lots et les téléchargez dans Amazon S3.
Pour que les étiquettes Ground Truth correspondent aux données de prédiction capturées, chaque enregistrement du jeu de données doit avoir un identifiant unique. La structure de chaque enregistrement pour les données Ground Truth est la suivante :
```
{
"groundTruthData": {
"data": "1",
"encoding": "CSV"
},
"eventMetadata": {
"eventId": "aaaa-bbbb-cccc"
},
"eventVersion": "0"
}
```
Selon la structure `groundTruthData`, `eventId` peut être l'un des éléments suivants :
+ `eventId` - Cet ID est automatiquement généré lorsqu'un utilisateur appelle le point de terminaison.
+ `inferenceId` - L'appelant fournit cet ID lorsqu'il appelle le point de terminaison.
Si l'ID `inferenceId` est présent dans les enregistrements de données capturées, Model Monitor l'utilise pour fusionner les données capturées avec les enregistrements Ground Truth. Vous devez vous assurer que l'ID `inferenceId` des enregistrements Ground Truth correspond à l'ID `inferenceId` des enregistrements capturés. Si l’ID `inferenceId` n’est pas présent dans les données capturées, Model Monitor utilise l’ID `eventId` des enregistrements de données capturés pour les faire correspondre à un enregistrement Ground Truth.
Vous devez charger les données Ground Truth dans un compartiment Amazon S3 ayant le même format de chemin d’accès que les données capturées.
**Exigences de format de données**
Lorsque vous enregistrez vos données sur Amazon S3, elles doivent utiliser le format JSON Lines (.jsonl) et être enregistrées selon la structure de dénomination suivante. Pour en savoir plus sur les exigences JSON Lines, consultez [Utilisation des données d’entrée et de sortie](sms-data.md).
```
s3://amzn-s3-demo-bucket1/prefix/yyyy/mm/dd/hh
```
Dans ce chemin d’accès, la date est celle à laquelle l’étiquette Ground Truth est collectée. Elle ne doit pas correspondre nécessairement à la date de génération de l’inférence.
Une fois les étiquettes Ground Truth créées et téléchargées, incluez leur emplacement comme paramètre dans la tâche de surveillance que vous créez. Si vous en utilisez AWS SDK pour Python (Boto3), faites-le en spécifiant l'emplacement des labels Ground Truth comme `S3Uri` champ du `GroundTruthS3Input` paramètre lors d'un appel à la `create_model_quality_job_definition` méthode. Si vous utilisez le SDK SageMaker Python, spécifiez l'emplacement des labels Ground Truth comme `ground_truth_input` paramètre lors de l'appel à `create_monitoring_schedule` l'`ModelQualityMonitor`objet.
# Indicateurs de qualité des modèles et CloudWatch surveillance d'Amazon
Les tâches de surveillance de la qualité des modèles calculent différentes métriques pour évaluer la qualité et les performances de vos modèles de machine learning. Les métriques spécifiques calculées dépendent du type de problème ML : régression, classification binaire ou classification multi-classes. La surveillance de ces métriques est essentielle pour détecter la dérive des modèles au fil du temps. Les sections suivantes présentent les principaux indicateurs de qualité du modèle pour chaque type de problème, ainsi que la manière de configurer la surveillance et les alertes automatisées CloudWatch afin de suivre en permanence les performances de votre modèle.
**Note**
L’écart-type pour les métriques n’est fourni que si au moins 200 échantillons sont disponibles. Model Monitor calcule l’écart-type en échantillonnant au hasard 80 % des données cinq fois, en calculant la métrique et en calculant l’écart-type de ces résultats.
## Métriques de régression
L'exemple suivant illustre les métriques calculées par Model Monitor pour un problème de régression.
```
"regression_metrics" : {
"mae" : {
"value" : 0.3711832061068702,
"standard_deviation" : 0.0037566388129940394
},
"mse" : {
"value" : 0.3711832061068702,
"standard_deviation" : 0.0037566388129940524
},
"rmse" : {
"value" : 0.609248066149471,
"standard_deviation" : 0.003079253267651125
},
"r2" : {
"value" : -1.3766111872212665,
"standard_deviation" : 0.022653980022771227
}
}
```
## Métriques de classification binaire
L'exemple suivant illustre les métriques calculées par Model Monitor pour un problème de classification binaire.
```
"binary_classification_metrics" : {
"confusion_matrix" : {
"0" : {
"0" : 1,
"1" : 2
},
"1" : {
"0" : 0,
"1" : 1
}
},
"recall" : {
"value" : 1.0,
"standard_deviation" : "NaN"
},
"precision" : {
"value" : 0.3333333333333333,
"standard_deviation" : "NaN"
},
"accuracy" : {
"value" : 0.5,
"standard_deviation" : "NaN"
},
"recall_best_constant_classifier" : {
"value" : 1.0,
"standard_deviation" : "NaN"
},
"precision_best_constant_classifier" : {
"value" : 0.25,
"standard_deviation" : "NaN"
},
"accuracy_best_constant_classifier" : {
"value" : 0.25,
"standard_deviation" : "NaN"
},
"true_positive_rate" : {
"value" : 1.0,
"standard_deviation" : "NaN"
},
"true_negative_rate" : {
"value" : 0.33333333333333337,
"standard_deviation" : "NaN"
},
"false_positive_rate" : {
"value" : 0.6666666666666666,
"standard_deviation" : "NaN"
},
"false_negative_rate" : {
"value" : 0.0,
"standard_deviation" : "NaN"
},
"receiver_operating_characteristic_curve" : {
"false_positive_rates" : [ 0.0, 0.0, 0.0, 0.0, 0.0, 1.0 ],
"true_positive_rates" : [ 0.0, 0.25, 0.5, 0.75, 1.0, 1.0 ]
},
"precision_recall_curve" : {
"precisions" : [ 1.0, 1.0, 1.0, 1.0, 1.0 ],
"recalls" : [ 0.0, 0.25, 0.5, 0.75, 1.0 ]
},
"auc" : {
"value" : 1.0,
"standard_deviation" : "NaN"
},
"f0_5" : {
"value" : 0.3846153846153846,
"standard_deviation" : "NaN"
},
"f1" : {
"value" : 0.5,
"standard_deviation" : "NaN"
},
"f2" : {
"value" : 0.7142857142857143,
"standard_deviation" : "NaN"
},
"f0_5_best_constant_classifier" : {
"value" : 0.29411764705882354,
"standard_deviation" : "NaN"
},
"f1_best_constant_classifier" : {
"value" : 0.4,
"standard_deviation" : "NaN"
},
"f2_best_constant_classifier" : {
"value" : 0.625,
"standard_deviation" : "NaN"
}
}
```
## Métriques multi-classes
L’exemple suivant illustre les métriques calculées par la surveillance de la qualité des modèles pour un problème de classification multi-classes.
```
"multiclass_classification_metrics" : {
"confusion_matrix" : {
"0" : {
"0" : 1180,
"1" : 510
},
"1" : {
"0" : 268,
"1" : 138
}
},
"accuracy" : {
"value" : 0.6288167938931297,
"standard_deviation" : 0.00375663881299405
},
"weighted_recall" : {
"value" : 0.6288167938931297,
"standard_deviation" : 0.003756638812994008
},
"weighted_precision" : {
"value" : 0.6983172269629505,
"standard_deviation" : 0.006195912915307507
},
"weighted_f0_5" : {
"value" : 0.6803947317178771,
"standard_deviation" : 0.005328406973561699
},
"weighted_f1" : {
"value" : 0.6571162346664904,
"standard_deviation" : 0.004385008075019733
},
"weighted_f2" : {
"value" : 0.6384024354394601,
"standard_deviation" : 0.003867109755267757
},
"accuracy_best_constant_classifier" : {
"value" : 0.19370229007633588,
"standard_deviation" : 0.0032049848450732355
},
"weighted_recall_best_constant_classifier" : {
"value" : 0.19370229007633588,
"standard_deviation" : 0.0032049848450732355
},
"weighted_precision_best_constant_classifier" : {
"value" : 0.03752057718081697,
"standard_deviation" : 0.001241536088657851
},
"weighted_f0_5_best_constant_classifier" : {
"value" : 0.04473443104152011,
"standard_deviation" : 0.0014460485504284792
},
"weighted_f1_best_constant_classifier" : {
"value" : 0.06286421244683643,
"standard_deviation" : 0.0019113576884608862
},
"weighted_f2_best_constant_classifier" : {
"value" : 0.10570313141262414,
"standard_deviation" : 0.002734216826748117
}
}
```
## Surveillance des indicateurs de qualité des modèles avec CloudWatch
Si vous définissez la valeur de `enable_cloudwatch_metrics` à `True` lorsque vous créez le calendrier de surveillance, les tâches de surveillance de la qualité du modèle envoient toutes les métriques à CloudWatch.
Les métriques de qualité des modèles apparaissent dans l’espace de noms suivant :
+ Pour les points de terminaison en temps réel : `aws/sagemaker/Endpoints/model-metrics`
+ Pour les tâches de transformation par lots : `aws/sagemaker/ModelMonitoring/model-metrics`
Pour obtenir la liste des métriques émises, consultez les sections précédentes de cette page.
Vous pouvez utiliser CloudWatch des métriques pour créer une alarme lorsqu'une métrique spécifique n'atteint pas le seuil que vous spécifiez. Pour obtenir des instructions sur la création d' CloudWatch alarmes, voir [Création CloudWatch d'une alarme basée sur un seuil statique](https://docs.aws.amazon.com/AmazonCloudWatch/latest/monitoring/ConsoleAlarms.html) dans le *guide de CloudWatch l'utilisateur*.