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. # Surveillance de la qualité des données et des modèles avec Amazon SageMaker Model Monitor Amazon SageMaker Model Monitor surveille la qualité des modèles d'apprentissage automatique Amazon SageMaker AI en production. Model Monitor vous permet de configurer les éléments suivants : + Surveillance continue avec un point de terminaison en temps réel. + Surveillance continue avec une tâche de transformation par lots exécutée régulièrement. + Surveillance planifiée des tâches de transformation par lots asynchrones. Avec Model Monitor, vous pouvez définir des alertes d’avertissement en cas d’écarts dans la qualité du modèle. La détection précoce et proactive de ces écarts vous permet de prendre des mesures correctives. Vous pouvez prendre des mesures comme le ré-entraînement des modèles, l’audit des systèmes en amont ou la résolution des problèmes de qualité sans avoir à surveiller manuellement les modèles ou à générer des outils supplémentaires. Vous pouvez utiliser des fonctionnalités de surveillance préconçues de Model Monitor qui ne nécessitent pas de codage. Vous avez également la possibilité de contrôler les modèles par codage afin de fournir une analyse personnalisée. Model Monitor fournit les types de surveillance suivants : + [Qualité des données](model-monitor-data-quality.md) - Surveillance d'écarts dans la qualité des données. + [Qualité des modèles](model-monitor-model-quality.md) - Surveillance d’écarts dans les métriques de qualité du modèle, la précision par exemple. + [Dérive de biais pour les modèles en production](clarify-model-monitor-bias-drift.md) - Surveillance du biais dans les prédictions de votre modèle. + [Dérive d’attribution de caractéristiques pour les modèles en production](clarify-model-monitor-feature-attribution-drift.md) : surveillez la dérive d’attribution de caractéristiques. **Topics** + [Surveillance d’un modèle en production](how-it-works-model-monitor.md) + [Comment fonctionne Amazon SageMaker Model Monitor](#model-monitor-how-it-works) + [Capture des données](model-monitor-data-capture.md) + [Qualité des données](model-monitor-data-quality.md) + [Qualité des modèles](model-monitor-model-quality.md) + [Dérive de biais pour les modèles en production](clarify-model-monitor-bias-drift.md) + [Dérive d’attribution de caractéristiques pour les modèles en production](clarify-model-monitor-feature-attribution-drift.md) + [Planification des tâches de surveillance](model-monitor-scheduling.md) + [Conteneur préfabriqué Amazon SageMaker Model Monitor](model-monitor-pre-built-container.md) + [Interprétation des résultats](model-monitor-interpreting-results.md) + [Visualisez les résultats pour les points de terminaison en temps réel dans Amazon Studio SageMaker](model-monitor-interpreting-visualize-results.md) + [Rubriques avancées](model-monitor-advanced-topics.md) + [Modèle de moniteur FAQs](model-monitor-faqs.md) # Surveillance d’un modèle en production Après avoir déployé un modèle dans votre environnement de production, utilisez Amazon SageMaker Model Monitor pour surveiller en permanence la qualité de vos modèles de machine learning en temps réel. Amazon SageMaker Model Monitor vous permet de configurer un système de déclenchement automatique d'alertes en cas d'écarts dans la qualité du modèle, tels que des dérives de données ou des anomalies. Amazon CloudWatch Logs collecte des fichiers journaux pour surveiller l'état du modèle et vous avertit lorsque la qualité de votre modèle atteint certains seuils que vous avez prédéfinis. CloudWatch stocke les fichiers journaux dans un compartiment Amazon S3 que vous spécifiez. La détection précoce et proactive des écarts de AWS modèle grâce aux produits de surveillance des modèles vous permet de prendre des mesures rapides pour maintenir et améliorer la qualité de votre modèle déployé. Pour plus d'informations sur les produits SageMaker Model Monitoring, consultez[Surveillance de la qualité des données et des modèles avec Amazon SageMaker Model Monitor](model-monitor.md). Pour commencer votre parcours d'apprentissage automatique avec l' SageMaker IA, créez un AWS compte sur [Set Up SageMaker AI](https://docs.aws.amazon.com/sagemaker/latest/dg/gs-set-up.html). ## Comment fonctionne Amazon SageMaker Model Monitor Amazon SageMaker Model Monitor surveille automatiquement les modèles d'apprentissage automatique (ML) en production et vous avertit en cas de problème de qualité. Model Monitor utilise des règles pour détecter les écarts dans vos modèles et vous en avertit le cas échéant. La figure suivante montre comment ce processus fonctionne dans le cas où votre modèle est déployé sur un point de terminaison en temps réel. ![\[Le processus de surveillance des modèles avec Amazon SageMaker Model Monitor.\]](http://docs.aws.amazon.com/fr_fr/sagemaker/latest/dg/images/model_monitor/mmv2-architecture.png) Vous pouvez également utiliser Model Monitor pour surveiller une tâche de transformation par lots plutôt qu’un point de terminaison en temps réel. Dans ce cas, au lieu de recevoir des demandes vers un point de terminaison et de suivre les prédictions, Model Monitor surveille les entrées et les sorties d’inférence. La figure suivante illustre le processus de surveillance d’une tâche de transformation par lots. ![\[Le processus de surveillance des modèles avec Amazon SageMaker Model Monitor.\]](http://docs.aws.amazon.com/fr_fr/sagemaker/latest/dg/images/model_monitor/mmv2-architecture-batch.png) Pour activer la surveillance de modèle, procédez comme suit. Ces étapes suivent le cheminement des données à travers les différents processus de collecte, de surveillance et d’analyse des données. + Pour un point de terminaison en temps réel, activez le point de terminaison pour qu’il capture les données issues des requêtes entrantes dans un modèle ML entraîné et les prédictions de modèle résultantes. + Pour une tâche de transformation par lots, activez la capture des données des entrées et des sorties de transformation par lots. + Créez une référence à partir du jeu de données utilisé pour entraîner le modèle. La référence calcule les métriques et suggère des contraintes pour les métriques. Les prédictions en temps réel ou par lots réalisées à partir de votre modèle sont comparées aux contraintes. Elles sont signalées comme des violations si elles se situent hors des valeurs contraintes. + Créez un programme de surveillance spécifiant les données à collecter, la fréquence de collecte, la méthode d’analyse et les rapports à produire. + Examinez les rapports, qui comparent les données les plus récentes à la référence. Surveillez les violations signalées, les statistiques et les notifications d'Amazon CloudWatch. **Remarques** Model Monitor calcule les mesures et les statistiques du modèle uniquement sur des données tabulaires. Par exemple, un modèle de classification d'images qui prend des images en tant qu'entrée et génère une étiquette basée sur ces images en sortie peut toujours être surveillé. Model Monitor serait capable de calculer des mesures et des statistiques pour la sortie, et non pour l'entrée. Model Monitor prend actuellement en charge uniquement les points de terminaison qui hébergent un seul modèle, pas les points de terminaison multimodèle. Pour plus d’informations sur l’utilisation des points de terminaison multimodèles, consultez [Points de terminaison multimodèles](multi-model-endpoints.md). Model Monitor prend en charge la surveillance des pipelines d’inférence. Toutefois, la capture et l’analyse des données sont effectuées pour l’ensemble du pipeline, et non pour les conteneurs individuels du pipeline. Pour éviter tout impact sur les requêtes d’inférence, Data Capture cesse de capturer les requêtes à des niveaux élevés d’utilisation du disque. Nous vous recommandons de maintenir l’utilisation du disque en dessous de 75 % pour que la capture des données continue de capturer les demandes. Si vous lancez SageMaker Studio dans un Amazon VPC personnalisé, vous devez créer des points de terminaison VPC pour permettre à Model Monitor de communiquer avec Amazon S3 et. CloudWatch Pour plus d’informations sur les points de terminaison d’un VPC, consultez [Points de terminaison d’un VPC](https://docs.aws.amazon.com/vpc/latest/privatelink/concepts.html) dans le *Guide de l’utilisateur Amazon Virtual Private Cloud*. Pour plus d'informations sur le lancement de SageMaker Studio dans un VPC personnalisé, consultez. [Connexion des blocs-notes Studio d’un VPC à des ressources externes](studio-notebooks-and-internet-access.md) ### Exemples de blocs-notes Model Monitor Pour un exemple de bloc-notes qui vous explique le end-to-end flux de travail à l'aide de Model Monitor avec votre point de terminaison en temps réel, consultez [Introduction à Amazon SageMaker Model Monitor](https://sagemaker-examples.readthedocs.io/en/latest/sagemaker_model_monitor/introduction/SageMaker-ModelMonitoring.html). Pour obtenir un exemple de bloc-notes qui visualise le fichier statistics.json correspondant à une exécution sélectionnée dans un programme de surveillance, consultez [Model Monitor Visualization](https://sagemaker-examples.readthedocs.io/en/latest/sagemaker_model_monitor/visualization/SageMaker-Model-Monitor-Visualize.html). Pour obtenir des instructions sur la façon de créer et d'accéder à des instances de bloc-notes Jupyter que vous pouvez utiliser pour exécuter l'exemple dans SageMaker AI, consultez. [Instances de SageMaker blocs-notes Amazon](nbi.md) Après avoir créé une instance de bloc-notes et l'avoir ouverte, choisissez l'onglet **Exemples d'SageMaker IA** pour voir la liste de tous les exemples d' SageMaker IA. Pour ouvrir un bloc-notes, choisissez l’onglet de bloc-notes **Utiliser**, puis **Créer une copie**. # Capture des données Pour journaliser les entrées de votre point de terminaison et les sorties d'inférence de votre modèle déployé sur Amazon S3, vous pouvez activer une fonction appelée *Data Capture* (Capture de données). La fonction *Data Capture* (Capture de données) est généralement utilisée pour enregistrer des informations qui peuvent être utilisées pour l'entraînement, le débogage et la surveillance. Amazon SageMaker Model Monitor analyse automatiquement ces données capturées et compare les mesures issues de ces données avec une référence que vous créez pour le modèle. Pour obtenir plus d’informations sur Model Monitor, consultez [Surveillance de la qualité des données et des modèles avec Amazon SageMaker Model Monitor](model-monitor.md). Vous pouvez implémenter la *capture de données* pour les modes de surveillance du modèle en temps réel et par lots à l'aide du SDK Python AWS SDK pour Python (Boto) ou du SDK SageMaker Python. Pour un point de terminaison en temps réel, vous devez spécifier votre configuration de *Data Capture* (Capture de données) lors de la création de votre point de terminaison. En raison de la nature persistante de votre point de terminaison en temps réel, vous pouvez configurer des options supplémentaires pour activer ou désactiver la capture de données à certains moments, ou modifier la fréquence d'échantillonnage. Vous pouvez également choisir de chiffrer vos données d'inférence. Pour une tâche de transformation par lots, vous pouvez activer *Data Capture* (Capture de données) si vous souhaitez exécuter une surveillance des modèles dans les délais ou une surveillance continue des modèles pour des tâches de transformation par lots régulières et périodiques. Vous spécifierez votre configuration de *Data Capture* (Capture de données) lorsque vous créerez votre tâche de transformation par lots. Dans cette configuration, vous avez la possibilité d'activer le chiffrement ou de générer l'identifiant d'inférence avec votre sortie, ce qui vous permet de faire correspondre vos données capturées aux données Ground Truth. # Capture des données à partir du point de terminaison en temps réel **Note** Pour éviter tout impact sur les requêtes d’inférence, Data Capture cesse de capturer les requêtes à des niveaux élevés d’utilisation du disque. Nous vous recommandons de maintenir l’utilisation du disque en dessous de 75 % pour que la capture des données continue de capturer les requêtes. Pour capturer des données pour votre point de terminaison en temps réel, vous devez déployer un modèle à l'aide de services d'hébergement basés sur l' SageMaker IA. Cela nécessite que vous créiez un modèle d' SageMaker IA, que vous définissiez une configuration de point de terminaison et que vous créiez un point de terminaison HTTPS. Les étapes requises pour activer la capture de données sont similaires, que vous utilisiez le SDK Python AWS SDK pour Python (Boto) ou le SDK SageMaker Python. Si vous utilisez le AWS SDK, définissez le [DataCaptureConfig](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_DataCaptureConfig.html)dictionnaire, ainsi que les champs obligatoires, dans la [CreateEndpointConfig](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_CreateEndpointConfig.html)méthode pour activer la capture de données. Si vous utilisez le SDK SageMaker Python, importez la [DataCaptureConfig](https://sagemaker.readthedocs.io/en/stable/api/inference/model_monitor.html#sagemaker.model_monitor.data_capture_config.DataCaptureConfig)classe et initialisez une instance à partir de cette classe. Puis, transmettez cet objet au paramètre `DataCaptureConfig` dans la méthode `sagemaker.model.Model.deploy()`. Pour utiliser les extraits de code suivants, remplacez ceux de l'exemple *italicized placeholder text* de code par vos propres informations. ## Comment activer la capture des données Spécifiez une configuration de capture de données. Avec cette configuration, vous pouvez capturer la charge utile de la demande et/ou la charge utile de la réponse. L'extrait de code suivant montre comment activer la capture de données à l'aide du SDK AWS SDK pour Python (Boto) et du SDK AI SageMaker Python. **Note** Vous n’avez pas besoin d’utiliser Model Monitor pour capturer les données utiles des requêtes ou des réponses. ------ #### [ AWS SDK pour Python (Boto) ] Configurez les données que vous souhaitez capturer avec le [DataCaptureConfig](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_DataCaptureConfig.html)dictionnaire lorsque vous créez un point de terminaison à l'aide de `CreateEndpointConfig` cette méthode. Définissez `EnableCapture` sur la valeur booléenne True. En outre, fournissez les paramètres obligatoires suivants : + `EndpointConfigName` : le nom de la configuration du point de terminaison. Vous utiliserez ce nom lorsque vous émettrez une requête `CreateEndpoint`. + `ProductionVariants` : une liste des modèles que vous souhaitez héberger dans ce point de terminaison. Définissez un type de données de dictionnaire pour chaque modèle. + `DataCaptureConfig` : type de données de dictionnaire où vous spécifiez une valeur entière qui correspond au pourcentage initial de données à échantillonner (`InitialSamplingPercentage`), l'URI Amazon S3 où vous voulez que les données capturées soient stockées et une liste d'options de capture (`CaptureOptions`). Spécifiez soit `Input` ou `Output` pour le champ `CaptureMode` dans la liste `CaptureOptions`. Vous pouvez éventuellement spécifier la manière dont l' SageMaker IA doit encoder les données capturées en transmettant des arguments de paire clé-valeur au dictionnaire. `CaptureContentTypeHeader` ``` # Create an endpoint config name. endpoint_config_name = '' # The name of the production variant. variant_name = '' # The name of the model that you want to host. # This is the name that you specified when creating the model. model_name = '' instance_type = '' #instance_type='ml.m5.xlarge' # Example # Number of instances to launch initially. initial_instance_count = # Sampling percentage. Choose an integer value between 0 and 100 initial_sampling_percentage = # The S3 URI containing the captured data s3_capture_upload_path = 's3:///' # Specify either Input, Output, or both capture_modes = [ "Input", "Output" ] #capture_mode = [ "Input"] # Example - If you want to capture input only endpoint_config_response = sagemaker_client.create_endpoint_config( EndpointConfigName=endpoint_config_name, # List of ProductionVariant objects, one for each model that you want to host at this endpoint. ProductionVariants=[ { "VariantName": variant_name, "ModelName": model_name, "InstanceType": instance_type, # Specify the compute instance type. "InitialInstanceCount": initial_instance_count # Number of instances to launch initially. } ], DataCaptureConfig= { 'EnableCapture': True, # Whether data should be captured or not. 'InitialSamplingPercentage' : initial_sampling_percentage, 'DestinationS3Uri': s3_capture_upload_path, 'CaptureOptions': [{"CaptureMode" : capture_mode} for capture_mode in capture_modes] # Example - Use list comprehension to capture both Input and Output } ) ``` Pour plus d'informations sur les autres options de configuration des terminaux, consultez l'[CreateEndpointConfig](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_CreateEndpointConfig.html)API dans le [guide de référence de l'API Amazon SageMaker AI Service](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_Operations_Amazon_SageMaker_Service.html). ------ #### [ SageMaker Python SDK ] Importez la classe `DataCaptureConfig` du module [sagemaker.model\$1monitor](https://sagemaker.readthedocs.io/en/stable/api/inference/model_monitor.html). Activez la capture de données en définissant `EnableCapture` sur la valeur booléenne `True`. Vous pouvez également fournir des arguments pour les paramètres suivants : + `SamplingPercentage` : une valeur entière qui correspond au pourcentage de données à échantillonner. Si vous ne fournissez pas de pourcentage d'échantillonnage, SageMaker AI échantillonnera par défaut 20 (20 %) de vos données. + `DestinationS3Uri`: l'URI Amazon S3 sera utilisée par l' SageMaker IA pour stocker les données capturées. Si vous n'en fournissez pas, l' SageMaker IA y stockera les données capturées`"s3:/// model-monitor/data-capture"`. ``` from sagemaker.model_monitor import DataCaptureConfig # Set to True to enable data capture enable_capture = True # Optional - Sampling percentage. Choose an integer value between 0 and 100 sampling_percentage = # sampling_percentage = 30 # Example 30% # Optional - The S3 URI of stored captured-data location s3_capture_upload_path = 's3:///' # Specify either Input, Output or both. capture_modes = ['REQUEST','RESPONSE'] # In this example, we specify both # capture_mode = ['REQUEST'] # Example - If you want to only capture input. # Configuration object passed in when deploying Models to SM endpoints data_capture_config = DataCaptureConfig( enable_capture = enable_capture, sampling_percentage = sampling_percentage, # Optional destination_s3_uri = s3_capture_upload_path, # Optional capture_options = ["REQUEST", "RESPONSE"], ) ``` ------ ## Déployer votre modèle Déployez votre modèle et créez un point de terminaison HTTPS avec `DataCapture` activée. ------ #### [ AWS SDK pour Python (Boto3) ] Fournissez la configuration du point de terminaison à SageMaker AI. Le service lance les instances de calcul ML et déploie le ou les modèles tel que spécifié dans la configuration. Une fois que vous avez votre configuration de modèle et de point de terminaison, utilisez l’API [https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_CreateEndpoint.html](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_CreateEndpoint.html) pour créer votre point de terminaison. Le nom du point de terminaison doit être unique dans une AWS région de votre AWS compte. L’exemple suivant crée un point de terminaison à l’aide de la configuration de point de terminaison spécifiée dans la requête. Amazon SageMaker AI utilise le point de terminaison pour provisionner des ressources et déployer des modèles. ``` # The name of the endpoint. The name must be unique within an AWS Region in your AWS account. endpoint_name = '' # The name of the endpoint configuration associated with this endpoint. endpoint_config_name='' create_endpoint_response = sagemaker_client.create_endpoint( EndpointName=endpoint_name, EndpointConfigName=endpoint_config_name) ``` Pour en savoir plus, consultez l’API [https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_CreateEndpoint.html](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_CreateEndpoint.html). ------ #### [ SageMaker Python SDK ] Définissez un nom pour votre point de terminaison. Cette étape est facultative. Si vous n'en fournissez pas, SageMaker AI créera un nom unique pour vous : ``` from datetime import datetime endpoint_name = f"DEMO-{datetime.utcnow():%Y-%m-%d-%H%M}" print("EndpointName =", endpoint_name) ``` Déployez votre modèle sur un point de terminaison HTTPS en temps réel avec la méthode `deploy()` intégrée de l’objet modèle. Indiquez le nom du type d’instance Amazon EC2 sur lequel déployer ce modèle dans le champ `instance_type` ainsi que le nombre initial d’instances sur lesquelles exécuter le point de terminaison dans le champ `initial_instance_count` : ``` initial_instance_count= # initial_instance_count=1 # Example instance_type='' # instance_type='ml.m4.xlarge' # Example # Uncomment if you did not define this variable in the previous step #data_capture_config = model.deploy( initial_instance_count=initial_instance_count, instance_type=instance_type, endpoint_name=endpoint_name, data_capture_config=data_capture_config ) ``` ------ ## Affichage des données capturées Créez un objet prédicteur à partir de la classe [prédictive](https://sagemaker.readthedocs.io/en/stable/api/inference/predictors.html) du SDK SageMaker Python. Vous utiliserez l'objet renvoyé par la classe `Predictor` pour appeler votre point de terminaison dans une étape ultérieure. Fournissez le nom de votre point de terminaison (défini précédemment comme `endpoint_name`), ainsi que les objets serializer et deserializer pour le sérialiseur et le désérialiseur, respectivement. [Pour plus d'informations sur les types de sérialiseurs, consultez la classe [Serializers](https://sagemaker.readthedocs.io/en/stable/api/inference/serializers.html) dans le SDK AI SageMaker Python.](https://sagemaker.readthedocs.io/en/stable/index.html) ``` from sagemaker.predictor import Predictor from sagemaker.serializers import from sagemaker.deserializers import predictor = Predictor(endpoint_name=endpoint_name, serializer = , deserializer = ) # Example #from sagemaker.predictor import Predictor #from sagemaker.serializers import CSVSerializer #from sagemaker.deserializers import JSONDeserializer #predictor = Predictor(endpoint_name=endpoint_name, # serializer=CSVSerializer(), # deserializer=JSONDeserializer()) ``` Dans l’exemple de code de traitement, nous invoquons le point de terminaison avec un échantillon de données de validation que nous avons stocké localement dans un fichier CSV nommé `validation_with_predictions`. Notre échantillon de jeu de validation contient des étiquettes pour chaque entrée. Les premières lignes de l'instruction with ouvrent d'abord le fichier CSV du jeu de validation, puis séparent chaque ligne du fichier par le caractère virgule `","`, et enfin stockent les deux objets renvoyés dans les variables label et input\$1cols. Pour chaque ligne, l'entrée (`input_cols`) est transmise à la méthode intégrée des objets `Predictor.predict()` de la variable predictor (`predictor`). Supposons que le modèle renvoie une probabilité. Les probabilités sont comprises entre les valeurs entières de 0 et 1,0. Si la probabilité renvoyée par le modèle est supérieure à 80 % (0,8), nous attribuons à la prédiction une étiquette de valeur entière de 1. Sinon, nous attribuons à la prédiction une étiquette de valeur entière de 0. ``` from time import sleep validate_dataset = "validation_with_predictions.csv" # Cut off threshold of 80% cutoff = 0.8 limit = 200 # Need at least 200 samples to compute standard deviations i = 0 with open(f"test_data/{validate_dataset}", "w") as validation_file: validation_file.write("probability,prediction,label\n") # CSV header with open("test_data/validation.csv", "r") as f: for row in f: (label, input_cols) = row.split(",", 1) probability = float(predictor.predict(input_cols)) prediction = "1" if probability > cutoff else "0" baseline_file.write(f"{probability},{prediction},{label}\n") i += 1 if i > limit: break print(".", end="", flush=True) sleep(0.5) print() print("Done!") ``` Comme vous avez activé la capture des données aux étapes précédentes, la charge utile des requêtes et réponses et certaines métadonnées supplémentaires sont enregistrées à l'emplacement Amazon S3 que vous avez spécifié dans `DataCaptureConfig`. La livraison des données de capture à Amazon S3 peut prendre quelques minutes. Affichez les données capturées en répertoriant les fichiers de capture de données stockés dans Amazon S3. Le format du chemin d'accès Amazon S3 est : `s3:///{endpoint-name}/{variant-name}/yyyy/mm/dd/hh/filename.jsonl`. Il peut y avoir différents fichiers de différentes périodes, organisés en fonction de l’heure de l’invocation. Exécutez la commande suivante pour afficher le contenu d’un seul fichier de capture : ``` print("\n".join(capture_file[-3:-1])) ``` Cela renverra un fichier au format JSON-line spécifique à l' SageMaker IA. Voici un exemple de réponse provenant d’un point de terminaison en temps réel que nous avons appelé en utilisant des données `csv/text` : ``` {"captureData":{"endpointInput":{"observedContentType":"text/csv","mode":"INPUT", "data":"69,0,153.7,109,194.0,105,256.1,114,14.1,6,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,1,0,1,0\n", "encoding":"CSV"},"endpointOutput":{"observedContentType":"text/csv; charset=utf-8","mode":"OUTPUT","data":"0.0254181120544672","encoding":"CSV"}}, "eventMetadata":{"eventId":"aaaaaaaa-bbbb-cccc-dddd-eeeeeeeeeeee","inferenceTime":"2022-02-14T17:25:49Z"},"eventVersion":"0"} {"captureData":{"endpointInput":{"observedContentType":"text/csv","mode":"INPUT", "data":"94,23,197.1,125,214.5,136,282.2,103,9.5,5,4,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,1,0,1\n", "encoding":"CSV"},"endpointOutput":{"observedContentType":"text/csv; charset=utf-8","mode":"OUTPUT","data":"0.07675473392009735","encoding":"CSV"}}, "eventMetadata":{"eventId":"aaaaaaaa-bbbb-cccc-dddd-eeeeeeeeeeee","inferenceTime":"2022-02-14T17:25:49Z"},"eventVersion":"0"} ``` Dans l'exemple de traitement, l'objet `capture_file` est un type de liste. Indexez le premier élément de la liste pour afficher une seule requête d'inférence. ``` # The capture_file object is a list. Index the first element to view a single inference request print(json.dumps(json.loads(capture_file[0]), indent=2)) ``` Cela renvoie une réponse semblable à ce qui suit. Les valeurs renvoyées varieront en fonction de la configuration de votre point de terminaison, de votre modèle d' SageMaker IA et des données capturées : ``` { "captureData": { "endpointInput": { "observedContentType": "text/csv", # data MIME type "mode": "INPUT", "data": "50,0,188.9,94,203.9,104,151.8,124,11.6,8,3,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,1,0,1,0\n", "encoding": "CSV" }, "endpointOutput": { "observedContentType": "text/csv; charset=character-encoding", "mode": "OUTPUT", "data": "0.023190177977085114", "encoding": "CSV" } }, "eventMetadata": { "eventId": "aaaaaaaa-bbbb-cccc-dddd-eeeeeeeeeeee", "inferenceTime": "2022-02-14T17:25:06Z" }, "eventVersion": "0" } ``` # Capture des données à partir d’une tâche de transformation par lots Les étapes requises pour activer la capture de données pour votre tâche de transformation par lots sont similaires, que vous utilisiez le SDK Python AWS SDK pour Python (Boto) ou le SDK SageMaker Python. Si vous utilisez le AWS SDK, définissez le [DataCaptureConfig](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_DataCaptureConfig.html)dictionnaire, ainsi que les champs obligatoires, dans la `CreateTransformJob` méthode pour activer la capture de données. Si vous utilisez le SDK SageMaker AI Python, importez la `BatchDataCaptureConfig` classe et initialisez une instance à partir de cette classe. Transmettez ensuite cet objet au paramètre `batch_data_capture_config` de votre instance de tâche de transformation. Pour utiliser les extraits de code suivants, remplacez ceux de l'exemple *italicized placeholder text* de code par vos propres informations. ## Comment activer la capture des données Spécifiez une configuration de capture de données lorsque vous lancez une tâche de transformation. Que vous utilisiez le SDK AWS SDK pour Python (Boto3) ou le SDK SageMaker Python, vous devez fournir l'`DestinationS3Uri`argument, qui est le répertoire dans lequel vous souhaitez que la tâche de transformation enregistre les données capturées. (Facultatif) Vous pouvez également préciser les paramètres suivants : + `KmsKeyId`: AWS KMS clé utilisée pour chiffrer les données capturées. + `GenerateInferenceId` : un indicateur booléen qui, lors de la capture des données, indique si vous souhaitez que la tâche de transformation ajoute l'ID d'inférence et l'heure à votre sortie. Cela est utile pour la surveillance de la qualité des modèles, lorsque vous devez ingérer les données Ground Truth. L'ID d'inférence et l'heure permettent de faire correspondre les données capturées à vos données Ground Truth. ------ #### [ AWS SDK pour Python (Boto3) ] Configurez les données que vous souhaitez capturer avec le [DataCaptureConfig](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_DataCaptureConfig.html)dictionnaire lorsque vous créez une tâche de transformation à l'aide de `CreateTransformJob` cette méthode. ``` input_data_s3_uri = "s3://input_S3_uri" output_data_s3_uri = "s3://output_S3_uri" data_capture_destination = "s3://captured_data_S3_uri" model_name = "model_name" sm_client.create_transform_job( TransformJobName="transform_job_name", MaxConcurrentTransforms=2, ModelName=model_name, TransformInput={ "DataSource": { "S3DataSource": { "S3DataType": "S3Prefix", "S3Uri": input_data_s3_uri, } }, "ContentType": "text/csv", "CompressionType": "None", "SplitType": "Line", }, TransformOutput={ "S3OutputPath": output_data_s3_uri, "Accept": "text/csv", "AssembleWith": "Line", }, TransformResources={ "InstanceType": "ml.m4.xlarge", "InstanceCount": 1, }, DataCaptureConfig={ "DestinationS3Uri": data_capture_destination, "KmsKeyId": "kms_key", "GenerateInferenceId": True, } ) ``` ------ #### [ SageMaker Python SDK ] Importez la classe `BatchDataCaptureConfig` du module [sagemaker.model\$1monitor](https://sagemaker.readthedocs.io/en/stable/api/inference/model_monitor.html). ``` from sagemaker.transformer import Transformer from sagemaker.inputs import BatchDataCaptureConfig # Optional - The S3 URI of where to store captured data in S3 data_capture_destination = "s3://captured_data_S3_uri" model_name = "model_name" transformer = Transformer(model_name=model_name, ...) transform_arg = transformer.transform( batch_data_capture_config=BatchDataCaptureConfig( destination_s3_uri=data_capture_destination, kms_key_id="kms_key", generate_inference_id=True, ), ... ) ``` ------ ## Comment afficher les données capturées Une fois la tâche de transformation terminée, les données capturées sont journalisées sous `DestinationS3Uri` que vous avez fournie avec la configuration de capture de données. Il existe deux sous-répertoires sous `DestinationS3Uri`, `/input` et `/output`. Si `DestinationS3Uri` est `s3://my-data-capture`, la tâche de transformation crée les répertoires suivants : + `s3://my-data-capture/input` : les données d'entrée capturées pour la tâche de transformation. + `s3://my-data-capture/output` : les données de sortie capturées pour la tâche de transformation. Pour éviter la duplication des données, les données capturées dans les deux répertoires précédents sont des manifestes. Chaque manifeste est un fichier JSONL qui contient les emplacements Amazon S3 des objets sources. Un fichier manifeste peut ressembler à l'exemple suivant : ``` # under "/input" directory [ {"prefix":"s3://input_S3_uri/"}, "dummy_0.csv", "dummy_1.csv", "dummy_2.csv", ... ] # under "/output" directory [ {"prefix":"s3://output_S3_uri/"}, "dummy_0.csv.out", "dummy_1.csv.out", "dummy_2.csv.out", ... ] ``` La tâche de transformation organise et étiquette ces manifestes avec un préfixe *yyyy/mm/dd/hh* S3 pour indiquer quand ils ont été capturés. Cela permet à Model Monitor de déterminer la partie appropriée des données à analyser. Par exemple, si vous commencez votre tâche de transformation le 26 août 2022 à 13 h UTC, les données capturées sont étiquetées avec une chaîne de préfixe `2022/08/26/13/`. ## InferenceId Génération Lorsque vous configurez `DataCaptureConfig` pour une tâche de transformation, vous pouvez activer l'indicateur booléen `GenerateInferenceId`. Cela est particulièrement utile lorsque vous devez exécuter des tâches de surveillance de la qualité et du biais des modèles, pour lesquelles vous avez besoin de données Ground Truth ingérées par les utilisateurs. Model Monitor s'appuie sur un ID d'inférence pour faire correspondre les données capturées et les données de Ground Truth. Pour plus de détails sur l'ingestion de Ground Truth, consultez [Ingestion et fusion des étiquettes Ground Truth avec des prédictions](model-monitor-model-quality-merge.md). Lorsque `GenerateInferenceId` est activé, la sortie de transformation ajoute un ID d'inférence (un UUID aléatoire) ainsi que l'heure de début de la tâche de transformation en UTC pour chaque enregistrement. Vous avez besoin de ces deux valeurs pour contrôler la qualité des modèles et le biais des modèles. Lorsque vous créez les données Ground Truth, vous devez fournir le même identifiant d'inférence pour correspondre aux données de sortie. Actuellement, cette fonction prend en charge les sorties de transformation aux formats CSV, JSON et JSONL. Si la sortie de votre transformation est au format CSV, le fichier de sortie ressemble à l'exemple suivant : ``` 0, 1f1d57b1-2e6f-488c-8c30-db4e6d757861,2022-08-30T00:49:15Z 1, 22445434-0c67-45e9-bb4d-bd1bf26561e6,2022-08-30T00:49:15Z ... ``` Les deux dernières colonnes contiennent l'ID d'inférence et l'heure de début de la tâche de transformation. Ne les modifiez pas. Les colonnes restantes sont les sorties de vos tâches de transformation. Si la sortie de votre transformation est au format JSON ou JSONL, le fichier de sortie ressemble à l'exemple suivant : ``` {"output": 0, "SageMakerInferenceId": "1f1d57b1-2e6f-488c-8c30-db4e6d757861", "SageMakerInferenceTime": "2022-08-30T00:49:15Z"} {"output": 1, "SageMakerInferenceId": "22445434-0c67-45e9-bb4d-bd1bf26561e6", "SageMakerInferenceTime": "2022-08-30T00:49:15Z"} ... ``` Deux champs ajoutés sont réservés, `SageMakerInferenceId` et `SageMakerInferenceTime`. Ne modifiez pas ces champs si vous devez contrôler la qualité des modèles ou le biais des modèles. Vous en avez besoin pour les tâches de fusion. # Qualité des données La surveillance de la qualité des données contrôle automatiquement les modèles de machine learning (ML) en production et vous avertit en cas de problèmes liés à la qualité des données. Les modèles ML en production doivent faire des prédictions par rapport aux données concrètes qui ne sont pas soigneusement organisées, comme la plupart des jeux de données pour l'entraînement. Si la nature statistique des données reçues par votre modèle en production diffère de la nature des données de référence sur lesquelles il a été entraîné, le modèle commence à produire des prédictions moins précises. Amazon SageMaker Model Monitor utilise des règles pour détecter la dérive des données et vous alerte lorsque cela se produit. Pour contrôler la qualité des données, 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 analyse le jeu de données d'entrée que vous fournissez. La tâche calcule les contraintes et les statistiques du schéma de référence pour chaque fonction à l'aide de [Deequ](https://github.com/awslabs/deequ), une bibliothèque open source créée sur Apache Spark et utilisée pour mesurer la qualité des données dans les jeux de données volumineux. Pour de plus amples informations, veuillez consulter [Création d’une référence](model-monitor-create-baseline.md). + Définissez et planifiez des tâches de surveillance de la qualité des données. Pour obtenir des informations spécifiques et des exemples de code sur les tâches de surveillance de la qualité des données, consultez [Planification des tâches de surveillance de la qualité des données](model-monitor-schedule-data-monitor.md). Pour des informations générales sur les tâches de surveillance, consultez [Planification des tâches de surveillance](model-monitor-scheduling.md). + Utilisez le cas échéant des scripts de prétraitement et de post-traitement pour transformer les données issues de votre analyse de la qualité des données. Pour de plus amples informations, veuillez consulter [Prétraitement et post-traitement](model-monitor-pre-and-post-processing.md). + Affichez les métriques de qualité des données. Pour de plus amples informations, veuillez consulter [Schéma des statistiques (fichier statistics.json)](model-monitor-interpreting-statistics.md). + Intégrez la surveillance de la qualité des données à Amazon CloudWatch. Pour de plus amples informations, veuillez consulter [CloudWatch Métriques](model-monitor-interpreting-cloudwatch.md). + 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 activer la surveillance de la qualité des données et visualiser les résultats si vous utilisez un point de terminaison en temps réel. 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). **Note** Model Monitor calcule les mesures et les statistiques du modèle uniquement sur des données tabulaires. Par exemple, un modèle de classification d'images qui prend des images en tant qu'entrée et génère une étiquette basée sur ces images en sortie peut toujours être surveillé. Model Monitor serait capable de calculer des mesures et des statistiques pour la sortie, et non pour l'entrée. **Topics** + [Création d’une référence](model-monitor-create-baseline.md) + [Planification des tâches de surveillance de la qualité des données](model-monitor-schedule-data-monitor.md) + [Schéma des statistiques (fichier statistics.json)](model-monitor-interpreting-statistics.md) + [CloudWatch Métriques](model-monitor-interpreting-cloudwatch.md) + [Schéma des violations (fichier constraint\$1violations.json)](model-monitor-interpreting-violations.md) # Création d’une référence Les calculs de référence des statistiques et des contraintes sont nécessaires en tant que norme pour savoir quels problèmes d'écarts des données et autres problèmes de qualité peuvent être détectés. Model Monitor fournit un conteneur intégré capable de suggérer automatiquement les contraintes pour les entrées CSV et JSON plat. Ce *sagemaker-model-monitor-analyzer*conteneur vous fournit également une gamme de fonctionnalités de surveillance des modèles, notamment la validation des contraintes par rapport à une référence et l'émission de CloudWatch métriques Amazon. Ce conteneur est basé sur Spark version 3.3.0 et est construit avec [Deequ](https://github.com/awslabs/deequ) version 2.0.2. Tous les noms de colonnes de votre jeu de données de référence doivent être conformes à Spark. Pour les noms de colonnes, utilisez uniquement des minuscules et `_` comme caractère spécial. Le jeu de données d'entraînement utilisé pour entraîner le modèle est généralement un bon jeu de données de référence. Les schémas du jeu de données d’entraînement et du jeu de données d’inférence doivent correspondre exactement (nombre et ordre des fonctions). Notez que les prediction/output colonnes sont supposées être les premières colonnes de l'ensemble de données d'apprentissage. À partir de l'ensemble de données d'entraînement, vous pouvez demander à l' SageMaker IA de suggérer un ensemble de contraintes de base et de générer des statistiques descriptives pour explorer les données. Pour cet exemple, chargez l’ensemble des données d’entraînement qui a servi à entraîner le modèle préentraîné inclus. Si vous avez déjà stocké le jeu de données d'entraînement dans Amazon S3, vous pouvez pointer directement dessus. **Pour créer une référence à partir d'un jeu de données d'entraînement** Lorsque vos données d'entraînement sont prêtes et stockées dans Amazon S3, lancez une tâche de traitement de base à `DefaultModelMonitor.suggest_baseline(..)` l'aide du [SDK Amazon SageMaker Python](https://sagemaker.readthedocs.io/en/stable). Un [Conteneur préfabriqué Amazon SageMaker Model Monitor](model-monitor-pre-built-container.md) est alors utilisé afin de générer des statistiques de référence et de suggérer des contraintes de référence pour le jeu de données, puis de les écrire à l’emplacement `output_s3_uri` que vous spécifiez. ``` from sagemaker.model_monitor import DefaultModelMonitor from sagemaker.model_monitor.dataset_format import DatasetFormat my_default_monitor = DefaultModelMonitor( role=role, instance_count=1, instance_type='ml.m5.xlarge', volume_size_in_gb=20, max_runtime_in_seconds=3600, ) my_default_monitor.suggest_baseline( baseline_dataset=baseline_data_uri+'/training-dataset-with-header.csv', dataset_format=DatasetFormat.csv(header=True), output_s3_uri=baseline_results_uri, wait=True ) ``` **Note** Si vous indiquez les feature/column noms dans le jeu de données d'apprentissage en tant que première ligne et que vous définissez l'`header=True`option comme indiqué dans l'exemple de code précédent, SageMaker AI utilise le nom de la fonctionnalité dans le fichier de contraintes et de statistiques. Les statistiques de référence du jeu de données sont contenues dans le fichier statistics.json et 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`. Fichiers de sortie pour les statistiques et les contraintes du jeu de données tabulaires | Nom de fichier | Description | | --- | --- | | statistics.json | Ce fichier doit comporter des statistiques en colonnes pour chaque fonction du jeu de données analysé. Pour plus d’informations sur le schéma de ce fichier, consultez [Schéma des statistiques (fichier statistics.json)](model-monitor-byoc-statistics.md). | | constraints.json | Dans ce fichier, les contraintes sur les fonctions doivent être observées. Pour plus d’informations sur le schéma de ce fichier, consultez [Schéma des contraintes (fichier constraints.json)](model-monitor-byoc-constraints.md). | Le [SDK Amazon SageMaker Python](https://sagemaker.readthedocs.io/en/stable) fournit des fonctions pratiques décrites pour générer les statistiques et les contraintes de base. Si vous voulez toutefois appeler la tâche de traitement directement à cette fin, vous devez définir le mappage `Environment` comme dans l’exemple ci-après : ``` "Environment": { "dataset_format": "{\"csv\”: { \”header\”: true}", "dataset_source": "/opt/ml/processing/sm_input", "output_path": "/opt/ml/processing/sm_output", "publish_cloudwatch_metrics": "Disabled", } ``` # Planification des tâches de surveillance de la qualité des données Après avoir créé votre base de référence, vous pouvez appeler la méthode `create_monitoring_schedule()` de votre instance de classe `DefaultModelMonitor` pour planifier une surveillance horaire de la qualité des données. Les sections suivantes expliquent comment créer une surveillance de la qualité des données 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. ## Surveillance de la qualité des données pour les modèles déployés sur des points de terminaison en temps réel Pour planifier une surveillance de la qualité des données pour un point de terminaison en temps réel, transmettez votre instance `EndpointInput` à l'argument `endpoint_input` de votre instance `DefaultModelMonitor`, comme indiqué dans l'exemple de code suivant : ``` from sagemaker.model_monitor import CronExpressionGenerator data_quality_model_monitor = DefaultModelMonitor( role=sagemaker.get_execution_role(), ... ) schedule = data_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=data_quality_model_monitor.baseline_statistics(), constraints=data_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", ) ) ``` ## Surveillance de la qualité des données pour les tâches de transformation par lots Pour planifier une surveillance de la qualité des données pour une tâche de transformation par lots, transmettez votre instance `BatchTransformInput` à l'argument `batch_transform_input` de votre instance `DefaultModelMonitor`, comme indiqué dans l'exemple de code suivant : ``` from sagemaker.model_monitor import CronExpressionGenerator data_quality_model_monitor = DefaultModelMonitor( role=sagemaker.get_execution_role(), ... ) schedule = data_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), ), output_s3_uri=s3_report_path, statistics= statistics_path, constraints = constraints_path, schedule_cron_expression=CronExpressionGenerator.hourly(), enable_cloudwatch_metrics=True, ) ``` # Schéma des statistiques (fichier statistics.json) Le conteneur prédéfini Amazon SageMaker Model Monitor calcule selon les statistiques. column/feature Les statistiques sont calculées pour l'ensemble de données de référence, ainsi que pour le jeu de données en cours d'analyse. ``` { "version": 0, # dataset level stats "dataset": { "item_count": number }, # feature level stats "features": [ { "name": "feature-name", "inferred_type": "Fractional" | "Integral", "numerical_statistics": { "common": { "num_present": number, "num_missing": number }, "mean": number, "sum": number, "std_dev": number, "min": number, "max": number, "distribution": { "kll": { "buckets": [ { "lower_bound": number, "upper_bound": number, "count": number } ], "sketch": { "parameters": { "c": number, "k": number }, "data": [ [ num, num, num, num ], [ num, num ][ num, num ] ] }#sketch }#KLL }#distribution }#num_stats }, { "name": "feature-name", "inferred_type": "String", "string_statistics": { "common": { "num_present": number, "num_missing": number }, "distinct_count": number, "distribution": { "categorical": { "buckets": [ { "value": "string", "count": number } ] } } }, #provision for custom stats } ] } ``` Notez ce qui suit : + Les conteneurs préconçus calculent le [croquis KLL](https://datasketches.apache.org/docs/KLL/KLLSketch.html), qui est un croquis de quantiles compact. + Par défaut, nous matérialisons la distribution en dix compartiments. Actuellement, ceci n’est pas configurable. # CloudWatch Métriques Vous pouvez utiliser le conteneur Amazon SageMaker Model Monitor intégré pour les CloudWatch métriques. Lorsque l'`emit_metrics`option se trouve `Enabled` dans le fichier de contraintes de référence, SageMaker AI émet ces métriques pour chaque feature/column observation dans l'ensemble de données dans l'espace de noms suivant : + Espace de noms `For real-time endpoints: /aws/sagemaker/Endpoints/data-metric` avec des dimensions `EndpointName` et `ScheduleName`. + Espace de noms `For batch transform jobs: /aws/sagemaker/ModelMonitoring/data-metric` avec une dimension `MonitoringSchedule`. Pour les champs numériques, le conteneur intégré émet les CloudWatch métriques suivantes : + Métrique : Max → requête pour `MetricName: feature_data_{feature_name}, Stat: Max` + Métrique : Min → requête pour `MetricName: feature_data_{feature_name}, Stat: Min` + Métrique : Sum → requête pour `MetricName: feature_data_{feature_name}, Stat: Sum` + Métrique : SampleCount → requête pour `MetricName: feature_data_{feature_name}, Stat: SampleCount` + Métrique : Average → requête pour `MetricName: feature_data_{feature_name}, Stat: Average` Pour les champs numériques et les champs de chaîne, le conteneur intégré émet les CloudWatch métriques suivantes : + Métrique : Exhaustivité → requête pour `MetricName: feature_non_null_{feature_name}, Stat: Sum` + Métrique : Dérive de la référence → requête pour `MetricName: feature_baseline_drift_{feature_name}, Stat: Sum` # Schéma des violations (fichier constraint\$1violations.json) Le fichier de violations est généré en tant que sortie d'un attribut `MonitoringExecution`, qui répertorie les résultats de l'évaluation des contraintes (spécifiées dans le fichier constraints.json) par rapport au jeu de données actuel qui a été analysé. Le conteneur SageMaker prédéfini Amazon Model Monitor fournit les contrôles de violation suivants. ``` { "violations": [{ "feature_name" : "string", "constraint_check_type" : "data_type_check", | "completeness_check", | "baseline_drift_check", | "missing_column_check", | "extra_column_check", | "categorical_values_check" "description" : "string" }] } ``` Types de violations surveillées | Type de vérification des violations | Description | | --- | --- | | data\$1type\$1check | Si les données de l'exécution en cours ne sont pas du même type que celles du jeu de données de référence, cette violation est signalée. Au cours de l’étape de la référence, les contraintes générées suggèrent le type de données déduit pour chaque colonne. Le paramètre `monitoring_config.datatype_check_threshold` peut être réglé pour ajuster le seuil lorsqu’il est signalé comme une violation. | | completeness\$1check | Si l’exhaustivité (totalité des éléments non nuls) observée dans l’exécution en cours dépasse le seuil spécifié dans le seuil d’exhaustivité spécifié par caractéristique, cette violation est signalée. Au cours de l’étape de référence, les contraintes générées suggèrent une valeur d’exhaustivité. | | baseline\$1drift\$1check | Si la distance de distribution calculée entre les jeux de données actif et les ensembles de données de référence est supérieure au seuil spécifié dans `monitoring_config.comparison_threshold`, cette violation est signalée. | | missing\$1column\$1check | Si le nombre de colonnes du jeu de données actif est inférieur au nombre de colonnes du jeu de données de référence, cette violation est signalée. | | extra\$1column\$1check | Si le nombre de colonnes du jeu de données actif est supérieur au nombre de colonnes de la référence, cette violation est signalée. | | categorical\$1values\$1check | S'il y a plus de valeurs inconnues dans le jeu de données actif que dans le jeu de données de référence, cette violation est signalée. Cette valeur est dictée par le seuil dans `monitoring_config.domain_content_threshold`. | # 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*. # Dérive de biais pour les modèles en production La surveillance des biais d'Amazon SageMaker Clarify aide les data scientists et les ingénieurs du ML à surveiller régulièrement les prédictions pour détecter les biais. Au fur et à mesure que le modèle est surveillé, les clients peuvent consulter des rapports et des graphiques exportables détaillant le biais dans SageMaker Studio et configurer des alertes dans Amazon CloudWatch pour recevoir des notifications en cas de détection d'un biais supérieur à un certain seuil. Un biais peut être introduit ou exacerbé dans les modèles ML déployés lorsque les données d'entraînement diffèrent des données vues par le modèle pendant le déploiement (c'est-à-dire les données actives). Ces types de changements dans la distribution des données actives peuvent être temporaires (dans le cas d'événements réels de courte durée, par exemple) ou permanents. Dans les deux cas, il peut être important de détecter ces changements. Par exemple, les sorties d’un modèle de prédiction des prix des maisons peuvent devenir biaisées si les taux hypothécaires utilisés pour entraîner le modèle ne correspondent pas aux taux hypothécaires réels du moment. Grâce aux fonctionnalités de détection des biais de Model Monitor, lorsque l' SageMaker IA détecte un biais au-delà d'un certain seuil, elle génère automatiquement des métriques que vous pouvez consulter dans SageMaker Studio et via les CloudWatch alertes Amazon. En général, mesurer le biais uniquement pendant la train-and-deploy phase peut ne pas être suffisant. Il est possible qu'une fois le modèle déployé, la distribution des données vue par le modèle déployé (c'est-à-dire les données actives) diffère de celle du jeu de données d'entraînement. Avec le temps, ce changement peut introduire un biais dans un modèle. Le changement dans la distribution des données actives peut être temporaire (dans le cas d'un événement de courte durée, la période des fêtes par exemple) ou permanent. Dans les deux cas, il peut être important de détecter ces changements et de prendre éventuellement des mesures pour réduire le biais. Pour détecter ces changements, SageMaker Clarify fournit des fonctionnalités permettant de surveiller en permanence les mesures de biais d'un modèle déployé et de déclencher des alertes automatisées si les mesures dépassent un seuil. Considérons par exemple la métrique de biais DPPL. Spécifiez une plage autorisée de valeurs A = (amin​,amax​), par exemple un intervalle de (-0,1, 0,1), à laquelle DPPL doit appartenir pendant le déploiement. Tout écart par rapport à cette plage doit déclencher une alerte de *biais détecté*. Avec SageMaker Clarify, vous pouvez effectuer ces contrôles à intervalles réguliers. Par exemple, vous pouvez définir la fréquence des vérifications sur 2 jours. Cela signifie que SageMaker Clarify calcule la métrique DPPL sur les données collectées pendant une période de 2 jours. Dans cet exemple, Dwin désigne les données traitées par le modèle sur la dernière fenêtre de 2 jours. Une alerte est émise si la valeur DPPL bwin​ calculée sur Dwin​ est extérieure à une plage autorisée A. Cette approche pour vérifier si bwin se situe en dehors de A peut être bruyante. Dwin​ peut comprendre très peu d'échantillons et ne pas représenter précisément la distribution des données actives. Le faible nombre d'échantillons signifie que la valeur d'estimation du biais bwin​ calculée sur Dwin​ peut ne pas être très robuste. En fait, l'observation de valeurs très élevées (ou très faibles) de bwin peut être le simple fruit du hasard. Pour s'assurer que les conclusions tirées des données observées D win sont statistiquement significatives, SageMaker Clarify utilise des intervalles de confiance. Plus précisément, il utilise la méthode de l'intervalle Bootstrap normal pour construire un intervalle C= (cmin, cmax) de telle sorte que SageMaker Clarify soit sûr que la vraie valeur de biais calculée sur l'ensemble des données en direct est contenue dans C avec une probabilité élevée. Désormais, si l'intervalle de confiance C chevauche la plage autorisée A, SageMaker Clarify l'interprète comme « il est probable que la valeur métrique de biais de la distribution des données en temps réel se situe dans la plage autorisée ». Si C et A sont disjoints, SageMaker Clarify est sûr que la métrique de biais ne se trouve pas dans A et déclenche une alerte. ## Exemples de blocs-notes Model Monitor Amazon SageMaker Clarify fournit l'exemple de carnet suivant qui montre comment capturer des données d'inférence pour un point de terminaison en temps réel, créer une base de référence pour surveiller l'évolution des biais et inspecter les résultats : + [Surveillance de la dérive des biais et de la dérive d'attribution des fonctionnalités Amazon SageMaker Clarify](https://sagemaker-examples.readthedocs.io/en/latest/sagemaker_model_monitor/fairness_and_explainability/SageMaker-Model-Monitor-Fairness-and-Explainability.html) — Utilisez Amazon SageMaker Model Monitor pour surveiller la dérive des biais et la dérive de l'attribution des fonctionnalités au fil du temps. Il a été vérifié que ce bloc-notes fonctionne uniquement dans Amazon SageMaker Studio. Si vous avez besoin d'instructions pour ouvrir un bloc-notes dans Amazon SageMaker Studio, consultez[Création ou ouverture d'un bloc-notes Amazon SageMaker Studio Classic](notebooks-create-open.md). Si vous êtes invité à choisir un noyau, choisissez **Python 3 (Science des données)**. Les rubriques suivantes contiennent les éléments principaux des deux dernières étapes, ainsi que des exemples de code tirés de l'exemple de bloc-notes. **Topics** + [Exemples de blocs-notes Model Monitor](#clarify-model-monitor-sample-notebooks-bias-drift) + [Créer une référence de dérive de biais](clarify-model-monitor-bias-drift-baseline.md) + [Violations de dérive de biais](clarify-model-monitor-bias-drift-violations.md) + [Paramètres pour surveiller la dérive de biais](clarify-config-json-monitor-bias-parameters.md) + [Planification de tâches de surveillance de dérive de biais](clarify-model-monitor-bias-drift-schedule.md) + [Inspecter les rapports pour détecter la dérive de biais des données](clarify-model-monitor-bias-drift-report.md) + [CloudWatch Métriques pour l'analyse de la dérive des biais](clarify-model-monitor-bias-drift-cw.md) # Créer une référence de dérive de biais Après avoir configuré votre application pour capturer des données d’inférence en temps réel ou de transformation par lots, la première tâche de surveillance de la dérive de biais consiste à créer une référence. Cela implique de configurer les entrées de données, les groupes sensibles, la capture des prédictions, ainsi que le modèle et ses métriques de biais de post-entraînement. Ensuite, vous devez démarrer la tâche de baselining. Le moniteur de biais de modèle peut détecter régulièrement la dérive de biais de modèles ML. Comme pour les autres types de surveillance, la procédure standard de création d’un moniteur de biais de modèle consiste d’abord à établir un baselining, puis un programme de surveillance. ``` model_bias_monitor = ModelBiasMonitor( role=role, sagemaker_session=sagemaker_session, max_runtime_in_seconds=1800, ) ``` `DataConfig` stocke des informations sur le jeu de données à analyser (par exemple, le fichier de jeu de données), son format (CSV ou JSON Lines), les en-têtes (le cas échéant) et l'étiquette. ``` model_bias_baselining_job_result_uri = f"{baseline_results_uri}/model_bias" model_bias_data_config = DataConfig( s3_data_input_path=validation_dataset, s3_output_path=model_bias_baselining_job_result_uri, label=label_header, headers=all_headers, dataset_type=dataset_type, ) ``` `BiasConfig` est la configuration des groupes sensibles dans le jeu de données. Généralement, le biais est mesuré en calculant une métrique et en la comparant entre les groupes. Le groupe d’intérêts est appelé la *facette*. Pour le biais de post-entraînement, vous devez également prendre en compte l'étiquette positive. ``` model_bias_config = BiasConfig( label_values_or_threshold=[1], facet_name="Account Length", facet_values_or_threshold=[100], ) ``` `ModelPredictedLabelConfig` spécifie la façon d’extraire une étiquette prédite à partir de la sortie du modèle. Dans cet exemple, nous avons choisi un seuil de 0,8 pour anticiper le renouvellement fréquent des clients. Pour les sorties plus complexes, il existe quelques options supplémentaires, comme « label » pour l'index, le nom ou JMESPath pour localiser l'étiquette prévue dans la charge utile de réponse du point de terminaison. ``` model_predicted_label_config = ModelPredictedLabelConfig( probability_threshold=0.8, ) ``` `ModelConfig` est la configuration associée au modèle devant être utilisé pour l’inférence. Afin de calculer les métriques de biais de post-entraînement, le calcul doit obtenir des inférences pour le nom de modèle fourni. Pour ce faire, la tâche de traitement utilise le modèle pour créer un point de terminaison éphémère (également connu comme *shadow endpoint (point de terminaison fantôme)*. Une fois les calculs terminés, la tâche de traitement supprime le point de terminaison fantôme. Cette configuration est également utilisée par le moniteur d'explicabilité. ``` model_config = ModelConfig( model_name=model_name, instance_count=endpoint_instance_count, instance_type=endpoint_instance_type, content_type=dataset_type, accept_type=dataset_type, ) ``` La tâche de baselining proprement dite peut maintenant commencer. ``` model_bias_monitor.suggest_baseline( model_config=model_config, data_config=model_bias_data_config, bias_config=model_bias_config, model_predicted_label_config=model_predicted_label_config, ) print(f"ModelBiasMonitor baselining job: {model_bias_monitor.latest_baselining_job_name}") ``` Le moniteur programmé prend automatiquement le nom de la tâche de baselining et l’attend avant le début de la surveillance. # Violations de dérive de biais Les tâches de dérive de biais évaluent les contraintes de base fournies par la [configuration de base](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_CreateModelBiasJobDefinition.html#sagemaker-CreateModelBiasJobDefinition-request-ModelBiasBaselineConfig) par rapport aux résultats d'analyse du code `MonitoringExecution` actuel. Si des violations sont détectées, la tâche les répertorie dans le fichier *contraint\$1violations.json* à l'emplacement de la sortie d'exécution, et affecte le statut d'exécution [Interprétation des résultats](model-monitor-interpreting-results.md). Voici le schéma du fichier de violations de dérive de biais. + `facet` – Nom de la facette, fourni par la facette de configuration de l'analyse des tâches de surveillance `name_or_index`. + `facet_value` – Valeur de la facette, fournie par la facette de configuration de l'analyse des tâches de surveillance `value_or_threshold`. + `metric_name` – Nom abrégé de la métrique de biais. Par exemple, « CI » pour déséquilibre de classe (class imbalance). Consultez [Indicateurs de biais de pré-entraînement](clarify-measure-data-bias.md) pour obtenir les noms abrégés de toutes les métriques de biais de pré-entraînement et [Indicateurs de biais de post-entraînement dans les données et les modèles](clarify-measure-post-training-bias.md) pour les noms abrégés de toutes les métriques de biais de post-entraînement. + `constraint_check_type` : type de violation surveillée. Actuellement, seul `bias_drift_check` est pris en charge. + `description` : message descriptif visant à expliquer la violation. ``` { "version": "1.0", "violations": [{ "facet": "string", "facet_value": "string", "metric_name": "string", "constraint_check_type": "string", "description": "string" }] } ``` Une métrique de biais est utilisée pour mesurer le niveau d'égalité dans une distribution. Une valeur proche de zéro indique que la distribution est plus équilibrée. Si la valeur d'une métrique de biais dans le fichier de résultats d'analyse des tâches (analysis.json) est pire que sa valeur correspondante dans le fichier de contraintes de référence, une violation est journalisée. Par exemple, si la contrainte de référence pour la métrique de biais DPPL est `0.2` et que le résultat de l'analyse est `0.1`, aucune violation n'est journalisée, car `0.1` est plus proche de `0` que `0.2`. Toutefois, si le résultat de l’analyse est `-0.3`, une violation est journalisée, car la valeur est plus éloignée de `0` que la contrainte de référence de `0.2`. ``` { "version": "1.0", "violations": [{ "facet": "Age", "facet_value": "40", "metric_name": "CI", "constraint_check_type": "bias_drift_check", "description": "Value 0.0751544567666083 does not meet the constraint requirement" }, { "facet": "Age", "facet_value": "40", "metric_name": "DPPL", "constraint_check_type": "bias_drift_check", "description": "Value -0.0791244970125596 does not meet the constraint requirement" }] } ``` # Paramètres pour surveiller la dérive de biais La surveillance des biais d'Amazon SageMaker Clarify réutilise un sous-ensemble des paramètres utilisés dans la configuration d'analyse de[Fichiers de configuration d’analyse](clarify-processing-job-configure-analysis.md). Après avoir décrit les paramètres de configuration, cette rubrique fournit des exemples de fichiers JSON. Ces fichiers sont utilisés pour configurer les jeux de données CSV et JSON Lines afin de surveiller leur dérive de biais lorsque des modèles Machine Learning sont en production. Les paramètres suivants doivent être fournis dans un fichier JSON. Le chemin d'accès au fichier JSON doit être fourni dans le paramètre `ConfigUri` de l'API [https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_ModelBiasAppSpecification](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_ModelBiasAppSpecification). + `"version"` : (facultatif) version de schéma du fichier de configuration. Si elle n’est pas fournie, la dernière version prise en charge est utilisée. + `"headers"` – (Facultatif) Liste des noms de colonnes dans le jeu de données. Si `dataset_type` est `"application/jsonlines"` et que `"label"` est spécifié, le dernier en-tête devient l'en-tête de la colonne d'étiquettes. + `"label"` – (Facultatif) Attribut cible du modèle à utiliser pour les *métriques de biais*. Spécifié soit sous forme de nom de colonne, soit d'index (si le format de jeu de données est CSV), soit sous forme de JMESPath (si le format de jeu de données est JSON Lines). + `"label_values_or_threshold"` : (facultatif) liste des valeurs d’étiquette ou du seuil. Indique le résultat positif utilisé pour les métriques de biais. + `"facet"` – (Facultatif) Liste des fonctions qui sont des attributs sensibles, appelées facettes. Les facettes sont utilisées pour les *métriques de biais* sous forme de paires, et comprennent les éléments suivants : + `"name_or_index"` – Nom ou index de la colonne facette. + `"value_or_threshold"` – (Facultatif) Liste des valeurs ou des seuils que la colonne de facettes peut prendre. Indique le groupe sensible, tel que le groupe par rapport auquel le biais est mesuré. Si elles ne sont pas fournies, les métriques de biais sont calculées comme un groupe pour chaque valeur unique (plutôt que toutes les valeurs). Si la colonne facette est numérique, cette valeur de seuil sert de limite inférieure pour sélectionner le groupe sensible. + `"group_variable"` – (Facultatif) Nom de colonne ou index pour indiquer la variable de groupe à utiliser pour la *métrique de biais* *Disparité démographique conditionnelle.* Les autres paramètres doivent être fournis dans `EndpointInput` (pour les points de terminaison en temps réel) ou `BatchTransformInput` (pour les tâches de transformation par lots) de l'API [https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_ModelBiasJobInput](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_ModelBiasJobInput). + `FeaturesAttribute` : ce paramètre est requis si le format des données d’entrée du point de terminaison est `"application/jsonlines"`. Il est JMESPath utilisé pour localiser les colonnes d'entités si le format du jeu de données est JSON Lines. + `InferenceAttribute`— Indice ou JMESPath emplacement dans la sortie du modèle pour l'attribut cible à utiliser pour surveiller le biais à l'aide de métriques de biais. S’il n’est pas fourni dans le cas `accept_type` CSV, il est supposé que la sortie du modèle est une valeur numérique unique correspondant à un score ou à une probabilité. + `ProbabilityAttribute`— Indice ou JMESPath emplacement dans la sortie du modèle pour les probabilités. Si la sortie du modèle est JSON Lines avec une liste d’étiquettes et de probabilités, par exemple, l’étiquette qui correspond à la probabilité maximale est alors sélectionnée pour les calculs de biais. + `ProbabilityThresholdAttribute` – (Facultatif) Valeur float indiquant le seuil de sélection de l'étiquette binaire dans le cas d'une classification binaire. La valeur par défaut est 0,5. ## Exemples de fichiers de configuration JSON pour les jeux de données CSV et JSON Lines Voici des exemples des fichiers JSON utilisés pour configurer les jeux de données CSV et JSON Lines afin de les surveiller pour détecter une dérive de biais. **Topics** + [Jeux de données CSV](#clarify-config-json-monitor-bias-parameters-example-csv) + [Jeux de données JSON Lines](#clarify-config-json-monitor-bias-parameters-example-jsonlines) ### Jeux de données CSV Considérez un jeu de données comportant quatre colonnes de caractéristiques et une colonne d'étiquettes, où la première caractéristique et l'étiquette sont binaires, comme dans l'exemple suivant. ``` 0, 0.5814568701544718, 0.6651538910132964, 0.3138080342665499, 0 1, 0.6711642728531724, 0.7466687034026017, 0.1215477472819713, 1 0, 0.0453256543003371, 0.6377430803264152, 0.3558625219713576, 1 1, 0.4785191813363956, 0.0265841045263860, 0.0376935084990697, 1 ``` Supposons que la sortie du modèle comporte deux colonnes, la première correspondant à l'étiquette prédite et la seconde à la probabilité, comme dans l'exemple suivant. ``` 1, 0.5385257417814224 ``` Le fichier de configuration JSON suivant montre comment ce jeu de données CSV peut être configuré. ``` { "headers": [ "feature_0", "feature_1", "feature_2", "feature_3", "target" ], "label": "target", "label_values_or_threshold": [1], "facet": [{ "name_or_index": "feature_1", "value_or_threshold": [1] }] } ``` L'étiquette prédite est sélectionnée par le paramètre `"InferenceAttribute"`. La numérotation basée sur zéro est utilisée, donc 0 indique la première colonne de la sortie du modèle. ``` "EndpointInput": { ... "InferenceAttribute": 0 ... } ``` Vous pouvez également utiliser des paramètres différents pour convertir les valeurs de probabilité en étiquettes prédites binaires. La numérotation basée sur zéro est utilisée : 1 indique la deuxième colonne ; une valeur de `ProbabilityThresholdAttribute` de 0,6 indique qu'une probabilité supérieure à 0,6 prédit que l'étiquette binaire est 1. ``` "EndpointInput": { ... "ProbabilityAttribute": 1, "ProbabilityThresholdAttribute": 0.6 ... } ``` ### Jeux de données JSON Lines Considérez un jeu de données comportant quatre colonnes de caractéristiques et une colonne d'étiquettes, où la première caractéristique et l'étiquette sont binaires, comme dans l'exemple suivant. ``` {"features":[0, 0.5814568701544718, 0.6651538910132964, 0.3138080342665499], "label":0} {"features":[1, 0.6711642728531724, 0.7466687034026017, 0.1215477472819713], "label":1} {"features":[0, 0.0453256543003371, 0.6377430803264152, 0.3558625219713576], "label":1} {"features":[1, 0.4785191813363956, 0.0265841045263860, 0.0376935084990697], "label":1} ``` Supposons que la sortie du modèle comporte deux colonnes, la première étant une étiquette prédite et la seconde une probabilité. ``` {"predicted_label":1, "probability":0.5385257417814224} ``` Le fichier de configuration JSON suivant montre comment ce jeu de données JSON Lines peut être configuré. ``` { "headers": [ "feature_0", "feature_1", "feature_2", "feature_3", "target" ], "label": "label", "label_values_or_threshold": [1], "facet": [{ "name_or_index": "feature_1", "value_or_threshold": [1] }] } ``` Ensuite, la valeur de paramètre `"features"` dans `EndpointInput` (pour les points de terminaison en temps réel) ou `BatchTransformInput` (pour les tâches de transformation par lots) est utilisée pour localiser les caractéristiques dans le jeu de données, et la valeur de paramètre `"predicted_label"` sélectionne l'étiquette prédite à partir de la sortie du modèle. ``` "EndpointInput": { ... "FeaturesAttribute": "features", "InferenceAttribute": "predicted_label" ... } ``` Vous pouvez également convertir les valeurs de probabilité en étiquettes binaires prédites à l’aide de la valeur de paramètre `ProbabilityThresholdAttribute`. Une valeur de 0,6, par exemple, indique qu'une probabilité supérieure à 0,6 prédit que l'étiquette binaire est 1. ``` "EndpointInput": { ... "FeaturesAttribute": "features", "ProbabilityAttribute": "probability", "ProbabilityThresholdAttribute": 0.6 ... } ``` # Planification de tâches de surveillance de dérive de biais Après avoir créé votre référence, vous pouvez appeler la méthode `create_monitoring_schedule()` de votre instance de classe `ModelBiasModelMonitor` pour planifier une surveillance horaire de la dérive de biais. Les sections suivantes expliquent comment créer une surveillance de la dérive de biais 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. Pour plus d'informations sur comment créer des décalages temporels, consultez [Décalages de Model Monitor](model-monitor-model-quality-schedule.md#model-monitor-model-quality-schedule-offsets). Si vous avez envoyé une tâche de baselining, le moniteur récupère automatiquement la configuration d’analyse à partir de la tâche de baselining. Si vous ignorez l’étape de baselining ou si la nature du jeu de données de capture est différente de celle du jeu de données d’entraînement, vous devez fournir la configuration d’analyse. ## Surveillance de la dérive de biais pour les modèles déployés sur des points de terminaison en temps réel Pour planifier une surveillance de la dérive de biais pour un point de terminaison en temps réel, transmettez votre instance `EndpointInput` à l'argument `endpoint_input` de votre instance `ModelBiasModelMonitor`, comme indiqué dans l'exemple de code suivant : ``` from sagemaker.model_monitor import CronExpressionGenerator model_bias_monitor = ModelBiasModelMonitor( role=sagemaker.get_execution_role(), ... ) model_bias_analysis_config = None if not model_bias_monitor.latest_baselining_job: model_bias_analysis_config = BiasAnalysisConfig( model_bias_config, headers=all_headers, label=label_header, ) model_bias_monitor.create_monitoring_schedule( monitor_schedule_name=schedule_name, post_analytics_processor_script=s3_code_postprocessor_uri, output_s3_uri=s3_report_path, statistics=model_bias_monitor.baseline_statistics(), constraints=model_bias_monitor.suggested_constraints(), schedule_cron_expression=CronExpressionGenerator.hourly(), enable_cloudwatch_metrics=True, analysis_config=model_bias_analysis_config, endpoint_input=EndpointInput( endpoint_name=endpoint_name, destination="/opt/ml/processing/input/endpoint", start_time_offset="-PT1H", end_time_offset="-PT0H", probability_threshold_attribute=0.8, ), ) ``` ## Surveillance de la dérive des biais pour les tâches de transformation par lots Pour planifier une surveillance de la dérive de biais pour une tâche de transformation par lots, transmettez votre instance `BatchTransformInput` à l'argument `batch_transform_input` de votre instance `ModelBiasModelMonitor`, comme indiqué dans l'exemple de code suivant : ``` from sagemaker.model_monitor import CronExpressionGenerator model_bias_monitor = ModelBiasModelMonitor( role=sagemaker.get_execution_role(), ... ) model_bias_analysis_config = None if not model_bias_monitor.latest_baselining_job: model_bias_analysis_config = BiasAnalysisConfig( model_bias_config, headers=all_headers, label=label_header, ) schedule = model_bias_monitor.create_monitoring_schedule( monitor_schedule_name=schedule_name, post_analytics_processor_script=s3_code_postprocessor_uri, output_s3_uri=s3_report_path, statistics=model_bias_monitor.baseline_statistics(), constraints=model_bias_monitor.suggested_constraints(), schedule_cron_expression=CronExpressionGenerator.hourly(), enable_cloudwatch_metrics=True, analysis_config=model_bias_analysis_config, batch_transform_input=BatchTransformInput( destination="opt/ml/processing/input", data_captured_destination_s3_uri=s3_capture_path, start_time_offset="-PT1H", end_time_offset="-PT0H", probability_threshold_attribute=0.8 ), ) ``` # Inspecter les rapports pour détecter la dérive de biais des données Si vous n'êtes pas en mesure de consulter les résultats de la surveillance dans les rapports générés dans SageMaker Studio, vous pouvez les imprimer comme suit : ``` schedule_desc = model_bias_monitor.describe_schedule() execution_summary = schedule_desc.get("LastMonitoringExecutionSummary") if execution_summary and execution_summary["MonitoringExecutionStatus"] in ["Completed", "CompletedWithViolations"]: last_model_bias_monitor_execution = model_bias_monitor.list_executions()[-1] last_model_bias_monitor_execution_report_uri = last_model_bias_monitor_execution.output.destination print(f'Report URI: {last_model_bias_monitor_execution_report_uri}') last_model_bias_monitor_execution_report_files = sorted(S3Downloader.list(last_model_bias_monitor_execution_report_uri)) print("Found Report Files:") print("\n ".join(last_model_bias_monitor_execution_report_files)) else: last_model_bias_monitor_execution = None print("====STOP==== \n No completed executions to inspect further. Please wait till an execution completes or investigate previously reported failures.") ``` En cas de violations par rapport à la référence, celles-ci sont répertoriées ici : ``` if last_model_bias_monitor_execution: model_bias_violations = last_model_bias_monitor_execution.constraint_violations() if model_bias_violations: print(model_bias_violations.body_dict) ``` Si votre modèle est déployé sur un point de terminaison en temps réel, vous pouvez voir des visualisations dans SageMaker AI Studio des résultats d'analyse et des CloudWatch mesures en choisissant l'onglet **Points de terminaison**, puis en double-cliquant sur le point de terminaison. # CloudWatch Métriques pour l'analyse de la dérive des biais Ce guide présente CloudWatch les métriques et leurs propriétés que vous pouvez utiliser pour l'analyse de la dérive des biais dans SageMaker Clarify. Les tâches de surveillance de la dérive des biais calculent à la fois les [mesures de biais avant](https://docs.aws.amazon.com/sagemaker/latest/dg/clarify-measure-data-bias.html) l'[entraînement et les mesures de biais après](https://docs.aws.amazon.com/sagemaker/latest/dg/clarify-measure-post-training-bias.html) l'entraînement, et les publient dans l'espace de noms suivant : CloudWatch + Pour les points de terminaison en temps réel : `aws/sagemaker/Endpoints/bias-metrics` + Pour les tâches de transformation par lots : `aws/sagemaker/ModelMonitoring/bias-metrics` Le nom de la CloudWatch métrique ajoute le nom abrégé de la métrique à`bias_metric`. Par exemple,`bias_metric_CI` est la métrique de biais pour le déséquilibre de classe (IC). **Note** `+/- infinity` est publié en tant que nombre à virgule flottante `+/- 2.348543e108`, et les erreurs incluant des valeurs nulles ne sont pas publiées. Chaque métrique comporte les propriétés suivantes : + `Endpoint` : le nom du point de terminaison surveillé, le cas échéant. + `MonitoringSchedule` : le nom du programme de surveillance. + `BiasStage` : le nom de l'étape de la tâche de surveillance de dérive de biais. Choisissez `Pre-training` ou `Post-Training`. + `Label` : le nom de la fonctionnalité cible, fourni par la configuration de l'analyse des tâches de surveillance `label`. + `LabelValue` : la valeur de la fonctionnalité cible, fournie par la configuration de l'analyse des tâches de surveillance `label_values_or_threshold`. + `Facet` : le nom de la fonctionnalité cible, fourni par la facette de la configuration de l'analyse des tâches de surveillance `name_of_index`. + `FacetValue` : la valeur de la fonctionnalité cible, fournie par la facette de la configuration de l'analyse des tâches de surveillance `nvalue_or_threshold`. Pour empêcher les tâches de surveillance de publier des métriques, définissez `publish_cloudwatch_metrics` à `Disabled` dans la `Environment`carte de la définition du [modèle de tâche de bias](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_CreateModelBiasJobDefinition.html). # Dérive d’attribution de caractéristiques pour les modèles en production Une dérive dans la distribution de données actives pour les modèles en production peut entraîner une dérive correspondante dans les valeurs d’attribution de caractéristiques, comme elle pourrait provoquer une dérive de biais lors de la surveillance des indicateurs de biais. La surveillance de l'attribution des fonctionnalités Amazon SageMaker Clarify aide les spécialistes des données et les ingénieurs du ML à surveiller régulièrement les prévisions relatives à la dérive de l'attribution des fonctionnalités. Lorsque le modèle est surveillé, les clients peuvent consulter des rapports et des graphiques exportables détaillant les attributions des fonctionnalités dans SageMaker Studio et configurer des alertes sur Amazon CloudWatch pour recevoir des notifications s'il est détecté que les valeurs d'attribution dépassent un certain seuil. Pour illustrer cela par une situation particulière, prenons le cas des admissions à l'université. Supposons que nous observons les valeurs d'attribution de fonctions (agrégées) suivantes dans les données d'entraînement et les données actives : Scénario hypothétique d'admission à l'université | Fonctionnalité | Attribution des données d'entraînement | Attribution des données actives | | --- | --- | --- | | Score SAT | 0,70 | 0.10 | | GPA | 0.50 | 0.20 | | Classement de classe | 0,05 | 0,70 | Le passage des données d'entraînement aux données actives semble significatif. Le classement des fonctions est complètement inversé. À l'instar de la dérive de biais, les dérives d'attribution de fonctions peuvent être causées par un changement dans la distribution des données actives et justifient un examen plus approfondi du comportement du modèle sur les données actives. Là encore, la première étape de ces scénarios consiste à signaler par une alarme qu'une dérive s'est produite. Nous pouvons détecter la dérive en comparant la façon dont le classement des fonctions individuelles est passé des données d'entraînement aux données actives. En plus de tenir compte des changements dans l'ordre de classement, nous devons également tenir compte du score d'attribution brut des fonctions. Par exemple, si deux fonctions entrent dans le classement par le même nombre de positions passant des données d'entraînement aux données actives, nous devons tenir compte de la fonction dont le score d'attribution était le plus élevé dans les données d'entraînement. En nous basant sur ces propriétés, nous utilisons le score NDCG (Normalized Discount Cumulative Gain) pour comparer le classement des attributions de fonctions des données d'entraînement et des données actives. Plus précisément, supposons le scénario suivant : + *F=[f1,...,fm]* est la liste des fonctions triées en fonction de leurs scores d'attribution dans les données d'entraînement, *m* représentant le nombre total de fonctions. Par exemple, dans notre cas, *F*=[Score SAT, GPA, Classement de classe]. + *a(f)* est une fonction qui renvoie le score d'attribution de fonction sur les données d'entraînement dans le cas d'une fonction *f*. Par exemple, *a*(Score SAT) = 0.70. + *F′=[f′1,...,f′m]* est la liste des fonctions triées en fonction de leurs scores d'attribution dans les données actives. Par exemple, *F*′=[Classement de classe, GPA, Score SAT]. Nous pouvons ensuite calculer le NDCG comme suit :         NDCG = DCG/IDCG avec + DCG = ∑1m*a*(*f'i*)/log2​(*i*\$11) + iDCG = ∑1m*a*(*fi*)/log2​(*i*\$11) La quantité DCG mesure si les fonctions ayant une attribution élevée dans les données d'entraînement occupent un rang également plus élevé dans l'attribution de fonctions calculée sur les données actives. La quantité iDCG mesure le *score idéal*. Il s'agit simplement d'un facteur de normalisation pour s'assurer que la quantité finale se situe dans la plage [0, 1], 1 désignant la meilleure valeur possible. Une valeur NDCG de 1 signifie que le classement d'attribution de fonctions dans les données actives est identique à celui des données d'entraînement. Dans cet exemple particulier, comme le classement a sensiblement changé, la valeur NDCG est de 0.69. Dans SageMaker Clarify, si la valeur NDCG est inférieure à 0,90, nous déclenchons automatiquement une alerte. ## Exemple de blocs-notes Model Monitor SageMaker Clarify fournit l'exemple de bloc-notes suivant qui montre comment capturer des données d'inférence pour un point de terminaison en temps réel, créer une base de référence pour surveiller l'évolution des biais et inspecter les résultats : + [Surveillance de la dérive des biais et de la dérive d'attribution des fonctionnalités Amazon SageMaker Clarify](https://sagemaker-examples.readthedocs.io/en/latest/sagemaker_model_monitor/fairness_and_explainability/SageMaker-Model-Monitor-Fairness-and-Explainability.html) — Utilisez Amazon SageMaker Model Monitor pour surveiller la dérive des biais et la dérive de l'attribution des fonctionnalités au fil du temps. Il a été vérifié que ce bloc-notes fonctionne uniquement dans SageMaker Studio. Si vous avez besoin d'instructions pour ouvrir un bloc-notes dans SageMaker Studio, consultez[Création ou ouverture d'un bloc-notes Amazon SageMaker Studio Classic](notebooks-create-open.md). Si vous êtes invité à choisir un noyau, choisissez **Python 3 (Science des données)**. Les rubriques suivantes contiennent les éléments principaux des deux dernières étapes, ainsi que des exemples de code tirés de l'exemple de bloc-notes. **Topics** + [Exemple de blocs-notes Model Monitor](#clarify-model-monitor-sample-notebooks-feature-drift) + [Créer une référence SHAP pour les modèles en production](clarify-model-monitor-shap-baseline.md) + [Violations de la dérive d'attribution de caractéristiques de modèle](clarify-model-monitor-model-attribution-drift-violations.md) + [Paramètres pour surveiller la dérive d’attribution](clarify-config-json-monitor-model-explainability-parameters.md) + [Programmer les tâches de surveillance de la dérive d’attribution des fonctions](clarify-model-monitor-feature-attribute-drift-schedule.md) + [Inspecter les rapports de dérive d’attribution des fonctions dans les modèles de production](clarify-feature-attribute-drift-report.md) + [CloudWatch Mesures pour l'analyse de la dérive des fonctionnalités](clarify-feature-attribute-drift-cw.md) # Créer une référence SHAP pour les modèles en production Les explications sont généralement contrastives. Autrement dit, elles tiennent compte des écarts par rapport à une référence. Pour plus d’informations sur les références d’explicabilité, consultez [Bases de référence SHAP pour l’explicabilité](clarify-feature-attribute-shap-baselines.md). En plus de fournir des explications pour les inférences par instance, SageMaker Clarify propose également une explication globale des modèles ML qui vous aide à comprendre le comportement d'un modèle dans son ensemble en termes de fonctionnalités. SageMaker Clarify génère une explication globale d'un modèle de machine learning en agrégeant les valeurs Shapley sur plusieurs instances. SageMaker Clarify prend en charge les différentes méthodes d'agrégation suivantes, que vous pouvez utiliser pour définir des lignes de base : + `mean_abs` - Moyenne des valeurs SHAP absolues pour toutes les instances. + `median` - Médiane des valeurs SHAP pour toutes les instances. + `mean_sq` : moyenne des valeurs SHAP au carré pour toutes les instances. Après avoir configuré votre application pour capturer des données d'inférence en temps réel ou de transformation par lots, la première tâche de surveillance de la dérive dans l'attribution de fonctions consiste à créer une référence qui servira de comparaison. Cela implique de configurer les entrées de données, les groupes sensibles, la capture des prédictions, ainsi que le modèle et ses métriques de biais post-entraînement. Ensuite, vous devez démarrer la tâche de baselining. Le moniteur d'explicabilité de modèle peut expliquer les prédictions d'un modèle déployé qui produit des inférences et détecter régulièrement la dérive d'attribution de fonctions. ``` model_explainability_monitor = ModelExplainabilityMonitor( role=role, sagemaker_session=sagemaker_session, max_runtime_in_seconds=1800, ) ``` Dans cet exemple, la tâche de baselining d'explicabilité partage le jeu de données de test avec la tâche de baselining de biais, il utilise donc la même `DataConfig`, la seule différence étant l'URI de sortie de la tâche. ``` model_explainability_baselining_job_result_uri = f"{baseline_results_uri}/model_explainability" model_explainability_data_config = DataConfig( s3_data_input_path=validation_dataset, s3_output_path=model_explainability_baselining_job_result_uri, label=label_header, headers=all_headers, dataset_type=dataset_type, ) ``` Actuellement, l' SageMaker explicateur Clarify propose une implémentation évolutive et efficace de SHAP. La configuration d'explicabilité est SHAPConfig donc la suivante : + `baseline` - Liste de lignes (au moins une) ou URI d'objet S3 à utiliser comme jeu de données de référence dans l'algorithme SHAP du noyau. Le format doit être identique au format du jeu de données. Chaque ligne doit contenir uniquement la fonctionnalité columns/values et omettre la colonne/les valeurs de l'étiquette. + `num_samples` : nombre d’échantillons à utiliser dans l’algorithme SHAP du noyau. Ce nombre détermine la taille du jeu de données synthétique généré pour calculer les valeurs SHAP. + agg\$1method - Méthode d'agrégation pour les valeurs SHAP globales. Voici les valeurs valides : + `mean_abs` - Moyenne des valeurs SHAP absolues pour toutes les instances. + `median` - Médiane des valeurs SHAP pour toutes les instances. + `mean_sq` - Moyenne des valeurs SHAP au carré pour toutes les instances. + `use_logit` - Indicateur signifiant si la fonction logit doit être appliquée aux prédictions du modèle. La valeur par défaut est `False`. Si `use_logit` est `True`, les valeurs SHAP auront des unités log-odds. + `save_local_shap_values` (bool) - Indicateur signifiant s'il faut enregistrer les valeurs SHAP locales à l'emplacement en sortie. La valeur par défaut est `False`. ``` # Here use the mean value of test dataset as SHAP baseline test_dataframe = pd.read_csv(test_dataset, header=None) shap_baseline = [list(test_dataframe.mean())] shap_config = SHAPConfig( baseline=shap_baseline, num_samples=100, agg_method="mean_abs", save_local_shap_values=False, ) ``` Démarrez une tâche de baselining. La `model_config` doit être la même, car la tâche de baselining d’explicabilité doit créer un point de terminaison fantôme pour obtenir des prédictions pour le jeu de données synthétiques généré. ``` model_explainability_monitor.suggest_baseline( data_config=model_explainability_data_config, model_config=model_config, explainability_config=shap_config, ) print(f"ModelExplainabilityMonitor baselining job: {model_explainability_monitor.latest_baselining_job_name}") ``` # Violations de la dérive d'attribution de caractéristiques de modèle Les tâches de dérive d'attribution de caractéristiques évaluent les contraintes de base fournies par la [configuration de base](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_CreateModelExplainabilityJobDefinition.html#sagemaker-CreateModelExplainabilityJobDefinition-request-ModelExplainabilityBaselineConfig) par rapport aux résultats d'analyse du code `MonitoringExecution` actuel. Si des violations sont détectées, la tâche les répertorie dans le fichier *contraint\$1violations.json* à l'emplacement de la sortie d'exécution, et affecte le statut d'exécution [Interprétation des résultats](model-monitor-interpreting-results.md). Voici le schéma du fichier de violations de dérive d'attribution de caractéristiques. + `label` – Nom de l'étiquette, `label_headers` de configuration de l'analyse des tâches ou espace réservé tel que `"label0"`. + `metric_name` – Nom de la méthode d'analyse d'explicabilité. Actuellement, seul `shap` est pris en charge. + `constraint_check_type` : type de violation surveillée. Actuellement, seul `feature_attribution_drift_check` est pris en charge. + `description` : message descriptif visant à expliquer la violation. ``` { "version": "1.0", "violations": [{ "label": "string", "metric_name": "string", "constraint_check_type": "string", "description": "string" }] } ``` Pour chaque étiquette dans la section `explanations`, les tâches de surveillance calculent le [score NDCG](https://scikit-learn.org/stable/modules/generated/sklearn.metrics.ndcg_score.html) de ses valeurs SHAP globales dans le fichier de contraintes de base et dans le fichier des résultats d'analyse des tâches (*analysis.json*). Si le score est inférieur à 0,9, une violation est consignée. La valeur SHAP globale combinée est évaluée, si bien qu'il n'y a aucun champ `“feature”` dans l'entrée de violation. La sortie suivante fournit un exemple de plusieurs violations consignées. ``` { "version": "1.0", "violations": [{ "label": "label0", "metric_name": "shap", "constraint_check_type": "feature_attribution_drift_check", "description": "Feature attribution drift 0.7639720923277322 exceeds threshold 0.9" }, { "label": "label1", "metric_name": "shap", "constraint_check_type": "feature_attribution_drift_check", "description": "Feature attribution drift 0.7323763972092327 exceeds threshold 0.9" }] } ``` # Paramètres pour surveiller la dérive d’attribution Le moniteur d' SageMaker explicabilité Amazon Clarify réutilise un sous-ensemble des paramètres utilisés dans la configuration d'analyse de. [Fichiers de configuration d’analyse](clarify-processing-job-configure-analysis.md) Les paramètres suivants doivent être fournis dans un fichier JSON et le chemin d'accès doit être fourni dans le paramètre `ConfigUri` de [https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_ModelExplainabilityAppSpecification](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_ModelExplainabilityAppSpecification). + `"version"` : (facultatif) version de schéma du fichier de configuration. Si elle n’est pas fournie, la dernière version prise en charge est utilisée. + `"headers"` – (Facultatif) Liste des noms de caractéristiques dans le jeu de données. L'analyse de l'explicabilité ne nécessite pas d'étiquettes. + `"methods"` – Liste des méthodes et de leurs paramètres pour les analyses et les rapports. Si une section est omise, elle n’est pas calculée. + `"shap"` – (Facultatif) Section sur le calcul de la valeur SHAP. + `"baseline"` – (Facultatif) Liste de lignes (au moins une) ou URI d'objet Amazon Simple Storage Service (Amazon S3). À utiliser comme jeu de données de référence (également appelé jeu de données d’arrière-plan) dans l’algorithme SHAP du noyau. Le format doit être identique au format du jeu de données. Chaque ligne doit contenir uniquement les colonnes (ou valeurs) de caractéristiques. Avant d'envoyer chaque ligne au modèle, omettez toute colonne qui doit être exclue. + `"num_samples"` : nombre d’échantillons à utiliser dans l’algorithme SHAP du noyau. Ce nombre détermine la taille du jeu de données synthétique généré pour calculer les valeurs SHAP. Si ce n'est pas le cas, une tâche SageMaker Clarify choisit la valeur en fonction du nombre de fonctionnalités. + `"agg_method"` : méthode d’agrégation pour les valeurs SHAP globales. Les valeurs valides sont les suivantes : + `"mean_abs"` - Moyenne des valeurs SHAP absolues pour toutes les instances. + `"median"` - Médiane des valeurs SHAP pour toutes les instances. + `"mean_sq"` : moyenne des valeurs SHAP au carré pour toutes les instances. + `"use_logit"` – (Facultatif) Valeur booléenne pour indiquer si la fonction logit doit être appliquée aux prédictions du modèle. Si `"use_logit"` est `true`, alors les valeurs SHAP ont des unités log-odds. La valeur par défaut est `false`. + `"save_local_shap_values"` : (facultatif) valeur booléenne pour indiquer si les valeurs SHAP locales doivent être enregistrées à l’emplacement en sortie. Utilisez `true` pour les enregistrer. Utilisez `false` pour ne pas les enregistrer. La valeur par défaut est `false`. + `"predictor"` : (Facultatif pour le point de terminaison en temps réel, obligatoire pour la transformation par lots) Section sur les paramètres du modèle, requise si les sections `"shap"` et `"post_training_bias"` sont présentes. + `"model_name"` : nom de modèle (tel que créé par l’API `CreateModel` avec le mode conteneur en tant que `SingleModel`). + `"instance_type"` – Type d'instance pour le point de terminaison fantôme. + `"initial_instance_count"` - Nombre d'instances pour le point de terminaison fantôme. + `"content_type"` – (Facultatif) Format d'entrée de modèle à utiliser pour obtenir des inférences avec le point de terminaison fantôme. Les valeurs valides sont `"text/csv"` pour CSV, `"application/jsonlines"` pour JSON Lines, `application/x-parquet` pour Apache Parquet, et `application/x-image` pour activer l'explicabilité de la reconnaissance d'image. La valeur par défaut est identique au format `dataset_type`. + `"accept_type"` – (Facultatif) Modèle *output (sortie)* à utiliser pour obtenir des inférences avec le point de terminaison fantôme. Les valeurs valides sont `"text/csv"` pour CSV et `"application/jsonlines"` pour JSON Lines. En cas d'omission, SageMaker Clarify utilise le type de données de réponse des données capturées. + `"content_template"` : (facultatif) chaîne de modèle utilisée pour créer l’entrée de modèle à partir d’instances du jeu de données. Elle est utilisée uniquement si `"content_type"` est `"application/jsonlines"`. Le modèle doit avoir un seul espace réservé, `$features`, qui est remplacé par la liste des fonctions lors de l’exécution. Par exemple, étant donné `"content_template":"{\"myfeatures\":$features}"`, si une instance (sans étiquette) est `1,2,3`, l'entrée du modèle devient JSON Lines `'{"myfeatures":[1,2,3]}'`. + `"label_headers"` – (Facultatif) Liste des valeurs que la `"label"` prend dans le jeu de données. Associe les scores renvoyés par le point de terminaison ou la tâche de transformation par lots du modèle à leurs valeurs d'étiquette correspondantes. S’il est fourni, le rapport d’analyse utilise les en-têtes à la place d’espaces réservés tels que `“label0”`. Les autres paramètres doivent être fournis dans `EndpointInput` (pour les points de terminaison en temps réel) ou `BatchTransformInput` (pour les tâches de transformation par lots) de l'API [https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_ModelExplainabilityJobInput](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_ModelExplainabilityJobInput). + `FeaturesAttribute` : ce paramètre est requis si le format des données d'entrée du point de terminaison ou la tâche par lots est `"application/jsonlines"`. Il est JMESPath utilisé pour localiser les colonnes d'entités si le format du jeu de données est JSON Lines. + `ProbabilityAttribute`— Indice ou JMESPath emplacement dans la sortie du modèle pour les probabilités. Si la sortie du modèle est JSON Lines avec une liste d’étiquettes et de probabilités, par exemple, l’étiquette qui correspond à la probabilité maximale est alors sélectionnée pour les calculs de biais. ## Exemples de fichiers de configuration JSON pour les jeux de données CSV et JSON Lines Voici des exemples des fichiers JSON utilisés pour configurer les jeux de données CSV et JSON Lines afin de les surveiller pour détecter une dérive d'attribution de caractéristiques. **Topics** + [Jeux de données CSV](#clarify-config-json-monitor-model-explainability-parameters-example-csv) + [Jeux de données JSON Lines](#clarify-config-json-monitor-model-explainability-parameters-example-jsonlines) ### Jeux de données CSV Considérons un jeu de données comportant trois colonnes de caractéristiques numériques, comme dans l'exemple suivant. ``` 0.5814568701544718, 0.6651538910132964, 0.3138080342665499 0.6711642728531724, 0.7466687034026017, 0.1215477472819713 0.0453256543003371, 0.6377430803264152, 0.3558625219713576 0.4785191813363956, 0.0265841045263860, 0.0376935084990697 ``` Supposons que la sortie du modèle comporte deux colonnes, la première correspondant à l'étiquette prédite et la seconde à la probabilité, comme dans l'exemple suivant. ``` 1, 0.5385257417814224 ``` L'exemple de fichier de configuration JSON suivant montre comment ce jeu de données CSV peut être configuré. ``` { "headers": [ "feature_1", "feature_2", "feature_3" ], "methods": { "shap": { "baseline": [ [0.4441164946610942, 0.5190374448171748, 0.20722795300473712] ], "num_samples": 100, "agg_method": "mean_abs" } }, "predictor": { "model_name": "my_model", "instance_type": "ml.m5.xlarge", "initial_instance_count": 1 } } ``` L'étiquette prédite est sélectionnée par le paramètre `"ProbabilityAttribute"`. La numérotation basée sur zéro est utilisée, donc 1 indique la deuxième colonne de la sortie du modèle. ``` "EndpointInput": { ... "ProbabilityAttribute": 1 ... } ``` ### Jeux de données JSON Lines Considérez un jeu de données comportant quatre colonnes de caractéristiques et une colonne d'étiquettes, où la première caractéristique et l'étiquette sont binaires, comme dans l'exemple suivant. ``` {"features":[0, 0.5814568701544718, 0.6651538910132964, 0.3138080342665499], "label":0} {"features":[1, 0.6711642728531724, 0.7466687034026017, 0.1215477472819713], "label":1} {"features":[0, 0.0453256543003371, 0.6377430803264152, 0.3558625219713576], "label":1} {"features":[1, 0.4785191813363956, 0.0265841045263860, 0.0376935084990697], "label":1} ``` L'entrée du modèle est identique au format du jeu de données, et la sortie du modèle est JSON Lines, comme dans l'exemple suivant. ``` {"predicted_label":1, "probability":0.5385257417814224} ``` Dans l’exemple suivant, le fichier de configuration JSON montre comment ce jeu de données JSON Lines peut être configuré. ``` { "headers": [ "feature_1", "feature_2", "feature_3" ], "methods": { "shap": { "baseline": [ {"features":[0.4441164946610942, 0.5190374448171748, 0.20722795300473712]} ], "num_samples": 100, "agg_method": "mean_abs" } }, "predictor": { "model_name": "my_model", "instance_type": "ml.m5.xlarge", "initial_instance_count": 1, "content_template":"{\"features\":$features}" } } ``` Ensuite, la valeur de paramètre `"features"` dans `EndpointInput` (pour les points de terminaison en temps réel) ou `BatchTransformInput` (pour les tâches de transformation par lots) est utilisée pour localiser les caractéristiques dans le jeu de données, et la valeur de paramètre `"probability"` sélectionne la valeur de probabilité à partir de la sortie du modèle. ``` "EndpointInput": { ... "FeaturesAttribute": "features", "ProbabilityAttribute": "probability", ... } ``` # Programmer les tâches de surveillance de la dérive d’attribution des fonctions Après avoir créé votre référence SHAP, vous pouvez appeler la méthode `create_monitoring_schedule()` de votre instance de classe `ModelExplainabilityMonitor` pour planifier une surveillance horaire de l’explicabilité des modèles. Les sections suivantes expliquent comment créer une surveillance de l’explicabilité 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. Si une tâche de baselining a été envoyée, le moniteur récupère automatiquement la configuration d’analyse à partir de la tâche de baselining. Toutefois, si vous ignorez l'étape de baselining ou si la nature du jeu de données de capture est différente de celle du jeu de données d'entraînement, vous devez fournir la configuration d'analyse. `ExplainabilityAnalysisConfig` a besoin de `ModelConfig` pour les mêmes raisons que la tâche de baselining. Comme le calcul de l'attribution de fonctions a seulement besoin de fonctions, vous devez exclure l'étiquetage Ground Truth. ## Surveillance de la dérive d'attribution des fonctions pour les modèles déployés sur des points de terminaison en temps réel Pour planifier une surveillance de l'explicabilité des modèles pour un point de terminaison en temps réel, transmettez votre instance `EndpointInput` à l'argument `endpoint_input` de votre instance `ModelExplainabilityMonitor`, comme indiqué dans l'exemple de code suivant : ``` from sagemaker.model_monitor import CronExpressionGenerator model_exp_model_monitor = ModelExplainabilityMonitor( role=sagemaker.get_execution_role(), ... ) schedule = model_exp_model_monitor.create_monitoring_schedule( monitor_schedule_name=schedule_name, post_analytics_processor_script=s3_code_postprocessor_uri, output_s3_uri=s3_report_path, statistics=model_exp_model_monitor.baseline_statistics(), constraints=model_exp_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", ) ) ``` ## Surveillance de la dérive d'attribution des fonctions pour les tâches de transformation par lots Pour planifier une surveillance de l'explicabilité des modèles pour une tâche de transformation par lots, transmettez votre instance `BatchTransformInput` à l'argument `batch_transform_input` de votre instance `ModelExplainabilityMonitor`, comme indiqué dans l'exemple de code suivant : ``` from sagemaker.model_monitor import CronExpressionGenerator model_exp_model_monitor = ModelExplainabilityMonitor( role=sagemaker.get_execution_role(), ... ) schedule = model_exp_model_monitor.create_monitoring_schedule( monitor_schedule_name=schedule_name, post_analytics_processor_script=s3_code_postprocessor_uri, output_s3_uri=s3_report_path, statistics=model_exp_model_monitor.baseline_statistics(), constraints=model_exp_model_monitor.suggested_constraints(), schedule_cron_expression=CronExpressionGenerator.hourly(), enable_cloudwatch_metrics=True, batch_transform_input=BatchTransformInput( destination="opt/ml/processing/data", model_name="batch-fraud-detection-model", input_manifests_s3_uri="s3://amzn-s3-demo-bucket/batch-fraud-detection/on-schedule-monitoring/in/", excludeFeatures="0", ) ) ``` # Inspecter les rapports de dérive d’attribution des fonctions dans les modèles de production Une fois que le programme que vous avez configuré a démarré par défaut, vous devez attendre que sa première exécution démarre, puis l’arrêter pour éviter d’encourir des frais. Pour inspecter les rapports, utilisez le code suivant : ``` schedule_desc = model_explainability_monitor.describe_schedule() execution_summary = schedule_desc.get("LastMonitoringExecutionSummary") if execution_summary and execution_summary["MonitoringExecutionStatus"] in ["Completed", "CompletedWithViolations"]: last_model_explainability_monitor_execution = model_explainability_monitor.list_executions()[-1] last_model_explainability_monitor_execution_report_uri = last_model_explainability_monitor_execution.output.destination print(f'Report URI: {last_model_explainability_monitor_execution_report_uri}') last_model_explainability_monitor_execution_report_files = sorted(S3Downloader.list(last_model_explainability_monitor_execution_report_uri)) print("Found Report Files:") print("\n ".join(last_model_explainability_monitor_execution_report_files)) else: last_model_explainability_monitor_execution = None print("====STOP==== \n No completed executions to inspect further. Please wait till an execution completes or investigate previously reported failures.") ``` En cas de violations par rapport à la référence, celles-ci sont répertoriées ici : ``` if last_model_explainability_monitor_execution: model_explainability_violations = last_model_explainability_monitor_execution.constraint_violations() if model_explainability_violations: print(model_explainability_violations.body_dict) ``` Si votre modèle est déployé sur un point de terminaison en temps réel, vous pouvez visualiser dans SageMaker Studio les résultats d'analyse et les CloudWatch mesures en choisissant l'onglet **Points de terminaison**, puis en double-cliquant sur le point de terminaison. # CloudWatch Mesures pour l'analyse de la dérive des fonctionnalités Ce guide présente CloudWatch les métriques et leurs propriétés que vous pouvez utiliser pour l'analyse de la dérive des attributs d'entités dans SageMaker Clarify. Les tâches de surveillance de dérive des attributs d'entités calculent et publient deux types de mesures : + La valeur SHAP globale de chaque entité. **Note** Le nom de cette métrique ajoute le nom de la fonctionnalité fourni par la configuration de l'analyse des tâches à `feature_`. Par exemple,`feature_X` est la valeur SHAP globale de la fonctionnalité `X`. + Nom de la métrique `ExpectedValue`. Ces métriques sont publiées dans l'espace de CloudWatch noms suivant : + Pour les points de terminaison en temps réel : `aws/sagemaker/Endpoints/explainability-metrics` + Pour les tâches de transformation par lots : `aws/sagemaker/ModelMonitoring/explainability-metrics` Chaque métrique comporte les propriétés suivantes : + `Endpoint` : le nom du point de terminaison surveillé, le cas échéant. + `MonitoringSchedule` : le nom du référencement pour la tâche de surveillance. + `ExplainabilityMethod` : la méthode utilisée pour calculer les valeurs de Shapley. Sélectionnez `KernelShap`. + `Label` : le nom fourni par la configuration de l'analyse des tâches `label_headers`, ou un espace réservé comme `label0`. + `ValueType` : le type de valeur renvoyée par la métrique. Choisissez `GlobalShapValues` ou `ExpectedValue`. Pour empêcher les tâches de surveillance de publier des métriques, définissez `publish_cloudwatch_metrics` sur `Disabled` dans la `Environment`carte de définition du [modèle d’explicabilité de tâche](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_CreateModelExplainabilityJobDefinition.html). # Planification des tâches de surveillance Amazon SageMaker Model Monitor vous permet de surveiller les données collectées à partir de vos points de terminaison en temps réel. Vous pouvez surveiller vos données selon une planification récurrente ou les surveiller une fois, immédiatement. Vous pouvez créer une planification de surveillance à l’aide de l’API [https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_CreateMonitoringSchedule.html](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_CreateMonitoringSchedule.html). Grâce à un calendrier de surveillance, l' SageMaker IA peut commencer à traiter des tâches pour analyser les données collectées au cours d'une période donnée. Dans le cadre de la tâche de traitement, l' SageMaker IA compare l'ensemble de données pour l'analyse en cours avec les statistiques de base et les contraintes que vous fournissez. L' SageMaker IA génère ensuite un rapport de violations. De plus, CloudWatch des métriques sont émises pour chaque caractéristique analysée. SageMaker L'IA fournit un conteneur prédéfini pour effectuer des analyses sur des ensembles de données tabulaires. Vous pouvez également choisir d’apporter votre propre conteneur comme indiqué dans la rubrique [Support pour vos propres conteneurs avec Amazon SageMaker Model Monitor](model-monitor-byoc-containers.md). Vous pouvez créer un calendrier de surveillance des modèles pour votre point de terminaison en temps réel ou votre tâche de transformation par lots. Comparez le trafic en temps réel ou les entrées de tâches par lots par rapport aux ressources de référence (contraintes et statistiques). **Example affectations de référence** Dans l’exemple suivant, le jeu de données d’entraînement utilisé pour entraîner le modèle a été chargé sur Amazon S3. S’il est déjà dans Amazon S3, vous pouvez pointer directement dessus. ``` # copy over the training dataset to Amazon S3 (if you already have it in Amazon S3, you could reuse it) baseline_prefix = prefix + '/baselining' baseline_data_prefix = baseline_prefix + '/data' baseline_results_prefix = baseline_prefix + '/results' baseline_data_uri = 's3://{}/{}'.format(bucket,baseline_data_prefix) baseline_results_uri = 's3://{}/{}'.format(bucket, baseline_results_prefix) print('Baseline data uri: {}'.format(baseline_data_uri)) print('Baseline results uri: {}'.format(baseline_results_uri)) ``` ``` training_data_file = open("test_data/training-dataset-with-header.csv", 'rb') s3_key = os.path.join(baseline_prefix, 'data', 'training-dataset-with-header.csv') boto3.Session().resource('s3').Bucket(bucket).Object(s3_key).upload_fileobj(training_data_file) ``` **Example planification d'une analyse récurrente** Si vous planifiez une surveillance des modèles pour un point de terminaison en temps réel, utilisez des contraintes et des statistiques de référence afin de comparer le trafic en temps réel. L’extrait de code suivant montre le format général que vous utilisez pour planifier une surveillance des modèles pour un point de terminaison en temps réel. Cet exemple planifie le moniteur de modèles pour qu'il s'exécute toutes les heures. ``` from sagemaker.model_monitor import CronExpressionGenerator from time import gmtime, strftime mon_schedule_name = 'my-model-monitor-schedule-' + strftime("%Y-%m-%d-%H-%M-%S", gmtime()) my_default_monitor.create_monitoring_schedule( monitor_schedule_name=mon_schedule_name, endpoint_input=EndpointInput( endpoint_name=endpoint_name, destination="/opt/ml/processing/input/endpoint" ), post_analytics_processor_script=s3_code_postprocessor_uri, output_s3_uri=s3_report_path, statistics=my_default_monitor.baseline_statistics(), constraints=my_default_monitor.suggested_constraints(), schedule_cron_expression=CronExpressionGenerator.hourly(), enable_cloudwatch_metrics=True, ) ``` **Example planification d'une analyse ponctuelle** Vous pouvez également planifier l'analyse pour l'exécuter une fois de façon non récurrente en transmettant des arguments tels que les suivants à la méthode `create_monitoring_schedule` : ``` schedule_cron_expression=CronExpressionGenerator.now(), data_analysis_start_time="-PT1H", data_analysis_end_time="-PT0H", ``` Dans ces arguments, le paramètre `schedule_cron_expression` planifie l'analyse pour qu'elle soit exécutée une fois, immédiatement, avec la valeur `CronExpressionGenerator.now()`. Pour toute planification avec ce paramètre, les paramètres `data_analysis_start_time` et `data_analysis_end_time` sont nécessaires. Ces paramètres définissent l'heure de début et de fin d'une fenêtre d'analyse. Définissez ces heures comme des décalages relatifs à l'heure actuelle et utilisez le format de durée ISO 8601. Dans cet exemple, les instants `-PT1H` et `-PT0H` définissent une fenêtre entre une heure dans le passé et l'heure actuelle. Avec cette planification, l'analyse évalue uniquement les données collectées au cours de la fenêtre spécifiée. **Example planification d'une tâche de transformation par lots** L’extrait de code suivant montre le format général que vous utilisez pour planifier une surveillance des modèles pour une tâche de transformation par lots. ``` from sagemaker.model_monitor import ( CronExpressionGenerator, BatchTransformInput, MonitoringDatasetFormat, ) from time import gmtime, strftime mon_schedule_name = 'my-model-monitor-schedule-' + strftime("%Y-%m-%d-%H-%M-%S", gmtime()) my_default_monitor.create_monitoring_schedule( monitor_schedule_name=mon_schedule_name, batch_transform_input=BatchTransformInput( destination="opt/ml/processing/input", data_captured_destination_s3_uri=s3_capture_upload_path, dataset_format=MonitoringDatasetFormat.csv(header=False), ), post_analytics_processor_script=s3_code_postprocessor_uri, output_s3_uri=s3_report_path, statistics=my_default_monitor.baseline_statistics(), constraints=my_default_monitor.suggested_constraints(), schedule_cron_expression=CronExpressionGenerator.hourly(), enable_cloudwatch_metrics=True, ) ``` ``` desc_schedule_result = my_default_monitor.describe_schedule() print('Schedule status: {}'.format(desc_schedule_result['MonitoringScheduleStatus'])) ``` # Expression cron pour le programme de surveillance Pour fournir des détails relatifs à la planification de surveillance, utilisez [https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_ScheduleConfig.html](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_ScheduleConfig.html), qui est une expression `cron` décrivant les détails de la planification de surveillance. Amazon SageMaker Model Monitor prend en charge les `cron` expressions suivantes : + Pour indiquer que la tâche doit commencer toutes les heures, utilisez ce qui suit : `Hourly: cron(0 * ? * * *)` + Pour exécuter la tâche tous les jours, utilisez ce qui suit : `cron(0 [00-23] ? * * *)` + Pour exécuter la tâche une fois, immédiatement, utilisez le mot clé suivant : `NOW` Par exemple, les expressions `cron` suivantes sont valides : + Tous les jours à midi UTC : `cron(0 12 ? * * *)` + Tous les jours à minuit UTC : `cron(0 0 ? * * *)` Pour prendre en charge l'exécution toutes les 6, 12 heures, Model Monitor prend en charge l'expression suivante : `cron(0 [00-23]/[01-24] ? * * *)` Par exemple, les expressions `cron` suivantes sont valides : + Toutes les 12 heures, à partir de 17 h UTC : `cron(0 17/12 ? * * *)` + Toutes les deux heures, à partir de minuit UTC : `cron(0 0/2 ? * * *)` **Remarques** Bien que l’expression `cron` soit définie pour démarrer à 17 h UTC, il peut y avoir un délai de 0 à 20 minutes à partir de l’heure réelle demandée pour lancer l’exécution. Si vous souhaitez exécuter un programme quotidien, ne fournissez pas ce paramètre. SageMaker Chaque jour, l'IA choisit l'heure à laquelle elle doit fonctionner. Actuellement, l' SageMaker IA ne prend en charge que les taux entiers horaires compris entre 1 heure et 24 heures. # Configuration de politiques de contrôle des services pour les planifications de surveillance Vous devez spécifier les paramètres d'une tâche de surveillance lorsque vous créez ou mettez à jour un calendrier correspondant avec l'[CreateMonitoringSchedule](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_CreateMonitoringSchedule.html)API ou l'[UpdateMonitoringSchedule](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_UpdateMonitoringSchedule.html)API, respectivement. En fonction de votre cas d'utilisation, vous pouvez utiliser l'une des façons suivantes : + Vous pouvez spécifier le [MonitoringJobDefinition](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_MonitoringJobDefinition.html)champ de [MonitoringScheduleConfig](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_MonitoringScheduleConfig.html), lorsque vous invoquez `CreateMonitoringSchedule` ou`UpdateMonitoringSchedule`. Vous pouvez utiliser cela uniquement pour créer ou mettre à jour une planification pour une tâche de surveillance de la qualité des données. + Vous pouvez spécifier le nom d'une définition de tâche de surveillance, que vous avez déjà créée, pour le champ `MonitoringJobDefinitionName` de `MonitoringScheduleConfig`, lorsque vous invoquez `CreateMonitoringSchedule` ou `UpdateMonitoringSchedule`. Vous pouvez l'utiliser pour n'importe quelle définition de tâche que vous créez avec l'une des options suivantes APIs : + [CreateDataQualityJobDefinition](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_CreateDataQualityJobDefinition.html) + [CreateModelQualityJobDefinition](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_CreateModelQualityJobDefinition.html) + [CreateModelBiasJobDefinition](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_CreateModelBiasJobDefinition.html) + [CreateModelExplainabilityJobDefinition](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_CreateModelExplainabilityJobDefinition.html) Si vous souhaitez utiliser le SDK SageMaker Python pour créer ou mettre à jour des plannings, vous devez utiliser ce processus. Les processus susmentionnés s'excluent mutuellement, c'est-à-dire que vous pouvez spécifier le champ `MonitoringJobDefinition` ou le champ `MonitoringJobDefinitionName` lors de la création ou de la mise à jour de planifications de surveillance. Lorsque vous créez une définition de tâche de surveillance ou en spécifiez une dans le champ `MonitoringJobDefinition`, vous pouvez définir des paramètres de sécurité, tels que `NetworkConfig` et `VolumeKmsKeyId`. En tant qu'administrateur, vous souhaiterez peut-être que ces paramètres soient toujours définis sur certaines valeurs, afin que les tâches de surveillance s'exécutent toujours dans un environnement sécurisé. Pour ce faire, configurez des [politiques de contrôle des services](https://docs.aws.amazon.com/organizations/latest/userguide/orgs_manage_policies_scps.html) appropriées (SCPs). SCPs sont un type de politique d'entreprise que vous pouvez utiliser pour gérer les autorisations au sein de votre organisation. L'exemple suivant montre une politique SCP que vous pouvez utiliser pour vous assurer que les paramètres d'infrastructure sont correctement définis lors de la création ou de la mise à jour de planifications pour les tâches de surveillance. ------ #### [ JSON ] **** ``` { "Version":"2012-10-17", "Statement": [ { "Effect": "Deny", "Action": [ "sagemaker:CreateDataQualityJobDefinition", "sagemaker:CreateModelBiasJobDefinition", "sagemaker:CreateModelExplainabilityJobDefinition", "sagemaker:CreateModelQualityJobDefinition" ], "Resource": "arn:*:sagemaker:*:*:*", "Condition": { "Null": { "sagemaker:VolumeKmsKey":"true", "sagemaker:VpcSubnets": "true", "sagemaker:VpcSecurityGroupIds": "true" } } }, { "Effect": "Deny", "Action": [ "sagemaker:CreateDataQualityJobDefinition", "sagemaker:CreateModelBiasJobDefinition", "sagemaker:CreateModelExplainabilityJobDefinition", "sagemaker:CreateModelQualityJobDefinition" ], "Resource": "arn:*:sagemaker:*:*:*", "Condition": { "Bool": { "sagemaker:InterContainerTrafficEncryption": "false" } } }, { "Effect": "Deny", "Action": [ "sagemaker:CreateMonitoringSchedule", "sagemaker:UpdateMonitoringSchedule" ], "Resource": "arn:*:sagemaker:*:*:monitoring-schedule/*", "Condition": { "Null": { "sagemaker:ModelMonitorJobDefinitionName": "true" } } } ] } ``` ------ Les deux premières règles de cet exemple garantissent que les paramètres de sécurité sont toujours définis pour les définitions des tâches de surveillance. La dernière règle exige que tous les membres de votre organisation qui créent ou mettent à jour une planification doivent toujours spécifier le champ `MonitoringJobDefinitionName`. Cela garantit qu'aucun membre de votre organisation ne peut définir de valeurs non sécurisées pour les paramètres de sécurité en spécifiant le champ `MonitoringJobDefinition`, lors de la création ou de la mise à jour de planifications. # Conteneur préfabriqué Amazon SageMaker Model Monitor SageMaker L'IA fournit une image intégrée appelée `sagemaker-model-monitor-analyzer` qui vous fournit une gamme de fonctionnalités de surveillance des modèles, notamment la suggestion de contraintes, la génération de statistiques, la validation des contraintes par rapport à une référence et l'émission de CloudWatch métriques Amazon. Cette image est basée sur Spark version 3.3.0 et est construite avec [Deequ](https://github.com/awslabs/deequ) version 2.0.2. **Note** Vous ne pouvez pas récupérer l’image `sagemaker-model-monitor-analyzer` intégrée directement. Vous pouvez utiliser l'`sagemaker-model-monitor-analyzer`image lorsque vous soumettez une tâche de traitement ou de surveillance de référence à l'aide de l'un des AWS SDKs. Utilisez le SDK SageMaker Python (voir `image_uris.retrieve` le [guide de référence du SDK SageMaker AI Python](https://sagemaker.readthedocs.io/en/stable/api/utility/image_uris.html)) pour générer l'URI de l'image ECR pour vous, ou spécifiez directement l'URI de l'image ECR. L'image prédéfinie pour SageMaker Model Monitor est accessible comme suit : `.dkr.ecr..amazonaws.com/sagemaker-model-monitor-analyzer` Par exemple : `159807026194.dkr.ecr.us-west-2.amazonaws.com/sagemaker-model-monitor-analyzer` Si vous vous trouvez dans une AWS région de Chine, les images prédéfinies pour SageMaker Model Monitor sont accessibles comme suit : `.dkr.ecr..amazonaws.com.rproxy.govskope.us.cn/sagemaker-model-monitor-analyzer` Pour les noms de compte IDs et de AWS région, consultez les [chemins de registre Docker et les exemples de code](https://docs.aws.amazon.com/sagemaker/latest/dg-ecr-paths/sagemaker-algo-docker-registry-paths). Pour écrire votre propre conteneur d’analyse, consultez le contrat de conteneur décrit à la section [Planifications de surveillance personnalisées](model-monitor-custom-monitoring-schedules.md). # Interprétation des résultats Après avoir exécuté une tâche de traitement de référence et obtenu des statistiques et des contraintes pour votre jeu de données, vous pouvez exécuter des tâches de surveillance qui calculent les statistiques et répertorient les violations des contraintes de référence. Les CloudWatch statistiques Amazon sont également enregistrées dans votre compte par défaut. Pour plus d'informations sur l'affichage des résultats de la surveillance dans Amazon SageMaker Studio, consultez[Visualisez les résultats pour les points de terminaison en temps réel dans Amazon Studio SageMaker](model-monitor-interpreting-visualize-results.md). ## Répertorier les exécutions Le programme démarre les tâches de surveillance aux intervalles spécifiés. Le code suivant répertorie les cinq dernières exécutions. Si vous exécutez ce code après avoir créé la planification horaire, les exécutions peuvent être vides et vous devrez peut-être attendre jusqu’à ce que vous franchissiez la limite horaire (en UTC) pour que les exécutions démarrent. Le code suivant inclut la logique d’attente. ``` mon_executions = my_default_monitor.list_executions() print("We created a hourly schedule above and it will kick off executions ON the hour (plus 0 - 20 min buffer.\nWe will have to wait till we hit the hour...") while len(mon_executions) == 0: print("Waiting for the 1st execution to happen...") time.sleep(60) mon_executions = my_default_monitor.list_executions() ``` ## Inspecter une exécution spécifique À l'étape précédente, vous avez récupéré la dernière exécution programmée réussie ou non. Vous pouvez explorer ce qui s’est bien ou mal passé. Les états terminaux sont les suivants : + `Completed` : l'exécution de la surveillance a réussi et le rapport de violations n'a révélé aucun problème. + `CompletedWithViolations` : l'exécution est terminée, mais des violations des contraintes ont été détectées. + `Failed` : l'exécution de la surveillance a échoué, peut-être à cause d'une erreur client (problèmes de rôle, par exemple) ou de problèmes d'infrastructure. Pour identifier la cause, consultez `FailureReason` et `ExitMessage`. ``` latest_execution = mon_executions[-1] # latest execution's index is -1, previous is -2 and so on.. time.sleep(60) latest_execution.wait(logs=False) print("Latest execution status: {}".format(latest_execution.describe()['ProcessingJobStatus'])) print("Latest execution result: {}".format(latest_execution.describe()['ExitMessage'])) latest_job = latest_execution.describe() if (latest_job['ProcessingJobStatus'] != 'Completed'): print("====STOP==== \n No completed executions to inspect further. Please wait till an execution completes or investigate previously reported failures.") ``` ``` report_uri=latest_execution.output.destination print('Report Uri: {}'.format(report_uri)) ``` ## Liste des rapports générés Utilisez le code suivant pour répertorier les rapports générés. ``` from urllib.parse import urlparse s3uri = urlparse(report_uri) report_bucket = s3uri.netloc report_key = s3uri.path.lstrip('/') print('Report bucket: {}'.format(report_bucket)) print('Report key: {}'.format(report_key)) s3_client = boto3.Session().client('s3') result = s3_client.list_objects(Bucket=report_bucket, Prefix=report_key) report_files = [report_file.get("Key") for report_file in result.get('Contents')] print("Found Report Files:") print("\n ".join(report_files)) ``` ## Rapport de violations Si des violations sont détectées par rapport à la référence, elles sont générées dans le rapport de violations. Utilisez le code suivant pour répertorier les violations. ``` violations = my_default_monitor.latest_monitoring_constraint_violations() pd.set_option('display.max_colwidth', -1) constraints_df = pd.io.json.json_normalize(violations.body_dict["violations"]) constraints_df.head(10) ``` Cela s'applique uniquement aux jeux de données contenant des données tabulaires. Les fichiers de schéma suivants spécifient les statistiques calculées et les violations surveillées. Fichiers de sortie pour données tabulaires | Nom de fichier | Description | | --- | --- | | statistics.json | Contient des statistiques en colonnes pour chaque fonction du jeu de données analysé. Consultez le schéma de ce fichier dans la rubrique suivante. Ce fichier est créé uniquement pour la surveillance de la qualité des données. | | constraint\$1violations.json | Contient une liste des violations détectées dans ce jeu de données actuel par rapport au fichier de statistiques et de contraintes de référence spécifié dans les chemins d'accès `baseline_constaints` et `baseline_statistics`. | [Conteneur préfabriqué Amazon SageMaker Model Monitor](model-monitor-pre-built-container.md)enregistre par défaut un ensemble de CloudWatch statistiques Amazon pour chaque fonctionnalité. Le code du conteneur peut émettre CloudWatch des métriques à cet emplacement :`/opt/ml/output/metrics/cloudwatch`. # Visualisez les résultats pour les points de terminaison en temps réel dans Amazon Studio SageMaker Si vous surveillez un point de terminaison en temps réel, vous pouvez également visualiser les résultats dans Amazon SageMaker Studio. Vous pouvez afficher les détails d’exécution de n’importe quelle tâche de surveillance et créer des graphiques illustrant la référence et les valeurs capturées pour une métrique calculée par la tâche de surveillance. **Pour afficher les résultats détaillés d'une tâche de surveillance** 1. Connectez-vous à Studio. Pour de plus amples informations, veuillez consulter [Présentation du domaine Amazon SageMaker AI](gs-studio-onboard.md). 1. Dans le volet de navigation de gauche, choisissez l’icône **Composants et registres** (![\[Orange paper airplane icon representing email or message sending functionality.\]](http://docs.aws.amazon.com/fr_fr/sagemaker/latest/dg/images/icons/Components_registries.png)). 1. Choisissez **Endpoints (Points de terminaison)** dans le menu déroulant. ![\[Emplacement du menu déroulant Points de terminaison dans la console.\]](http://docs.aws.amazon.com/fr_fr/sagemaker/latest/dg/images/model_monitor/mm-studio-endpoints.png) 1. Sous l’onglet Endpoint (Point de terminaison), choisissez le type de tâche de surveillance dont vous voulez afficher les détails. ![\[Emplacement de l’onglet Qualité du modèle dans la section SURVEILLANCE DES MODÈLES.\]](http://docs.aws.amazon.com/fr_fr/sagemaker/latest/dg/images/model_monitor/mm-studio-model-quality.png) 1. Choisissez le nom de la tâche de surveillance exécutée dont vous voulez afficher les détails dans la liste des tâches de surveillance. ![\[Onglet Qualité du modèle de la section SURVEILLANCE DES MODÈLES.\]](http://docs.aws.amazon.com/fr_fr/sagemaker/latest/dg/images/model_monitor/mm-studio-job-history.png) 1. L’onglet **MONITORING JOB DETAILS (DÉTAILS DE LA TÂCHE DE SURVEILLANCE)** s’ouvre et affiche un rapport détaillé de la tâche de surveillance. ![\[Onglet DÉTAILS DE LA TÂCHE DE SURVEILLANCE\]](http://docs.aws.amazon.com/fr_fr/sagemaker/latest/dg/images/model_monitor/mm-studio-job-details.png) Vous pouvez créer un graphique illustrant la référence et les métriques capturées pour une période donnée. **Pour créer un graphique dans SageMaker Studio afin de visualiser les résultats de surveillance** 1. Connectez-vous à Studio. Pour de plus amples informations, veuillez consulter [Présentation du domaine Amazon SageMaker AI](gs-studio-onboard.md). 1. Dans le volet de navigation de gauche, choisissez l’icône **Composants et registres** (![\[Orange paper airplane icon representing email or message sending functionality.\]](http://docs.aws.amazon.com/fr_fr/sagemaker/latest/dg/images/icons/Components_registries.png)). 1. Choisissez **Endpoints (Points de terminaison)** dans le menu déroulant. ![\[Emplacement du menu déroulant Points de terminaison dans la console.\]](http://docs.aws.amazon.com/fr_fr/sagemaker/latest/dg/images/model_monitor/mm-studio-endpoints.png) 1. Sous l’onglet **Point de terminaison**, choisissez le type de tâche de surveillance pour laquelle vous voulez créer un graphique. Voici un exemple de graphique pour le type de surveillance **Model quality (Qualité du modèle)**. ![\[Emplacement de l’onglet Qualité du modèle dans la section SURVEILLANCE DES MODÈLES.\]](http://docs.aws.amazon.com/fr_fr/sagemaker/latest/dg/images/model_monitor/mm-studio-model-quality.png) 1. Choisissez **Add chart (Ajouter un graphique**. ![\[Emplacement de l’option Ajouter un graphique dans la console.\]](http://docs.aws.amazon.com/fr_fr/sagemaker/latest/dg/images/model_monitor/mm-studio-add-chart.png) 1. Sous l’onglet **PROPRIÉTÉS DU GRAPHIQUE**, choisissez la période, la statistique et la métrique que vous voulez faire figurer. Voici un exemple de graphique pour un **délai** d’**une semaine**, sa **statistique** **moyenne** et la **métrique** **F1**. ![\[Emplacement où sélectionner une métrique dans la console.\]](http://docs.aws.amazon.com/fr_fr/sagemaker/latest/dg/images/model_monitor/mm-studio-chart-properties.png) 1. Le graphique qui affiche la référence et les statistiques de métrique actuelle que vous avez choisies à l’étape précédente s’affiche sous l’onglet **Point de terminaison**. ![\[Exemple de graphique montrant la métrique de référence et la métrique moyenne actuelle choisies à l’étape précédente.\]](http://docs.aws.amazon.com/fr_fr/sagemaker/latest/dg/images/model_monitor/mm-studio-f1-chart.png) # Rubriques avancées Les sections suivantes contiennent des tâches plus avancées qui expliquent comment personnaliser la surveillance à l'aide de scripts de prétraitement et de post-traitement, comment créer votre propre conteneur et comment l'utiliser CloudFormation pour créer un calendrier de surveillance. **Topics** + [Planifications de surveillance personnalisées](model-monitor-custom-monitoring-schedules.md) + [Créez un calendrier de surveillance pour un point de terminaison en temps réel avec une ressource CloudFormation personnalisée](model-monitor-cloudformation-monitoring-schedules.md) # Planifications de surveillance personnalisées En plus d'utiliser les mécanismes de surveillance préconçus, vous pouvez créer vos propres planifications et procédures de surveillance personnalisées à l'aide de scripts de prétraitement et de post-traitement, ou en utilisant ou créant votre propre conteneur. **Topics** + [Prétraitement et post-traitement](model-monitor-pre-and-post-processing.md) + [Support pour vos propres conteneurs avec Amazon SageMaker Model Monitor](model-monitor-byoc-containers.md) # Prétraitement et post-traitement Vous pouvez utiliser des scripts Python de prétraitement et de post-traitement personnalisés pour transformer l'entrée de votre surveillance de modèle ou étendre le code après une exécution de surveillance réussie. Téléchargez ces scripts sur Amazon S3 et référencez-les lors de la création de votre surveillance de modèle. L'exemple suivant montre comment personnaliser les planifications de surveillance à l'aide de scripts de prétraitement et de post-traitement. Remplacez *user placeholder text* par vos propres informations. ``` import boto3, os from sagemaker import get_execution_role, Session from sagemaker.model_monitor import CronExpressionGenerator, DefaultModelMonitor # Upload pre and postprocessor scripts session = Session() bucket = boto3.Session().resource("s3").Bucket(session.default_bucket()) prefix = "demo-sagemaker-model-monitor" pre_processor_script = bucket.Object(os.path.join(prefix, "preprocessor.py")).upload_file("preprocessor.py") post_processor_script = bucket.Object(os.path.join(prefix, "postprocessor.py")).upload_file("postprocessor.py") # Get execution role role = get_execution_role() # can be an empty string # Instance type instance_type = "instance-type" # instance_type = "ml.m5.xlarge" # Example # Create a monitoring schedule with pre and postprocessing my_default_monitor = DefaultModelMonitor( role=role, instance_count=1, instance_type=instance_type, volume_size_in_gb=20, max_runtime_in_seconds=3600, ) s3_report_path = "s3://{}/{}".format(bucket, "reports") monitor_schedule_name = "monitor-schedule-name" endpoint_name = "endpoint-name" my_default_monitor.create_monitoring_schedule( post_analytics_processor_script=post_processor_script, record_preprocessor_script=pre_processor_script, monitor_schedule_name=monitor_schedule_name, # use endpoint_input for real-time endpoint endpoint_input=endpoint_name, # or use batch_transform_input for batch transform jobs # batch_transform_input=batch_transform_name, output_s3_uri=s3_report_path, statistics=my_default_monitor.baseline_statistics(), constraints=my_default_monitor.suggested_constraints(), schedule_cron_expression=CronExpressionGenerator.hourly(), enable_cloudwatch_metrics=True, ) ``` **Topics** + [Script de prétraitement](#model-monitor-pre-processing-script) + [Échantillonnage personnalisé](#model-monitor-pre-processing-custom-sampling) + [Script de post-traitement](#model-monitor-post-processing-script) ## Script de prétraitement Utilisez des scripts de prétraitement lorsque vous devez transformer les entrées de votre surveillance de modèle. Supposons, par exemple, que la sortie de votre modèle soit un tableau `[1.0, 2.1]`. Le conteneur Amazon SageMaker Model Monitor ne fonctionne qu'avec des structures JSON tabulaires ou aplaties, comme. `{“prediction0”: 1.0, “prediction1” : 2.1}` Vous pouvez utiliser un script de prétraitement comme celui-ci pour transformer le tableau en structure JSON correcte. ``` def preprocess_handler(inference_record): input_data = inference_record.endpoint_input.data output_data = inference_record.endpoint_output.data.rstrip("\n") data = output_data + "," + input_data return { str(i).zfill(20) : d for i, d in enumerate(data.split(",")) } ``` Dans un autre exemple, supposons que votre modèle comporte des fonctions facultatives et que vous utilisiez `-1` pour indiquer que la fonction facultative possède une valeur manquante. Si vous disposez d'une surveillance de qualité des données, vous pouvez le supprimer `-1` du tableau des valeurs d'entrée afin qu'il ne soit pas inclus dans les calculs métriques de la surveillance. Vous pouvez utiliser un script comme celui-ci pour supprimer ces valeurs. ``` def preprocess_handler(inference_record): input_data = inference_record.endpoint_input.data return {i : None if x == -1 else x for i, x in enumerate(input_data.split(","))} ``` Votre script de prétraitement reçoit `inference_record` comme seule entrée. L'extrait de code suivant illustre un exemple de `inference_record`. ``` { "captureData": { "endpointInput": { "observedContentType": "text/csv", "mode": "INPUT", "data": "132,25,113.2,96,269.9,107,,0,0,0,0,0,0,1,0,1,0,0,1", "encoding": "CSV" }, "endpointOutput": { "observedContentType": "text/csv; charset=utf-8", "mode": "OUTPUT", "data": "0.01076381653547287", "encoding": "CSV" } }, "eventMetadata": { "eventId": "feca1ab1-8025-47e3-8f6a-99e3fdd7b8d9", "inferenceTime": "2019-11-20T23:33:12Z" }, "eventVersion": "0" } ``` L’extrait de code suivant illustre la structure complète d’une classe pour `inference_record`. ``` KEY_EVENT_METADATA = "eventMetadata" KEY_EVENT_METADATA_EVENT_ID = "eventId" KEY_EVENT_METADATA_EVENT_TIME = "inferenceTime" KEY_EVENT_METADATA_CUSTOM_ATTR = "customAttributes" KEY_EVENTDATA_ENCODING = "encoding" KEY_EVENTDATA_DATA = "data" KEY_GROUND_TRUTH_DATA = "groundTruthData" KEY_EVENTDATA = "captureData" KEY_EVENTDATA_ENDPOINT_INPUT = "endpointInput" KEY_EVENTDATA_ENDPOINT_OUTPUT = "endpointOutput" KEY_EVENTDATA_BATCH_OUTPUT = "batchTransformOutput" KEY_EVENTDATA_OBSERVED_CONTENT_TYPE = "observedContentType" KEY_EVENTDATA_MODE = "mode" KEY_EVENT_VERSION = "eventVersion" class EventConfig: def __init__(self, endpoint, variant, start_time, end_time): self.endpoint = endpoint self.variant = variant self.start_time = start_time self.end_time = end_time class EventMetadata: def __init__(self, event_metadata_dict): self.event_id = event_metadata_dict.get(KEY_EVENT_METADATA_EVENT_ID, None) self.event_time = event_metadata_dict.get(KEY_EVENT_METADATA_EVENT_TIME, None) self.custom_attribute = event_metadata_dict.get(KEY_EVENT_METADATA_CUSTOM_ATTR, None) class EventData: def __init__(self, data_dict): self.encoding = data_dict.get(KEY_EVENTDATA_ENCODING, None) self.data = data_dict.get(KEY_EVENTDATA_DATA, None) self.observedContentType = data_dict.get(KEY_EVENTDATA_OBSERVED_CONTENT_TYPE, None) self.mode = data_dict.get(KEY_EVENTDATA_MODE, None) def as_dict(self): ret = { KEY_EVENTDATA_ENCODING: self.encoding, KEY_EVENTDATA_DATA: self.data, KEY_EVENTDATA_OBSERVED_CONTENT_TYPE: self.observedContentType, } return ret class CapturedData: def __init__(self, event_dict): self.event_metadata = None self.endpoint_input = None self.endpoint_output = None self.batch_transform_output = None self.ground_truth = None self.event_version = None self.event_dict = event_dict self._event_dict_postprocessed = False if KEY_EVENT_METADATA in event_dict: self.event_metadata = EventMetadata(event_dict[KEY_EVENT_METADATA]) if KEY_EVENTDATA in event_dict: if KEY_EVENTDATA_ENDPOINT_INPUT in event_dict[KEY_EVENTDATA]: self.endpoint_input = EventData(event_dict[KEY_EVENTDATA][KEY_EVENTDATA_ENDPOINT_INPUT]) if KEY_EVENTDATA_ENDPOINT_OUTPUT in event_dict[KEY_EVENTDATA]: self.endpoint_output = EventData(event_dict[KEY_EVENTDATA][KEY_EVENTDATA_ENDPOINT_OUTPUT]) if KEY_EVENTDATA_BATCH_OUTPUT in event_dict[KEY_EVENTDATA]: self.batch_transform_output = EventData(event_dict[KEY_EVENTDATA][KEY_EVENTDATA_BATCH_OUTPUT]) if KEY_GROUND_TRUTH_DATA in event_dict: self.ground_truth = EventData(event_dict[KEY_GROUND_TRUTH_DATA]) if KEY_EVENT_VERSION in event_dict: self.event_version = event_dict[KEY_EVENT_VERSION] def as_dict(self): if self._event_dict_postprocessed is True: return self.event_dict if KEY_EVENTDATA in self.event_dict: if KEY_EVENTDATA_ENDPOINT_INPUT in self.event_dict[KEY_EVENTDATA]: self.event_dict[KEY_EVENTDATA][KEY_EVENTDATA_ENDPOINT_INPUT] = self.endpoint_input.as_dict() if KEY_EVENTDATA_ENDPOINT_OUTPUT in self.event_dict[KEY_EVENTDATA]: self.event_dict[KEY_EVENTDATA][ KEY_EVENTDATA_ENDPOINT_OUTPUT ] = self.endpoint_output.as_dict() if KEY_EVENTDATA_BATCH_OUTPUT in self.event_dict[KEY_EVENTDATA]: self.event_dict[KEY_EVENTDATA][KEY_EVENTDATA_BATCH_OUTPUT] = self.batch_transform_output.as_dict() self._event_dict_postprocessed = True return self.event_dict def __str__(self): return str(self.as_dict()) ``` ## Échantillonnage personnalisé Vous pouvez également appliquer une stratégie d'échantillonnage personnalisée dans votre script de prétraitement. Pour ce faire, configurez le conteneur prédéfini de Model Monitor de manière à ignorer un pourcentage des enregistrements en fonction de la fréquence d'échantillonnage que vous avez spécifiée. Dans l’exemple suivant, le gestionnaire échantillonne 10 % des enregistrements en renvoyant l’enregistrement dans 10 % des appels du gestionnaire et en renvoyant une liste vide dans le cas contraire. ``` import random def preprocess_handler(inference_record): # we set up a sampling rate of 0.1 if random.random() > 0.1: # return an empty list return [] input_data = inference_record.endpoint_input.data return {i : None if x == -1 else x for i, x in enumerate(input_data.split(","))} ``` ### Journalisation personnalisée pour le script de prétraitement Si votre script de prétraitement renvoie une erreur, vérifiez les messages d'exception enregistrés CloudWatch pour le débogage. Vous pouvez accéder à l'enregistreur CloudWatch via l'`preprocess_handler`interface. Vous pouvez enregistrer toutes les informations dont vous avez besoin depuis votre script dans CloudWatch. Cela peut être utile lors du débogage de votre script de prétraitement. L'exemple suivant montre comment vous pouvez utiliser l'`preprocess_handler`interface pour vous connecter à CloudWatch ``` def preprocess_handler(inference_record, logger): logger.info(f"I'm a processing record: {inference_record}") logger.debug(f"I'm debugging a processing record: {inference_record}") logger.warning(f"I'm processing record with missing value: {inference_record}") logger.error(f"I'm a processing record with bad value: {inference_record}") return inference_record ``` ## Script de post-traitement Utilisez un script de post-traitement lorsque vous souhaitez étendre le code après une exécution de surveillance réussie. ``` def postprocess_handler(): print("Hello from post-proc script!") ``` # Support pour vos propres conteneurs avec Amazon SageMaker Model Monitor Amazon SageMaker Model Monitor fournit un conteneur prédéfini capable d'analyser les données capturées à partir de points de terminaison ou de tâches de transformation par lots pour des ensembles de données tabulaires. Si vous voulez apporter votre propre conteneur, vous pouvez mettre à profit les points d’extension fournis par Model Monitor. Ainsi, lorsque vous créez un `MonitoringSchedule`, Model Monitor lance les tâches de traitement. Par conséquent, le conteneur doit être conscient du contrat des tâches de traitement documenté dans la rubrique [Création de votre propre conteneur de traitement (scénario avancé)](build-your-own-processing-container.md). Model Monitor lance la tâche de traitement en votre nom selon le programme. Lors de l'appel, Model Monitor configure pour vous des variables d'environnement supplémentaires de sorte que votre conteneur ait suffisamment de contexte pour traiter les données correspondant à cette exécution particulière de la surveillance programmée. Pour plus d’informations sur les entrées de conteneur, consultez [Entrées du contrat de conteneur](model-monitor-byoc-contract-inputs.md). Dans le conteneur, à l'aide des variables d'environnement et du contexte ci-dessus, vous pouvez maintenant analyser le jeu de données pour la période en cours dans votre code personnalisé. Une fois cette analyse terminée, vous pouvez choisir d'émettre vos rapports à télécharger dans un compartiment S3. Les rapports générés par le conteneur préconçu sont documentés dans [Sorties du contrat de conteneur](model-monitor-byoc-contract-outputs.md). Si vous souhaitez que la visualisation des rapports fonctionne dans SageMaker Studio, vous devez suivre le même format. Vous pouvez également choisir d’émettre des rapports entièrement personnalisés. Vous pouvez également émettre CloudWatch des métriques depuis le conteneur en suivant les instructions de[CloudWatch Indicateurs pour apporter vos propres contenants](model-monitor-byoc-cloudwatch.md). **Topics** + [Entrées du contrat de conteneur](model-monitor-byoc-contract-inputs.md) + [Sorties du contrat de conteneur](model-monitor-byoc-contract-outputs.md) + [CloudWatch Indicateurs pour apporter vos propres contenants](model-monitor-byoc-cloudwatch.md) # Entrées du contrat de conteneur La plateforme Amazon SageMaker Model Monitor invoque votre code de conteneur selon un calendrier défini. Si vous avez choisi d'écrire votre propre code de conteneur, les variables d'environnement suivantes sont disponibles. Dans ce contexte, vous pouvez analyser le jeu de données actuel ou évaluer les contraintes si vous le souhaitez et émettre des métriques, le cas échéant. Les variables d'environnement disponibles sont les mêmes pour les points de terminaison en temps réel et les tâches de transformation par lots, à l'exception de la variable `dataset_format`. Si vous utilisez un point de terminaison en temps réel, la variable `dataset_format` prend en charge les options suivantes : ``` {\"sagemakerCaptureJson\": {\"captureIndexNames\": [\"endpointInput\",\"endpointOutput\"]}} ``` Si vous utilisez une tâche de transformation par lots, `dataset_format` prend en charge les options suivantes : ``` {\"csv\": {\"header\": [\"true\",\"false\"]}} ``` ``` {\"json\": {\"line\": [\"true\",\"false\"]}} ``` ``` {\"parquet\": {}} ``` L'exemple de code suivant montre le jeu complet des variables d'environnement disponibles pour votre code de conteneur (et utilise le format `dataset_format` d'un point de terminaison en temps réel). ``` "Environment": { "dataset_format": "{\"sagemakerCaptureJson\": {\"captureIndexNames\": [\"endpointInput\",\"endpointOutput\"]}}", "dataset_source": "/opt/ml/processing/endpointdata", "end_time": "2019-12-01T16: 20: 00Z", "output_path": "/opt/ml/processing/resultdata", "publish_cloudwatch_metrics": "Disabled", "sagemaker_endpoint_name": "endpoint-name", "sagemaker_monitoring_schedule_name": "schedule-name", "start_time": "2019-12-01T15: 20: 00Z" } ``` Parameters | Nom du paramètre | Description | | --- | --- | | dataset\$1format | Pour une tâche démarrée à partir d’un `MonitoringSchedule` basé sur un `Endpoint`, il s’agit de `sageMakerCaptureJson` avec les indices de capture `endpointInput` et/ou `endpointOutput`. Pour une tâche de transformation par lots, cela indique le format de données, qu'il s'agisse de CSV, JSON ou Parquet. | | dataset\$1source | Si vous utilisez un point de terminaison en temps réel, le chemin d'accès local dans lequel les données correspondant à la période de surveillance, comme spécifié par `start_time` et `end_time`, sont disponibles. Dans ce chemin d’accès, les données sont disponibles dans ` /{endpoint-name}/{variant-name}/yyyy/mm/dd/hh`. Nous téléchargeons parfois plus de données que ce qui est spécifié par les heures de début et de fin. C’est au code de conteneur d’analyser les données selon les besoins. | | output\$1path | Chemin d’accès local où écrire des rapports de sortie et d’autres fichiers. Vous devez spécifier ce paramètre dans la demande `CreateMonitoringSchedule` comme `MonitoringOutputConfig.MonitoringOutput[0].LocalPath`. Il est chargé dans le chemin d’accès `S3Uri` spécifié dans `MonitoringOutputConfig.MonitoringOutput[0].S3Uri`. | | publish\$1cloudwatch\$1metrics | Pour une tâche lancée par `CreateMonitoringSchedule`, ce paramètre est défini sur `Enabled`. Le conteneur peut choisir d'écrire le fichier de CloudWatch sortie Amazon à l'adresse`[filepath]`. | | sagemaker\$1endpoint\$1name | Si vous utilisez un point de terminaison en temps réel, le nom du `Endpoint` pour lequel cette tâche planifiée a été lancée. | | sagemaker\$1monitoring\$1schedule\$1name | Nom du `MonitoringSchedule` qui a lancé cette tâche. | | \$1sagemaker\$1endpoint\$1datacapture\$1prefix\$1 | Si vous utilisez un point de terminaison en temps réel, le préfixe spécifié dans le paramètre `DataCaptureConfig` du `Endpoint`. Le conteneur peut l'utiliser s'il a besoin d'accéder directement à plus de données que celles déjà téléchargées par l' SageMaker IA sur le `dataset_source` chemin. | | start\$1time, end\$1time | Fenêtre horaire pour l’analyse exécutée. Par exemple, pour une tâche planifiée pour s’exécuter à 5 h 00 UTC et une tâche qui s’exécute le 20/02/202, `start_time` : est 2020-02-19T06:00:00Z et `end_time` : est 2020-02-20T05:00:00Z | | baseline\$1constraints: | Chemin d’accès local du fichier de contrainte de référence spécifié dans ` BaselineConfig.ConstraintResource.S3Uri`. Ce paramètre est disponible uniquement si ce paramètre a été spécifié dans la demande `CreateMonitoringSchedule`. | | baseline\$1statistics | Chemin d’accès local au fichier de statistiques de référence spécifié dans `BaselineConfig.StatisticsResource.S3Uri`. Ce paramètre est disponible uniquement si ce paramètre a été spécifié dans la demande `CreateMonitoringSchedule`. | # Sorties du contrat de conteneur Le conteneur peut analyser les données disponibles dans le chemin d’accès `*dataset_source*` et écrire des rapports dans le chemin d’accès dans `*output_path*.` Le code de conteneur peut écrire tous les rapports qui répondent à vos besoins. Si vous utilisez la structure et le contrat suivants, certains fichiers de sortie sont traités spécialement par l' SageMaker IA dans la visualisation et l'API. Cela s’applique uniquement aux jeux de données tabulaires. Fichiers de sortie pour données tabulaires | Nom de fichier | Description | | --- | --- | | statistics.json | Ce fichier doit comporter des statistiques en colonnes pour chaque fonction du jeu de données analysé. Le schéma de ce fichier est disponible dans la section suivante. | | constraints.json | Dans ce fichier, les contraintes sur les fonctions doivent être observées. Le schéma de ce fichier est disponible dans la section suivante. | | constraints\$1violations.json | Ce fichier doit contenir la liste des violations détectées dans ce jeu de données actif par rapport au fichier de statistiques et de contraintes de référence spécifié dans le chemin d'accès `baseline_constaints` et `baseline_statistics`. | De plus, si la `publish_cloudwatch_metrics` valeur est le code du `"Enabled"` conteneur, vous pouvez émettre CloudWatch des métriques Amazon à cet endroit :`/opt/ml/output/metrics/cloudwatch`. Le schéma de ces fichiers est décrit dans les sections suivantes. **Topics** + [Schéma des statistiques (fichier statistics.json)](model-monitor-byoc-statistics.md) + [Schéma des contraintes (fichier constraints.json)](model-monitor-byoc-constraints.md) # Schéma des statistiques (fichier statistics.json) Le schéma défini dans le fichier `statistics.json` spécifie les paramètres statistiques à calculer pour la référence et les données capturées. Il configure également le compartiment qui sera utilisé par [KLL](https://datasketches.apache.org/docs/KLL/KLLSketch.html), un croquis de quantiles très compact avec un schéma de compactage paresseux. ``` { "version": 0, # dataset level stats "dataset": { "item_count": number }, # feature level stats "features": [ { "name": "feature-name", "inferred_type": "Fractional" | "Integral", "numerical_statistics": { "common": { "num_present": number, "num_missing": number }, "mean": number, "sum": number, "std_dev": number, "min": number, "max": number, "distribution": { "kll": { "buckets": [ { "lower_bound": number, "upper_bound": number, "count": number } ], "sketch": { "parameters": { "c": number, "k": number }, "data": [ [ num, num, num, num ], [ num, num ][ num, num ] ] }#sketch }#KLL }#distribution }#num_stats }, { "name": "feature-name", "inferred_type": "String", "string_statistics": { "common": { "num_present": number, "num_missing": number }, "distinct_count": number, "distribution": { "categorical": { "buckets": [ { "value": "string", "count": number } ] } } }, #provision for custom stats } ] } ``` **Remarques** Les métriques spécifiées sont reconnues par l' SageMaker IA lors des modifications de visualisation ultérieures. Le conteneur peut émettre davantage de métriques si nécessaire. Le [croquis KLL](https://datasketches.apache.org/docs/KLL/KLLSketch.html) est le croquis reconnu. Les conteneurs personnalisés peuvent écrire leur propre représentation, mais celle-ci ne sera pas reconnue par l' SageMaker IA dans les visualisations. Par défaut, la distribution est matérialisée dans dix compartiments. Vous ne pouvez pas modifier cette valeur. # Schéma des contraintes (fichier constraints.json) Un fichier constraints.json est utilisé pour exprimer les contraintes qu'un jeu de données doit satisfaire. Les conteneurs Amazon SageMaker Model Monitor peuvent utiliser le fichier constraints.json pour évaluer les ensembles de données par rapport à ceux-ci. Les conteneurs préconçus permettent de générer automatiquement le fichier constraints.json pour un jeu de données de référence. Si vous apportez votre propre conteneur, vous pouvez lui attribuer des capacités similaires ou vous pouvez créer le fichier constraints.json d'une autre manière. Voici le schéma du fichier de contraintes utilisé par le conteneur préconçu. Les conteneurs personnalisés peuvent adopter le même format ou vous pouvez l’améliorer au besoin. ``` { "version": 0, "features": [ { "name": "string", "inferred_type": "Integral" | "Fractional" | | "String" | "Unknown", "completeness": number, "num_constraints": { "is_non_negative": boolean }, "string_constraints": { "domains": [ "list of", "observed values", "for small cardinality" ] }, "monitoringConfigOverrides": {} } ], "monitoring_config": { "evaluate_constraints": "Enabled", "emit_metrics": "Enabled", "datatype_check_threshold": 0.1, "domain_content_threshold": 0.1, "distribution_constraints": { "perform_comparison": "Enabled", "comparison_threshold": 0.1, "comparison_method": "Simple"||"Robust", "categorical_comparison_threshold": 0.1, "categorical_drift_method": "LInfinity"||"ChiSquared" } } } ``` L'objet `monitoring_config` contient des options pour surveiller la tâche pour la fonctionnalité. Le tableau suivant décrit chaque option. Surveillance des contraintes [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/fr_fr/sagemaker/latest/dg/model-monitor-byoc-constraints.html) # CloudWatch Indicateurs pour apporter vos propres contenants Si la `publish_cloudwatch_metrics` valeur se trouve `Enabled` sur la `Environment` carte du `/opt/ml/processing/processingjobconfig.json` fichier, le code du conteneur émet CloudWatch des métriques Amazon à cet emplacement :`/opt/ml/output/metrics/cloudwatch`. Le schéma de ce fichier est étroitement basé sur l' CloudWatch`PutMetrics`API. L’espace de noms n’est pas spécifié ici. La valeur par défaut est la suivante : + `For real-time endpoints: /aws/sagemaker/Endpoint/data-metrics` + `For batch transform jobs: /aws/sagemaker/ModelMonitoring/data-metrics` Toutefois, vous pouvez spécifier des dimensions. Nous vous recommandons d'ajouter les dimensions suivantes au minimum : + `Endpoint` et `MonitoringSchedule` pour les points de terminaison en temps réel + `MonitoringSchedule` pour les tâches de transformation par lots Les extraits de code JSON suivants montrent comment définir vos dimensions. Pour un point de terminaison en temps réel, consultez l'extrait JSON suivant qui inclut les dimensions `Endpoint` et `MonitoringSchedule` : ``` { "MetricName": "", # Required "Timestamp": "2019-11-26T03:00:00Z", # Required "Dimensions" : [{"Name":"Endpoint","Value":"endpoint_0"},{"Name":"MonitoringSchedule","Value":"schedule_0"}] "Value": Float, # Either the Value or the StatisticValues field can be populated and not both. "StatisticValues": { "SampleCount": Float, "Sum": Float, "Minimum": Float, "Maximum": Float }, "Unit": "Count", # Optional } ``` Pour une tâche de transformation par lots, consultez l'extrait JSON suivant qui inclut la dimension `MonitoringSchedule` : ``` { "MetricName": "", # Required "Timestamp": "2019-11-26T03:00:00Z", # Required "Dimensions" : [{"Name":"MonitoringSchedule","Value":"schedule_0"}] "Value": Float, # Either the Value or the StatisticValues field can be populated and not both. "StatisticValues": { "SampleCount": Float, "Sum": Float, "Minimum": Float, "Maximum": Float }, "Unit": "Count", # Optional } ``` # Créez un calendrier de surveillance pour un point de terminaison en temps réel avec une ressource CloudFormation personnalisée Si vous utilisez un point de terminaison en temps réel, vous pouvez utiliser une ressource CloudFormation personnalisée pour créer un calendrier de surveillance. La ressource personnalisée se trouve dans Python. Pour la déployer, consultez [Package de déploiement Lambda dans Python](https://docs.aws.amazon.com/lambda/latest/dg/lambda-python-how-to-create-deployment-package.html). ## Ressource personnalisée Commencez par ajouter une ressource personnalisée à votre CloudFormation modèle. Cela pointera vers une fonction AWS Lambda que vous créerez à l'étape suivante. Cette ressource vous permet de personnaliser les paramètres du programme de surveillance. Vous pouvez ajouter ou supprimer d'autres paramètres en modifiant la CloudFormation ressource et la fonction Lambda dans l'exemple de ressource suivant. ``` { "AWSTemplateFormatVersion": "2010-09-09", "Resources": { "MonitoringSchedule": { "Type": "Custom::MonitoringSchedule", "Version": "1.0", "Properties": { "ServiceToken": "arn:aws:lambda:us-west-2:111111111111:function:lambda-name", "ScheduleName": "YourScheduleName", "EndpointName": "YourEndpointName", "BaselineConstraintsUri": "s3://your-baseline-constraints/constraints.json", "BaselineStatisticsUri": "s3://your-baseline-stats/statistics.json", "PostAnalyticsProcessorSourceUri": "s3://your-post-processor/postprocessor.py", "RecordPreprocessorSourceUri": "s3://your-preprocessor/preprocessor.py", "InputLocalPath": "/opt/ml/processing/endpointdata", "OutputLocalPath": "/opt/ml/processing/localpath", "OutputS3URI": "s3://your-output-uri", "ImageURI": "111111111111.dkr.ecr.us-west-2.amazonaws.com/your-image", "ScheduleExpression": "cron(0 * ? * * *)", "PassRoleArn": "arn:aws:iam::111111111111:role/AmazonSageMaker-ExecutionRole" } } } } ``` ## Code de ressource personnalisée Lambda Cette ressource CloudFormation personnalisée utilise la AWS bibliothèque [Custom Resource Helper](https://github.com/aws-cloudformation/custom-resource-helper), que vous pouvez installer avec pip using. `pip install crhelper` Cette fonction Lambda est invoquée CloudFormation lors de la création et de la suppression de la pile. Cette fonction Lambda est responsable de la création et de la suppression de la planification de la surveillance et de l’utilisation des paramètres définis dans la ressource personnalisée décrite à la section précédente. ``` import boto3 import botocore import logging from crhelper import CfnResource from botocore.exceptions import ClientError logger = logging.getLogger(__name__) sm = boto3.client('sagemaker') # cfnhelper makes it easier to implement a CloudFormation custom resource helper = CfnResource() # CFN Handlers def handler(event, context): helper(event, context) @helper.create def create_handler(event, context): """ Called when CloudFormation custom resource sends the create event """ create_monitoring_schedule(event) @helper.delete def delete_handler(event, context): """ Called when CloudFormation custom resource sends the delete event """ schedule_name = get_schedule_name(event) delete_monitoring_schedule(schedule_name) @helper.poll_create def poll_create(event, context): """ Return true if the resource has been created and false otherwise so CloudFormation polls again. """ schedule_name = get_schedule_name(event) logger.info('Polling for creation of schedule: %s', schedule_name) return is_schedule_ready(schedule_name) @helper.update def noop(): """ Not currently implemented but crhelper will throw an error if it isn't added """ pass # Helper Functions def get_schedule_name(event): return event['ResourceProperties']['ScheduleName'] def create_monitoring_schedule(event): schedule_name = get_schedule_name(event) monitoring_schedule_config = create_monitoring_schedule_config(event) logger.info('Creating monitoring schedule with name: %s', schedule_name) sm.create_monitoring_schedule( MonitoringScheduleName=schedule_name, MonitoringScheduleConfig=monitoring_schedule_config) def is_schedule_ready(schedule_name): is_ready = False schedule = sm.describe_monitoring_schedule(MonitoringScheduleName=schedule_name) status = schedule['MonitoringScheduleStatus'] if status == 'Scheduled': logger.info('Monitoring schedule (%s) is ready', schedule_name) is_ready = True elif status == 'Pending': logger.info('Monitoring schedule (%s) still creating, waiting and polling again...', schedule_name) else: raise Exception('Monitoring schedule ({}) has unexpected status: {}'.format(schedule_name, status)) return is_ready def create_monitoring_schedule_config(event): props = event['ResourceProperties'] return { "ScheduleConfig": { "ScheduleExpression": props["ScheduleExpression"], }, "MonitoringJobDefinition": { "BaselineConfig": { "ConstraintsResource": { "S3Uri": props['BaselineConstraintsUri'], }, "StatisticsResource": { "S3Uri": props['BaselineStatisticsUri'], } }, "MonitoringInputs": [ { "EndpointInput": { "EndpointName": props["EndpointName"], "LocalPath": props["InputLocalPath"], } } ], "MonitoringOutputConfig": { "MonitoringOutputs": [ { "S3Output": { "S3Uri": props["OutputS3URI"], "LocalPath": props["OutputLocalPath"], } } ], }, "MonitoringResources": { "ClusterConfig": { "InstanceCount": 1, "InstanceType": "ml.t3.medium", "VolumeSizeInGB": 50, } }, "MonitoringAppSpecification": { "ImageUri": props["ImageURI"], "RecordPreprocessorSourceUri": props['PostAnalyticsProcessorSourceUri'], "PostAnalyticsProcessorSourceUri": props['PostAnalyticsProcessorSourceUri'], }, "StoppingCondition": { "MaxRuntimeInSeconds": 300 }, "RoleArn": props["PassRoleArn"], } } def delete_monitoring_schedule(schedule_name): logger.info('Deleting schedule: %s', schedule_name) try: sm.delete_monitoring_schedule(MonitoringScheduleName=schedule_name) except ClientError as e: if e.response['Error']['Code'] == 'ResourceNotFound': logger.info('Resource not found, nothing to delete') else: logger.error('Unexpected error while trying to delete monitoring schedule') raise e ``` # Modèle de moniteur FAQs Reportez-vous à ce qui suit FAQs pour plus d'informations sur Amazon SageMaker Model Monitor. **Q : Comment Model Monitor et SageMaker Clarify aident-ils les clients à surveiller le comportement des modèles ?** Les clients peuvent surveiller le comportement du modèle selon quatre dimensions : [qualité des données](https://docs.aws.amazon.com/sagemaker/latest/dg/model-monitor-data-quality.html), [qualité du modèle](https://docs.aws.amazon.com/sagemaker/latest/dg/model-monitor-model-quality.html), [dérive du biais](https://docs.aws.amazon.com/sagemaker/latest/dg/clarify-model-monitor-bias-drift.html) et [dérive de l'attribution des fonctionnalités](https://docs.aws.amazon.com/sagemaker/latest/dg/clarify-model-monitor-feature-attribution-drift.html) via Amazon SageMaker Model Monitor et SageMaker Clarify. [Model Monitor](https://aws.amazon.com/sagemaker/model-monitor/) surveille en permanence la qualité des modèles d'apprentissage automatique Amazon SageMaker AI en production. Cela inclut la surveillance de la dérive de la qualité des données et des métriques de qualité des modèles tels que la précision et la RMSE. [SageMaker Clarifier](https://aws.amazon.com/sagemaker/clarify/?sagemaker-data-wrangler-whats-new.sort-by=item.additionalFields.postDateTime&sagemaker-data-wrangler-whats-new.sort-order=desc) la surveillance des biais aide les scientifiques des données et les ingénieurs du ML à surveiller les biais dans les prévisions du modèle et la dérive d'attribution des caractéristiques. **Q : Que se passe-t-il en arrière-plan quand Sagemaker Model Monitor est activé ?** Amazon SageMaker Model Monitor automatise la surveillance des modèles, ce qui évite de devoir surveiller les modèles manuellement ou de créer des outils supplémentaires. Afin d'automatiser le processus, Model Monitor vous permet de créer un ensemble de statistiques et de contraintes de référence en utilisant les données avec lesquelles votre modèle a été entraîné, puis de définir une planification pour surveiller les prédictions effectuées sur votre point de terminaison. Model Monitor utilise des règles pour détecter les écarts dans vos modèles et vous en avertit le cas échéant. Les étapes suivantes décrivent ce qui se passe lorsque vous activez la surveillance des modèles : + **Activer la surveillance des modèles** : pour un point de terminaison en temps réel, vous devez permettre au point de terminaison de capturer les données issues des demandes entrantes dans un modèle ML déployé et les prédictions de modèle résultantes. Pour une tâche de transformation par lots, activez la capture des données des entrées et des sorties de transformation par lots. + **Tâche de traitement de référence** : vous créez ensuite une référence à partir du jeu de données qui a été utilisé pour entraîner le modèle. La référence calcule les métriques et suggère des contraintes pour les métriques. Par exemple, le score de rappel du modèle ne doit pas régresser et descendre en dessous de 0,571, ou le score de précision ne doit pas descendre en dessous de 1,0. Les prédictions en temps réel ou par lots réalisées à partir de votre modèle sont comparées aux contraintes et sont signalées comme des violations si elles se situent hors des valeurs contraintes. + **Tâche de surveillance** : vous créez ensuite une planification de surveillance spécifiant les données à collecter, la fréquence de collecte, la manière de les analyser et les rapports à produire. + **Job de fusion** : cela ne s'applique que si vous utilisez Amazon SageMaker Ground Truth. Model Monitor 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. 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. Lorsque vous utilisez Model Monitor pour surveiller une tâche de transformation par lots à la place d'un point de terminaison en temps réel, au lieu de recevoir des demandes à un point de terminaison et de suivre les prédictions, Model Monitor surveille les entrées et les sorties d'inférence. Dans une planification de Model Monitor, le client fournit le nombre et le type d'instances à utiliser dans le cadre de la tâche de traitement. Ces ressources restent réservées jusqu'à ce que la planification soit supprimée, quel que soit le statut de l'exécution en cours. **Q : Qu'est-ce que la capture de données, pourquoi est-elle requise et comment puis-je l'activer ?** Pour journaliser les entrées au niveau du point de terminaison et les sorties d'inférence à partir du modèle déployé sur Amazon S3, vous pouvez activer une fonctionnalité appelée [Capture de données](https://docs.aws.amazon.com/sagemaker/latest/dg/model-monitor-data-capture.html). Pour plus de détails sur la façon de l'activer pour un point de terminaison en temps réel et une tâche de transformation par lots, consultez [Capture des données à partir d'un point de terminaison en temps réel](https://docs.aws.amazon.com/sagemaker/latest/dg/model-monitor-data-capture-endpoint.html) et [Capture des données à partir d'une tâche de transformation par lots](https://docs.aws.amazon.com/sagemaker/latest/dg/model-monitor-data-capture-batch.html). **Q : L'activation de la capture de données a-t-elle un impact sur les performances d'un point de terminaison en temps réel ?** La capture des données s'effectue de manière asynchrone sans impact sur le trafic de production. Une fois que vous avez activé la capture des données, la charge utile de demande et de réponse, ainsi que certaines métadonnées supplémentaires sont enregistrées à l'emplacement Amazon S3 que vous avez spécifié dans `DataCaptureConfig`. Notez qu'il peut y avoir un retard dans la propagation des données capturées vers Amazon S3. Vous pouvez également afficher les données capturées en répertoriant les fichiers de capture de données stockés dans Amazon S3. Le format du chemin d’accès Amazon S3 est : `s3:///{endpoint-name}/{variant-name}/yyyy/mm/dd/hh/filename.jsonl`. La capture de données Amazon S3 doit avoir lieu dans la même région que la planification Model Monitor. Vous devez également vous assurer que les noms des colonnes du jeu de données de référence comportent uniquement des lettres minuscules et un trait de soulignement (`_`) comme seul séparateur. **Q : Pourquoi Ground Truth est-il requis pour la surveillance des modèles ?** Les étiquettes Ground Truth sont requises par les fonctionnalités suivantes de Model Monitor : + 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. + La **surveillance des biais du modèle** surveille les prédictions pour détecter les biais. Un biais peut être introduit dans des modèles ML déployés lorsque les données utilisées pour l'entraînement diffèrent des données utilisées pour générer des prédictions. Cela est particulièrement vrai si les données utilisées pour l'entraînement changent au fil du temps (par exemple, des taux hypothécaires variables). Dans ce cas, la prédiction du modèle n'est pas très précise, sauf si le modèle est réentraîné avec des données mises à jour. Par exemple, un modèle de prédiction des prix de l'immobilier peut être biaisé si les taux hypothécaires utilisés pour entraîner le modèle diffèrent du taux hypothécaire réel le plus récent. **Q : Pour les clients qui utilisent Ground Truth pour l'étiquetage, quelles sont les mesures que je peux prendre pour surveiller la qualité du modèle ?** 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. Outre les captures, l'exécution de la surveillance des biais du modèle nécessite également des données Ground Truth. Dans des cas d'utilisation réels, les données Ground Truth doivent être régulièrement collectées et chargées dans l'emplacement Amazon S3 désigné. 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. Pour la structure de chaque enregistrement des données Ground Truth, consultez [Ingestion d'étiquettes Ground Truth et fusion avec des prédictions](https://docs.aws.amazon.com/sagemaker/latest/dg/model-monitor-model-quality-merge.html). L'exemple de code suivant peut être utilisé pour générer des données Ground Truth artificielles pour un jeu de données tabulaire. ``` import random def ground_truth_with_id(inference_id): random.seed(inference_id) # to get consistent results rand = random.random() # format required by the merge container return { "groundTruthData": { "data": "1" if rand < 0.7 else "0", # randomly generate positive labels 70% of the time "encoding": "CSV", }, "eventMetadata": { "eventId": str(inference_id), }, "eventVersion": "0", } def upload_ground_truth(upload_time): records = [ground_truth_with_id(i) for i in range(test_dataset_size)] fake_records = [json.dumps(r) for r in records] data_to_upload = "\n".join(fake_records) target_s3_uri = f"{ground_truth_upload_path}/{upload_time:%Y/%m/%d/%H/%M%S}.jsonl" print(f"Uploading {len(fake_records)} records to", target_s3_uri) S3Uploader.upload_string_as_file_body(data_to_upload, target_s3_uri) # Generate data for the last hour upload_ground_truth(datetime.utcnow() - timedelta(hours=1)) # Generate data once a hour def generate_fake_ground_truth(terminate_event): upload_ground_truth(datetime.utcnow()) for _ in range(0, 60): time.sleep(60) if terminate_event.is_set(): break ground_truth_thread = WorkerThread(do_run=generate_fake_ground_truth) ground_truth_thread.start() ``` L'exemple de code suivant montre comment générer du trafic artificiel à envoyer au point de terminaison de modèle. Notez l'attribut `inferenceId` utilisé ci-dessus pour invoquer. S'il est présent, il est utilisé pour joindre avec les données Ground Truth (dans le cas contraire, `eventId` est utilisé). ``` import threading class WorkerThread(threading.Thread): def __init__(self, do_run, *args, **kwargs): super(WorkerThread, self).__init__(*args, **kwargs) self.__do_run = do_run self.__terminate_event = threading.Event() def terminate(self): self.__terminate_event.set() def run(self): while not self.__terminate_event.is_set(): self.__do_run(self.__terminate_event) def invoke_endpoint(terminate_event): with open(test_dataset, "r") as f: i = 0 for row in f: payload = row.rstrip("\n") response = sagemaker_runtime_client.invoke_endpoint( EndpointName=endpoint_name, ContentType="text/csv", Body=payload, InferenceId=str(i), # unique ID per row ) i += 1 response["Body"].read() time.sleep(1) if terminate_event.is_set(): break # Keep invoking the endpoint with test data invoke_endpoint_thread = WorkerThread(do_run=invoke_endpoint) invoke_endpoint_thread.start() ``` Vous devez charger les données Ground Truth dans un compartiment Amazon S3 ayant le même format de chemin que les données capturées, qui ont le format suivant : `s3:////yyyy/mm/dd/hh` **Note** La date de ce chemin est la date à laquelle l'étiquette Ground Truth est collectée. Il n'est pas nécessaire qu'elle corresponde à la date où l'inférence a été générée. **Q : Comment les clients peuvent-ils personnaliser les planifications de surveillance ?** En plus d'utiliser les mécanismes de surveillance intégrés, vous pouvez créer vos propres planifications et procédures de surveillance personnalisées à l'aide de scripts de prétraitement et de post-traitement, ou en utilisant ou créant votre propre conteneur. Il est important de noter que les scripts de prétraitement et de post-traitement ne fonctionnent qu’avec des tâches de qualité de modèle et de données. Amazon SageMaker AI vous permet de surveiller et d'évaluer les données observées par les points de terminaison du modèle. Pour cela, vous devez créer une base de référence vous permettant de comparer le trafic en temps réel. Une fois qu'une base de référence est prête, configurez une planification à évaluer et à comparer en permanence à la base de référence. Lors de la création d'une planification, vous pouvez fournir le script de prétraitement et de post-traitement. L'exemple suivant montre comment personnaliser des planifications de surveillance à l'aide de scripts de prétraitement et de post-traitement. ``` import boto3, osfrom sagemaker import get_execution_role, Sessionfrom sagemaker.model_monitor import CronExpressionGenerator, DefaultModelMonitor # Upload pre and postprocessor scripts session = Session() bucket = boto3.Session().resource("s3").Bucket(session.default_bucket()) prefix = "demo-sagemaker-model-monitor" pre_processor_script = bucket.Object(os.path.join(prefix, "preprocessor.py")).upload_file("preprocessor.py") post_processor_script = bucket.Object(os.path.join(prefix, "postprocessor.py")).upload_file("postprocessor.py") # Get execution role role = get_execution_role() # can be an empty string # Instance type instance_type = "instance-type" # instance_type = "ml.m5.xlarge" # Example # Create a monitoring schedule with pre and post-processing my_default_monitor = DefaultModelMonitor( role=role, instance_count=1, instance_type=instance_type, volume_size_in_gb=20, max_runtime_in_seconds=3600, ) s3_report_path = "s3://{}/{}".format(bucket, "reports") monitor_schedule_name = "monitor-schedule-name" endpoint_name = "endpoint-name" my_default_monitor.create_monitoring_schedule( post_analytics_processor_script=post_processor_script, record_preprocessor_script=pre_processor_script, monitor_schedule_name=monitor_schedule_name, # use endpoint_input for real-time endpoint endpoint_input=endpoint_name, # or use batch_transform_input for batch transform jobs # batch_transform_input=batch_transform_name, output_s3_uri=s3_report_path, statistics=my_default_monitor.baseline_statistics(), constraints=my_default_monitor.suggested_constraints(), schedule_cron_expression=CronExpressionGenerator.hourly(), enable_cloudwatch_metrics=True, ) ``` **Q : Quels sont les scénarios ou les cas d'utilisation dans lesquels je peux tirer parti d'un script de prétraitement ?** Vous pouvez utiliser des scripts de prétraitement lorsque vous devez transformer les entrées de votre moniteur de modèles. Prenons les exemples de scénarios suivants : 1. Script de prétraitement pour la transformation des données Supposons que la sortie de votre modèle soit un tableau : `[1.0, 2.1]`. Le conteneur Model Monitor fonctionne uniquement avec des structures JSON tabulaires ou mises à plat, telles que `{“prediction0”: 1.0, “prediction1” : 2.1}`. Vous pouvez utiliser un script de prétraitement comme l'exemple suivant pour transformer le tableau en structure JSON correcte. ``` def preprocess_handler(inference_record): input_data = inference_record.endpoint_input.data output_data = inference_record.endpoint_output.data.rstrip("\n") data = output_data + "," + input_data return { str(i).zfill(20) : d for i, d in enumerate(data.split(",")) } ``` 1. Exclusion de certains enregistrements des calculs de métriques de Model Monitor Supposons que votre modèle comporte des fonctionnalités facultatives et que vous utilisiez `-1` pour indiquer que la fonctionnalité facultative présente une valeur manquante. Si vous disposez d’une surveillance de qualité des données, vous pouvez le supprimer `-1` du tableau des valeurs d’entrée afin qu’il ne soit pas inclus dans les calculs métriques de la surveillance. Vous pouvez utiliser un script comme celui-ci pour supprimer ces valeurs. ``` def preprocess_handler(inference_record): input_data = inference_record.endpoint_input.data return {i : None if x == -1 else x for i, x in enumerate(input_data.split(","))} ``` 1. Application d'une stratégie d'échantillonnage personnalisée Vous pouvez également appliquer une stratégie d'échantillonnage personnalisée dans votre script de prétraitement. Pour ce faire, configurez le conteneur prédéfini de Model Monitor de manière à ignorer un pourcentage des enregistrements en fonction de la fréquence d’échantillonnage que vous avez spécifiée. Dans l'exemple suivant, le gestionnaire échantillonne 10 % des enregistrements en renvoyant l'enregistrement dans 10 % des appels du gestionnaire et en renvoyant une liste vide autrement. ``` import random def preprocess_handler(inference_record): # we set up a sampling rate of 0.1 if random.random() > 0.1: # return an empty list return [] input_data = inference_record.endpoint_input.data return {i : None if x == -1 else x for i, x in enumerate(input_data.split(","))} ``` 1. Utilisation d'une journalisation personnalisée Vous pouvez enregistrer toutes les informations dont vous avez besoin depuis votre script sur Amazon CloudWatch. Cela peut être utile lors du débogage de votre script de prétraitement en cas d'erreur. L'exemple suivant montre comment vous pouvez utiliser l'`preprocess_handler`interface pour vous connecter à CloudWatch. ``` def preprocess_handler(inference_record, logger): logger.info(f"I'm a processing record: {inference_record}") logger.debug(f"I'm debugging a processing record: {inference_record}") logger.warning(f"I'm processing record with missing value: {inference_record}") logger.error(f"I'm a processing record with bad value: {inference_record}") return inference_record ``` **Note** Lorsque le script de prétraitement est exécuté sur des données de transformation par lots, le type d'entrée n'est pas toujours l'objet `CapturedData`. Pour des données CSV, le type est une chaîne. Pour des données JSON, le type est un dictionnaire Python. **Q : Quand puis-je utiliser un script de post-traitement ?** Vous pouvez utiliser un script de post-traitement en tant qu'extension après une exécution de surveillance réussie. L'exemple suivant est simple, mais vous pouvez exécuter ou appeler n'importe quelle fonction métier dont vous avez besoin après une exécution de surveillance réussie. ``` def postprocess_handler(): print("Hello from the post-processing script!") ``` **Q : Quand dois-je envisager d’apporter mon propre conteneur pour la surveillance des modèles ?** SageMaker L'IA fournit un conteneur prédéfini pour analyser les données capturées à partir de points de terminaison ou pour les tâches de transformation par lots pour les ensembles de données tabulaires. Toutefois, dans certains scénarios, vous souhaiterez peut-être créer votre propre conteneur. Réfléchissez aux scénarios suivants : + Des exigences réglementaires et de conformité vous obligent à n’utiliser que les conteneurs créés et gérés en interne dans votre organisation. + Si vous souhaitez inclure quelques bibliothèques tierces, vous pouvez placer un `requirements.txt` fichier dans un répertoire local et le référencer à l'aide du `source_dir` paramètre de l'[estimateur SageMaker AI](https://sagemaker.readthedocs.io/en/stable/api/training/estimators.html#sagemaker.estimator.Estimator), qui permet l'installation de bibliothèques au moment de l'exécution. Toutefois, si vous avez de nombreuses bibliothèques ou dépendances qui augmentent le temps d’installation lors de l’exécution de la tâche d’entraînement, vous souhaiterez peut-être tirer parti du BYOC. + Votre environnement n'impose aucune connexion Internet (ni Silo), ce qui empêche le téléchargement de packages. + Vous souhaitez surveiller des données dans des formats autres que tabulaires, tels que les cas d'utilisation de modèles NLP ou CV. + Vous avez besoin de métriques de surveillance supplémentaires par rapport à celles prises en charge par Model Monitor. **Q : J'ai des modèles NLP et CV. Comment puis-je les surveiller pour détecter la dérive des données ?** Le conteneur SageMaker prédéfini d'Amazon AI prend en charge les ensembles de données tabulaires. Si vous souhaitez surveiller les modèles NLP et CV, vous pouvez apporter votre propre conteneur en tirant parti des points d’extension fournis par Model Monitor. Pour plus de détails sur les exigences, consultez [Apport de vos propres conteneurs](https://docs.aws.amazon.com/sagemaker/latest/dg/model-monitor-byoc-containers.html). Voici quelques exemples supplémentaires : + Pour une explication détaillée de l'utilisation de Model Monitor pour un cas d'utilisation de la vision par ordinateur, consultez [Détection et analyse de prédictions incorrectes](https://aws.amazon.com/blogs/machine-learning/detecting-and-analyzing-incorrect-model-predictions-with-amazon-sagemaker-model-monitor-and-debugger/) (langue française non garantie). + Pour un scénario dans lequel Model Monitor peut être utilisé pour un cas d'utilisation du NLP, voir [Détecter la dérive des données NLP à l'aide d'Amazon SageMaker Model Monitor personnalisé](https://aws.amazon.com/blogs/machine-learning/detect-nlp-data-drift-using-custom-amazon-sagemaker-model-monitor/). **Q : Je souhaite supprimer le point de terminaison du modèle pour lequel Model Monitor a été activé, mais je ne peux pas le faire car la planification de surveillance est toujours active. Que dois-je faire ?** Si vous souhaitez supprimer un point de terminaison d'inférence hébergé dans SageMaker AI sur lequel Model Monitor est activé, vous devez d'abord supprimer le calendrier de surveillance du modèle (à l'aide de la `DeleteMonitoringSchedule` [CLI](https://docs.aws.amazon.com/cli/latest/reference/sagemaker/delete-monitoring-schedule.html) ou de l'[API](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_DeleteMonitoringSchedule.html)). Ensuite, supprimez le point de terminaison. **Q : Est-ce que SageMaker Model Monitor calcule les mesures et les statistiques à saisir ?** Model Monitor calcule des métriques et des statistiques pour la sortie, et non pour l'entrée. **Q : SageMaker Model Monitor prend-il en charge les terminaux multimodèles ?** Non, Model Monitor prend en charge uniquement les points de terminaison qui hébergent un seul modèle, et non pas la surveillance des points de terminaison multimodèles. **Q : SageMaker Model Monitor fournit-il des données de surveillance sur les conteneurs individuels d'un pipeline d'inférence ?** Model Monitor prend en charge la surveillance des pipelines d’inférence, mais la capture et l’analyse des données sont effectuées pour l’ensemble du pipeline, pas pour ses conteneurs individuels. **Q : Que puis-je faire pour éviter tout impact sur les demandes d'inférence lorsque la capture de données est configurée ?** Pour éviter tout impact sur les requêtes d’inférence, Data Capture cesse de capturer les requêtes à des niveaux élevés d’utilisation du disque. Nous vous recommandons de maintenir l’utilisation du disque en dessous de 75 % pour que la capture des données continue de capturer les requêtes. **Q : La capture de données Amazon S3 peut-elle se faire dans une AWS région différente de celle dans laquelle le calendrier de surveillance a été configuré ?** Non, la capture de données Amazon S3 doit avoir lieu dans la même région que la planification de surveillance. **Q : Qu'est-ce qu'une base de référence et comment en créer une ? Puis-je créer une base de référence personnalisée ?** Une base de référence sert de référence pour comparer les prédictions en temps réel ou par lots issues du modèle. Elle calcule des statistiques et des métriques ainsi que des contraintes sur ces éléments. Au cours de la surveillance, tous ces éléments sont utilisés conjointement pour identifier les violations. Pour utiliser la solution par défaut d'Amazon SageMaker Model Monitor, vous pouvez utiliser le [SDK Amazon SageMaker Python](https://sagemaker.readthedocs.io/en/stable/api/inference/model_monitor.html). Plus précisément, utilisez la méthode [suggest\$1baseline](https://sagemaker.readthedocs.io/en/stable/api/inference/model_monitor.html#sagemaker.model_monitor.model_monitoring.DefaultModelMonitor.suggest_baseline) de la [ModelQualityMonitor](https://sagemaker.readthedocs.io/en/stable/api/inference/model_monitor.html#sagemaker.model_monitor.model_monitoring.ModelQualityMonitor)classe [ModelMonitor](https://sagemaker.readthedocs.io/en/stable/api/inference/model_monitor.html#sagemaker.model_monitor.model_monitoring.DefaultModelMonitor)ou pour déclencher une tâche de traitement qui calcule les métriques et les contraintes de la ligne de base. Le résultat d'une tâche de référence est constitué de deux fichiers : `statistics.json` et `constraints.json`. Le [schéma des statistiques](https://docs.aws.amazon.com/sagemaker/latest/dg/model-monitor-byoc-statistics.html) et le [schéma des contraintes](https://docs.aws.amazon.com/sagemaker/latest/dg/model-monitor-byoc-constraints.html) contiennent les schémas des fichiers respectifs. Vous pouvez passer en revue les contraintes générées et les modifier si nécessaire avant de les utiliser pour la surveillance. Sur la base de votre compréhension du domaine et du problème métier, vous pouvez rendre une contrainte plus agressive ou l'assouplir pour contrôler le nombre et la nature des violations. **Q : Quelles sont les directives pour créer un jeu de données de référence ?** La principale exigence pour tout type de surveillance est de disposer d'un jeu de données de référence utilisé pour calculer les métriques et les contraintes. Il s'agit généralement du jeu de données d'entraînement utilisé par le modèle, mais dans certains cas, vous pouvez choisir d'utiliser un autre jeu de données de référence. Les noms des colonnes du jeu de données de référence doivent être compatibles avec Spark. Afin de maintenir une compatibilité maximale entre Spark, CSV, JSON et parquet, il est conseillé de n'utiliser que des lettres minuscules et d'utiliser uniquement `_` comme séparateur. Les caractères spéciaux, y compris `“ ”`, peuvent poser des problèmes. **Q : Quels sont les paramètres `StartTimeOffset` et `EndTimeOffset`, et quand sont-ils utilisés ?** Lorsque Amazon SageMaker Ground Truth est requis pour surveiller des tâches telles que la qualité des modèles, vous devez vous assurer qu'une tâche de surveillance utilise uniquement des données pour lesquelles Ground Truth est disponible. Les `end_time_offset` paramètres `start_time_offset` et de [EndpointInput](https://sagemaker.readthedocs.io/en/stable/api/inference/model_monitor.html#sagemaker.model_monitor.model_monitoring.EndpointInput)peuvent être utilisés pour sélectionner les données utilisées par la tâche de surveillance. La tâche de surveillance utilise les données de la fenêtre temporelle définie par `start_time_offset` et `end_time_offset`. Ces paramètres doivent être spécifiés dans le [format de durée ISO 8601](https://en.wikipedia.org/wiki/ISO_8601#Durations). Voici quelques exemples : + Si vos résultats Ground Truth arrivent 3 jours après la réalisation des prédictions, définissez `start_time_offset="-P3D"` et `end_time_offset="-P1D"`, soit 3 jours et 1 jour respectivement. + Si les résultats Ground Truth arrivent 6 heures après les prédictions et que vous avez une planification horaire, définissez `start_time_offset="-PT6H"` et `end_time_offset="-PT1H"` sur 6 heures et 1 heure. **Q : Puis-je exécuter des tâches de surveillance « à la demande » ?** Oui, vous pouvez exécuter des tâches de surveillance « à la demande » en exécutant une tâche de SageMaker traitement. Pour Batch Transform, [Pipelines](https://docs.aws.amazon.com/sagemaker/latest/dg/pipelines-overview.html) propose un pipeline [MonitorBatchTransformStep](https://sagemaker.readthedocs.io/en/stable/workflows/pipelines/sagemaker.workflow.pipelines.html#sagemaker.workflow.monitor_batch_transform_step.MonitorBatchTransformStep)que vous pouvez utiliser pour créer un pipeline d' SageMaker IA qui exécute des tâches de surveillance à la demande. Le référentiel d'exemples d' SageMaker IA contient des exemples de code pour exécuter des tâches de surveillance [de la qualité des données](https://github.com/aws/amazon-sagemaker-examples/blob/main/sagemaker_model_monitor/model_monitor_batch_transform/SageMaker-ModelMonitoring-Batch-Transform-Data-Quality-With-SageMaker-Pipelines-On-Demand.ipynb) et [de la qualité des modèles](https://github.com/aws/amazon-sagemaker-examples/blob/main/sagemaker_model_monitor/model_monitor_batch_transform/SageMaker-ModelMonitoring-Batch-Transform-Model-Quality-With-SageMaker-Pipelines-On-Demand.ipynb) à la demande. **Q : Comment configurer Model Monitor ?** Vous pouvez configurer Model Monitor de la manière suivante : + **[SDK Amazon SageMaker AI Python](https://sagemaker.readthedocs.io/en/stable/index.html)** — Il existe un [module Model Monitor](https://sagemaker.readthedocs.io/en/stable/api/inference/model_monitor.html) qui contient des classes et des fonctions qui aident à suggérer des bases de référence, à créer des calendriers de surveillance, etc. Consultez les [exemples de blocs-notes Amazon SageMaker Model Monitor](https://github.com/aws/amazon-sagemaker-examples/tree/main/sagemaker_model_monitor) pour obtenir des blocs-notes détaillés qui exploitent le SDK SageMaker AI Python pour configurer Model Monitor. + **[Pipelines](https://docs.aws.amazon.com/sagemaker/latest/dg/pipelines-overview.html)** : les pipelines sont intégrés à Model Monitor via les [QualityCheck étapes](https://docs.aws.amazon.com/sagemaker/latest/dg/build-and-manage-steps.html#step-type-quality-check) et [ClarifyCheckStep](https://docs.aws.amazon.com/sagemaker/latest/dg/build-and-manage-steps.html#step-type-clarify-check) APIs. Vous pouvez créer un pipeline d' SageMaker IA qui contient ces étapes et qui peut être utilisé pour exécuter des tâches de surveillance à la demande chaque fois que le pipeline est exécuté. + **[Amazon SageMaker Studio Classic](https://docs.aws.amazon.com/sagemaker/latest/dg/studio.html)** : vous pouvez créer un calendrier de surveillance de la qualité des données ou des modèles ainsi que des programmes d'explicabilité et de partialité du modèle directement depuis l'interface utilisateur en sélectionnant un point de terminaison dans la liste des points de terminaison des modèles déployés. Des planifications pour d’autres types de surveillance peuvent être créées en sélectionnant l’onglet correspondant dans l’interface utilisateur. + **[SageMaker Tableau de bord du modèle](https://docs.aws.amazon.com/sagemaker/latest/dg/model-dashboard.html)** : vous pouvez activer la surveillance sur les terminaux en sélectionnant un modèle qui a été déployé sur un point de terminaison. Dans la capture d'écran suivante de la console SageMaker AI, un modèle nommé `group1` a été sélectionné dans la section **Modèles** du tableau de **bord des modèles**. Sur cette page, vous pouvez créer une planification de surveillance, et vous pouvez modifier, activer ou désactiver les planifications et les alertes de surveillance existantes. Pour obtenir un guide pas à pas sur la façon d'afficher les alertes et les planifications du moniteur de modèles, consultez [Affichage des planifications et des alertes de Model Monitor](https://docs.aws.amazon.com/sagemaker/latest/dg/model-dashboard-schedule.html). ![\[Capture d'écran du tableau de bord des modèles, montrant l'option permettant de créer une planification de surveillance.\]](http://docs.aws.amazon.com/fr_fr/sagemaker/latest/dg/images/model-monitoring-faqs-screenshot.png) **Q : Comment s'intègre Model Monitor au SageMaker Model Dashboard** [SageMaker Model Dashboard](https://docs.aws.amazon.com/sagemaker/latest/dg/model-dashboard.html) vous offre une surveillance unifiée de tous vos modèles en fournissant des alertes automatisées concernant les écarts par rapport au comportement attendu et en résolvant les problèmes afin d'inspecter les modèles et d'analyser les facteurs influant sur les performances des modèles au fil du temps.