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, qualité du modèle, dérive du biais et dérive de l'attribution des fonctionnalités via Amazon SageMaker Model Monitor et SageMaker Clarify. 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 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 :

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. 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 et Capture des données à partir d'une tâche de transformation par lots.

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 :

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.

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://<bucket>/<prefix>/yyyy/mm/dd/hh

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 :

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 :

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. Voici quelques exemples supplémentaires :

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 ou de l'API). 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. Plus précisément, utilisez la méthode suggest_baseline de la ModelQualityMonitorclasse ModelMonitorou 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 et le schéma des contraintes 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 EndpointInputpeuvent ê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. Voici quelques exemples :

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 propose un pipeline MonitorBatchTransformStepque 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 et de la qualité des modèles à la demande.

Q : Comment configurer Model Monitor ?

Vous pouvez configurer Model Monitor de la manière suivante :

Q : Comment s'intègre Model Monitor au SageMaker Model Dashboard ?

SageMaker Model Dashboard 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.