Ajouter une étape

Dans l' drag-and-dropinterface utilisateur de Pipelines, vous pouvez utiliser une étape d'exécution de code pour exécuter votre propre code en tant qu'étape de pipeline. Vous pouvez télécharger une fonction, un script ou un bloc-notes Python à exécuter dans le cadre de votre pipeline. Vous devez utiliser cette étape si vous souhaitez orchestrer une tâche de machine learning personnalisée qui tire parti des fonctionnalités avancées de l' SageMaker IA ou d'autres AWS services.

L'étape Execute Code télécharge les fichiers dans votre compartiment Amazon S3 par défaut pour Amazon SageMaker AI. Il est possible que les autorisations requises de partage de ressources entre origines (CORS) ne soient pas définies pour ce compartiment. Pour en savoir plus sur la configuration CORS des autorisations, consultezCORSExigence relative aux données d'image d'entrée.

L'étape Execute Code utilise une tâche de SageMaker formation Amazon pour exécuter votre code. Assurez-vous que votre IAM rôle dispose des sagemaker:CreateTrainingJob API autorisations sagemaker:DescribeTrainingJob et. Pour en savoir plus sur toutes les autorisations requises pour Amazon SageMaker AI et sur la façon de les configurer, consultezAPIAutorisations Amazon SageMaker AI : référence sur les actions, les autorisations et les ressources.

Pour ajouter une étape de code d'exécution à un pipeline à l'aide du concepteur de pipeline, procédez comme suit :

Utilisez une étape de traitement pour créer une tâche de traitement pour le traitement des données. Pour plus d'informations sur les tâches de traitement, veuillez consulter Données de traitement et Modèles d'évaluation.

Vous utilisez une étape d'entraînement pour créer une tâche d'entraînement afin d'entraîner un modèle. Pour plus d'informations sur les métiers de formation, consultez Train a Model with Amazon SageMaker AI.

Une étape d'entraînement nécessite un estimateur, ainsi que des entrées de données d'entraînement et de validation.

Vous utilisez une étape de réglage pour créer une tâche de réglage des hyperparamètres, également appelée optimisation des hyperparamètres ()HPO. Une tâche de réglage d'hyperparamètres exécute plusieurs tâches d'entraînement, chaque tâche produisant une version du modèle. Pour plus d'informations sur le réglage d'hyperparamètres, veuillez consulter Réglage automatique du modèle grâce à l' SageMaker IA.

La tâche de réglage est associée à l'expérience d' SageMaker IA pour le pipeline, les tâches de formation étant créées à titre d'essais. Pour de plus amples informations, veuillez consulter Intégration d'Experiments.

Une étape de réglage nécessite des entrées HyperparameterTuneret un entraînement. Vous pouvez entraîner à nouveau les tâches de réglage précédentes en spécifiant le paramètre warm_start_config du HyperparameterTuner. Pour plus d'informations sur le réglage d'hyperparamètres et le démarrage à chaud, veuillez consulter Exécution d'une tâche de réglage des hyperparamètres avec démarrage à chaud.

Vous utilisez la méthode get_top_model_s3_uri du sagemaker.workflow.steps. TuningStepclasse pour obtenir l'artefact du modèle à partir de l'une des versions les plus performantes du modèle. Pour un bloc-notes expliquant comment utiliser une étape de réglage dans un pipeline d' SageMaker IA, consultez sagemaker-pipelines-tuning-step.ipynb.

L'exemple suivant montre comment créer une définition TuningStep.

from sagemaker.workflow.pipeline_context import PipelineSession

from sagemaker.tuner import HyperparameterTuner
from sagemaker.inputs import TrainingInput
from sagemaker.workflow.steps import TuningStep

tuner = HyperparameterTuner(..., sagemaker_session=PipelineSession())
    
step_tuning = TuningStep(
    name = "HPTuning",
    step_args = tuner.fit(inputs=TrainingInput(s3_data="s3://amzn-s3-demo-bucket/my-data"))
)

Obtenir la meilleure version de modèle

L'exemple suivant montre comment obtenir la meilleure version de modèle à partir de la tâche de réglage à l'aide de la méthode get_top_model_s3_uri. Tout au plus, les 50 versions les plus performantes sont disponibles classées selon HyperParameterTuningJobObjective. L'argument top_k est un index dans les versions, où top_k=0 est la version la plus performante et top_k=49 est la version la moins performante.

best_model = Model(
    image_uri=image_uri,
    model_data=step_tuning.get_top_model_s3_uri(
        top_k=0,
        s3_bucket=sagemaker_session.default_bucket()
    ),
    ...
)

Pour plus d'informations sur les exigences relatives aux étapes de réglage, consultez le document sagemaker.workflow.steps. TuningStepdocumentation.

Le réglage fin entraîne un modèle de base préentraîné d'Amazon SageMaker JumpStart sur un nouvel ensemble de données. Ce processus, également connu sous le nom d'apprentissage par transfert, peut produire des modèles précis avec des jeux de données plus petits et moins de temps d'entraînement. Lorsque vous peaufinez un modèle, vous pouvez utiliser le jeu de données par défaut ou choisir vos propres données. Pour en savoir plus sur l'optimisation d'un modèle de base à partir de JumpStart, voirAffiner un modèle.

L'étape de mise au point utilise une tâche de SageMaker formation Amazon pour personnaliser votre modèle. Assurez-vous que votre IAM rôle dispose des sagemaker:CreateTrainingJob API autorisations sagemaker:DescribeTrainingJob et des autorisations nécessaires pour exécuter le travail de réglage précis dans votre pipeline. Pour en savoir plus sur les autorisations requises pour Amazon SageMaker AI et sur la façon de les configurer, consultezAPIAutorisations Amazon SageMaker AI : référence sur les actions, les autorisations et les ressources.

Pour ajouter une étape de modèle affinée à votre pipeline à l'aide de l' drag-and-dropéditeur, procédez comme suit :

Utilisez l'AutoML API pour créer une tâche AutoML afin d'entraîner automatiquement un modèle. Pour plus d'informations sur les tâches AutoML, consultez Automatiser le développement de modèles avec Amazon SageMaker Autopilot.

L'exemple suivant montre comment créer une définition avec AutoMLStep.

from sagemaker.workflow.pipeline_context import PipelineSession
from sagemaker.workflow.automl_step import AutoMLStep

pipeline_session = PipelineSession()

auto_ml = AutoML(...,
    role="<role>",
    target_attribute_name="my_target_attribute_name",
    mode="ENSEMBLING",
    sagemaker_session=pipeline_session) 

input_training = AutoMLInput(
    inputs="s3://amzn-s3-demo-bucket/my-training-data",
    target_attribute_name="my_target_attribute_name",
    channel_type="training",
)
input_validation = AutoMLInput(
    inputs="s3://amzn-s3-demo-bucket/my-validation-data",
    target_attribute_name="my_target_attribute_name",
    channel_type="validation",
)

step_args = auto_ml.fit(
    inputs=[input_training, input_validation]
)

step_automl = AutoMLStep(
    name="AutoMLStep",
    step_args=step_args,
)     

Obtenir la meilleure version de modèle

L'étape AutoML entraîne automatiquement plusieurs modèles candidats. Obtenez le modèle avec la meilleure métrique objective à partir de la tâche AutoML en utilisant la get_best_auto_ml_model méthode suivante. Vous devez également utiliser un IAM role pour accéder aux artefacts du modèle.

best_model = step_automl.get_best_auto_ml_model(role=<role>)

Pour plus d'informations, consultez l'étape AutoML dans le Python SageMaker . SDK

Utilisez un ModelStep pour créer ou enregistrer un modèle d' SageMaker IA. Pour plus d'informations sur les ModelStep exigences, consultez le document sagemaker.workflow.model_step. ModelStepdocumentation.

Création d’un modèle

Vous pouvez utiliser un ModelStep pour créer un modèle d' SageMaker IA. A ModelStep nécessite des artefacts du modèle et des informations sur le type d'instance d' SageMaker IA que vous devez utiliser pour créer le modèle. Pour plus d'informations sur les modèles d' SageMaker IA, consultez Entraînez un modèle avec Amazon SageMaker AI.

L'exemple suivant montre comment créer une définition ModelStep.

from sagemaker.workflow.pipeline_context import PipelineSession
from sagemaker.model import Model
from sagemaker.workflow.model_step import ModelStep

step_train = TrainingStep(...)
model = Model(
    image_uri=pytorch_estimator.training_image_uri(),
    model_data=step_train.properties.ModelArtifacts.S3ModelArtifacts,
    sagemaker_session=PipelineSession(),
    role=role,
)

step_model_create = ModelStep(
   name="MyModelCreationStep",
   step_args=model.create(instance_type="ml.m5.xlarge"),
)

Enregistrement d'un modèle

Vous pouvez utiliser a ModelStep pour enregistrer un sagemaker.model.Model ou un dans sagemaker.pipeline.PipelineModel l'Amazon SageMaker Model Registry. Un PipelineModel représente un pipeline d'inférence, qui est un modèle composé d'une séquence linéaire de conteneurs qui traitent les demandes d'inférence. Pour savoir comment enregistrer un modèle, veuillez consulter Déploiement de l'enregistrement des modèles avec le registre des modèles.

L'exemple suivant montre comment créer une ModelStep qui enregistre un PipelineModel.

import time

from sagemaker.workflow.pipeline_context import PipelineSession
from sagemaker.sklearn import SKLearnModel
from sagemaker.xgboost import XGBoostModel

pipeline_session = PipelineSession()

code_location = 's3://{0}/{1}/code'.format(bucket_name, prefix)

sklearn_model = SKLearnModel(
   model_data=processing_step.properties.ProcessingOutputConfig.Outputs['model'].S3Output.S3Uri,
   entry_point='inference.py',
   source_dir='sklearn_source_dir/',
   code_location=code_location,
   framework_version='1.0-1',
   role=role,
   sagemaker_session=pipeline_session,
   py_version='py3'
)

xgboost_model = XGBoostModel(
   model_data=training_step.properties.ModelArtifacts.S3ModelArtifacts,
   entry_point='inference.py',
   source_dir='xgboost_source_dir/',
   code_location=code_location,
   framework_version='0.90-2',
   py_version='py3',
   sagemaker_session=pipeline_session,
   role=role
)

from sagemaker.workflow.model_step import ModelStep
from sagemaker import PipelineModel

pipeline_model = PipelineModel(
   models=[sklearn_model, xgboost_model],
   role=role,sagemaker_session=pipeline_session,
)

register_model_step_args = pipeline_model.register(
    content_types=["application/json"],
   response_types=["application/json"],
   inference_instances=["ml.t2.medium", "ml.m5.xlarge"],
   transform_instances=["ml.m5.xlarge"],
   model_package_group_name='sipgroup',
)

step_model_registration = ModelStep(
   name="AbaloneRegisterModel",
   step_args=register_model_step_args,
)

Vous utilisez l'étape Créer un modèle pour créer un modèle d' SageMaker IA. Pour plus d'informations sur les modèles d' SageMaker IA, consultezEntraînez un modèle avec Amazon SageMaker.

Une étape de création de modèle nécessite des artefacts de modèle et des informations sur le type d'instance d' SageMaker IA que vous devez utiliser pour créer le modèle. Les exemples suivants montrent comment créer une définition d'étape Create model. Pour plus d'informations sur les exigences relatives aux étapes de création d'un modèle, consultez le document sagemaker.workflow.steps. CreateModelStepdocumentation.

L'étape Enregistrer un modèle enregistre un modèle dans le registre des SageMaker modèles.

Dans le concepteur de pipeline, utilisez l'étape Déployer le modèle (point de terminaison) pour déployer votre modèle sur un point de terminaison. Vous pouvez créer un nouveau point de terminaison ou utiliser un point de terminaison existant. L'inférence en temps réel est idéale pour les charges de travail d'inférence où vous avez des exigences en temps réel, interactives et à faible latence. Vous pouvez déployer votre modèle sur les services d'hébergement SageMaker AI et obtenir un point de terminaison en temps réel qui peut être utilisé à des fins d'inférence. Ces points de terminaison sont entièrement gérés et prennent en charge l'auto-scaling. Pour en savoir plus sur l'inférence en temps réel dans l' SageMaker IA, consultezInférence en temps réel.

Avant d'ajouter une étape du modèle de déploiement à votre pipeline, assurez-vous que votre IAM rôle dispose des autorisations suivantes :

Pour en savoir plus sur toutes les autorisations requises pour l' SageMaker IA et sur la façon de les configurer, consultezAPIAutorisations Amazon SageMaker AI : référence sur les actions, les autorisations et les ressources.

Pour ajouter une étape de déploiement du modèle à votre pipeline dans l' drag-and-dropéditeur, procédez comme suit :

Pour exécuter des inférences sur un jeu de données entier, vous utilisez une étape de transformation pour une transformation par lots. Pour plus d'informations sur la transformation par lots, veuillez consulter Transformations par lots à l'aide de pipelines d'inférence.

Une étape de transformation nécessite un transformateur et les données sur lesquelles exécuter la transformation par lots. L'exemple suivant montre comment créer une définition d'étape de transformation. Pour plus d'informations sur les exigences relatives aux étapes de transformation, consultez le document sagemaker.workflow.steps. TransformStepdocumentation.

Vous utilisez une étape de condition pour évaluer la condition des propriétés de l'étape afin d'évaluer quelle action doit être effectuée ensuite dans le pipeline.

Une étape de condition nécessite :

Utilisez une Callback étape pour ajouter à votre flux de travail des processus et AWS des services supplémentaires qui ne sont pas directement fournis par Amazon SageMaker Pipelines. Lorsqu'une étape de Callback s'exécute, la procédure suivante se produit :

Pour plus d'informations sur les exigences relatives aux Callback étapes, consultez le document sagemaker.workflow.callback_step. CallbackStepdocumentation. Pour une solution complète, voir Étendre les SageMaker pipelines pour inclure des étapes personnalisées à l'aide d'étapes de rappel.

L'exemple suivant montre une implémentation de la procédure précédente.

from sagemaker.workflow.callback_step import CallbackStep

step_callback = CallbackStep(
    name="MyCallbackStep",
    sqs_queue_url="https://sqs.us-east-2.amazonaws.com/012345678901/MyCallbackQueue",
    inputs={...},
    outputs=[...]
)

callback_handler_code = '
    import boto3
    import json

    def handler(event, context):
        sagemaker_client=boto3.client("sagemaker")

        for record in event["Records"]:
            payload=json.loads(record["body"])
            token=payload["token"]

            # Custom processing

            # Call SageMaker AI to complete the step
            sagemaker_client.send_pipeline_execution_step_success(
                CallbackToken=token,
                OutputParameters={...}
            )
'

Comportement d'arrêt

Un processus de pipeline ne s'arrête pas lorsqu'une étape de Callback est en cours d'exécution.

Lorsque vous faites appel StopPipelineExecutionà un processus de pipeline comportant une Callback étape en cours d'exécution, Pipelines envoie un SQS message Amazon à la SQS file d'attente. Le corps du SQS message contient un champ Status, défini surStopping. Voici un exemple de corps de SQS message.

{
  "token": "26vcYbeWsZ",
  "pipelineExecutionArn": "arn:aws:sagemaker:us-east-2:012345678901:pipeline/callback-pipeline/execution/7pinimwddh3a",
  "arguments": {
    "number": 5,
    "stringArg": "some-arg",
    "inputData": "s3://sagemaker-us-west-2-012345678901/abalone/abalone-dataset.csv"
  },
  "status": "Stopping"
}

Vous devez inciter votre destinataire de SQS messages Amazon à prendre toutes les mesures nécessaires (par exemple, nettoyer les ressources) dès réception du message. Ajoutez ensuite un appel à SendPipelineExecutionStepSuccess ouSendPipelineExecutionStepFailure.

Ce n'est que lorsque Pipelines reçoit l'un de ces appels qu'il arrête le processus de pipeline.

Vous utilisez une étape Lambda pour exécuter une AWS Lambda fonction. Vous pouvez exécuter une fonction Lambda existante, ou l' SageMaker IA peut créer et exécuter une nouvelle fonction Lambda. Pour un bloc-notes expliquant comment utiliser une étape Lambda dans un pipeline d' SageMaker IA, consultez sagemaker-pipelines-lambda-step .ipynb.

SageMaker L'IA fournit la classe SageMaker.Lambda_Helper.Lambda pour créer, mettre à jour, invoquer et supprimer des fonctions Lambda. Lambdaporte la signature suivante.

Lambda(
    function_arn,       # Only required argument to invoke an existing Lambda function

    # The following arguments are required to create a Lambda function:
    function_name,
    execution_role_arn,
    zipped_code_dir,    # Specify either zipped_code_dir and s3_bucket, OR script
    s3_bucket,          # S3 bucket where zipped_code_dir is uploaded
    script,             # Path of Lambda function script
    handler,            # Lambda handler specified as "lambda_script.lambda_handler"
    timeout,            # Maximum time the Lambda function can run before the lambda step fails
    ...
)

Le sagemaker.workflow.lambda_step. LambdaStepla classe a un lambda_func argument de typeLambda. Pour appeler une fonction Lambda existante, la seule exigence est de fournir le nom de ressource Amazon (ARN) de la fonction à. function_arn Si vous ne définissez aucune valeur pour function_arn, vous devez spécifier handler et l'un des éléments suivants :

L'exemple suivant montre comment créer une définition d'étape Lambda qui appelle une fonction Lambda existante.

from sagemaker.workflow.lambda_step import LambdaStep
from sagemaker.lambda_helper import Lambda

step_lambda = LambdaStep(
    name="ProcessingLambda",
    lambda_func=Lambda(
        function_arn="arn:aws:lambda:us-west-2:012345678910:function:split-dataset-lambda"
    ),
    inputs={
        s3_bucket = s3_bucket,
        data_file = data_file
    },
    outputs=[
        "train_file", "test_file"
    ]
)

L'exemple suivant montre comment créer une définition d'étape Lambda qui appelle une fonction Lambda existante.

from sagemaker.workflow.lambda_step import LambdaStep
from sagemaker.lambda_helper import Lambda

step_lambda = LambdaStep(
    name="ProcessingLambda",
    lambda_func=Lambda(
      function_name="split-dataset-lambda",
      execution_role_arn=execution_role_arn,
      script="lambda_script.py",
      handler="lambda_script.lambda_handler",
      ...
    ),
    inputs={
        s3_bucket = s3_bucket,
        data_file = data_file
    },
    outputs=[
        "train_file", "test_file"
    ]
)

Entrées et sorties

Si votre fonction Lambda a des entrées ou des sorties, elles doivent également être définies dans votre étape Lambda.

Lors de la définition de l'étape Lambda, inputs doit être un dictionnaire de paires clé-valeur. Chaque valeur du dictionnaire inputs doit être de type primitif (chaîne, entier ou flottante). Les objets imbriqués ne sont pas pris en charge. Si elle n'est pas définie, la valeur inputs est définie par défaut sur None.

La valeur outputs doit être une liste de clés. Ces clés font référence à un dictionnaire défini dans la sortie de la fonction Lambda. Comme inputs, ces clés doivent être de type primitif et les objets imbriqués ne sont pas pris en charge.

Délai d'expiration et comportement d'arrêt

La classe Lambda a un argument timeout qui spécifie la durée maximale d'exécution de la fonction Lambda. La valeur par défaut est de 120 secondes, avec une valeur maximum de 10 minutes. Si la fonction Lambda est en cours d'exécution lorsque le délai d'expiration est atteint, l'étape Lambda échoue. Cependant, la fonction Lambda continue de s'exécuter.

Un processus de pipeline ne peut pas être arrêté pendant qu'une étape Lambda est en cours d'exécution, car la fonction Lambda invoquée par l'étape Lambda ne peut pas être arrêtée. Si vous arrêtez le processus alors que la fonction Lambda est en cours d'exécution, le pipeline attend que la fonction se termine ou que le délai d'expiration soit atteint. Cela dépend de ce qui se produit en premier. Le processus s'arrête alors. Si la fonction Lambda se termine, le statut de processus du pipeline est Stopped. Si le délai d'expiration est atteint, le statut de processus du pipeline est Failed.

Vous pouvez utiliser l'étape ClarifyCheck afin d'effectuer des vérifications de dérive de référence par rapport aux références précédentes pour l'analyse de biais et l'explicabilité de modèle. Vous pouvez ensuite générer et enregistrer vos références avec le model.register() et transmettre la sortie de cette méthode à Étape du modèle en utilisant step_args. Ces lignes de base pour le contrôle de dérive peuvent être utilisées par Amazon SageMaker Model Monitor pour les points de terminaison de votre modèle. Par conséquent, il n'est pas nécessaire de faire une suggestion de référence séparément.

L'étape ClarifyCheck peut également extraire des références pour la vérification de dérive à partir du registre des modèles. L'ClarifyCheckétape utilise le conteneur préconstruit SageMaker Clarify. Ce conteneur fournit une gamme de fonctionnalités de surveillance des modèles, notamment la suggestion de contraintes et la validation des contraintes par rapport à une référence donnée. Pour de plus amples informations, veuillez consulter Conteneurs SageMaker Clarify préfabriqués.

Configuration de l' ClarifyCheck étape

Vous pouvez configurer l'étape ClarifyCheck pour effectuer l'un des types de vérification suivants chaque fois qu'il est utilisé dans un pipeline.

Pour ce faire, définissez le clarify_check_config paramètre avec l'une des valeurs de type de contrôle suivantes :

L'ClarifyCheckétape lance une tâche de traitement qui exécute le conteneur SageMaker prédéfini AI Clarify et nécessite des configurations dédiées pour la vérification et la tâche de traitement. ClarifyCheckConfiget CheckJobConfig sont des fonctions d'assistance pour ces configurations. Ces fonctions d'assistance sont alignées sur la façon dont la tâche de traitement SageMaker Clarify calcule pour vérifier le biais du modèle, le biais des données ou l'explicabilité du modèle. Pour de plus amples informations, veuillez consulter Exécutez des tâches de traitement SageMaker Clarify pour l'analyse des biais et l'explicabilité.

Contrôle des comportements d'étape pour la vérification de dérive

L'étape ClarifyCheck nécessite les deux indicateurs booléens suivants pour le contrôle de son comportement :

Pour de plus amples informations, veuillez consulter Calcul de référence, détection de la dérive et cycle de vie avec Amazon SageMaker Pipelines ClarifyCheck et QualityCheck étapes.

Utilisation des références

Vous pouvez éventuellement spécifier le model_package_group_name pour localiser la ligne de base existante. Ensuite, l'ClarifyCheckétape active DriftCheckBaselines le dernier modèle de package approuvé dans le groupe de modèles de packages.

Vous pouvez également fournir une référence précédente via le paramètre supplied_baseline_constraints. Si vous spécifiez le model_package_group_name et les supplied_baseline_constraints, l'étape ClarifyCheck utilise la référence spécifiée par le paramètre supplied_baseline_constraints.

Pour plus d'informations sur l'utilisation des exigences relatives aux ClarifyCheck étapes, consultez le document sagemaker.workflow.steps. ClarifyCheckStepdans l' SageMaker SageMaker IA d'Amazon SDK pour Python. Pour un bloc-notes Amazon SageMaker Studio Classic expliquant comment utiliser ClarifyCheck step dans Pipelines, consultez sagemaker-pipeline-model-monitor-clarify-steps.ipynb.

from sagemaker.workflow.check_job_config import CheckJobConfig
from sagemaker.workflow.clarify_check_step import DataBiasCheckConfig, ClarifyCheckStep
from sagemaker.workflow.execution_variables import ExecutionVariables

check_job_config = CheckJobConfig(
    role=role,
    instance_count=1,
    instance_type="ml.c5.xlarge",
    volume_size_in_gb=120,
    sagemaker_session=sagemaker_session,
)

data_bias_data_config = DataConfig(
    s3_data_input_path=step_process.properties.ProcessingOutputConfig.Outputs["train"].S3Output.S3Uri,
    s3_output_path=Join(on='/', values=['s3:/', your_bucket, base_job_prefix, ExecutionVariables.PIPELINE_EXECUTION_ID, 'databiascheckstep']),
    label=0,
    dataset_type="text/csv",
    s3_analysis_config_output_path=data_bias_analysis_cfg_output_path,
)

data_bias_config = BiasConfig(
    label_values_or_threshold=[15.0], facet_name=[8], facet_values_or_threshold=[[0.5]]  
)

data_bias_check_config = DataBiasCheckConfig(
    data_config=data_bias_data_config,
    data_bias_config=data_bias_config,
)h

data_bias_check_step = ClarifyCheckStep(
    name="DataBiasCheckStep",
    clarify_check_config=data_bias_check_config,
    check_job_config=check_job_config,
    skip_check=False,
    register_new_baseline=False
   supplied_baseline_constraints="s3://sagemaker-us-west-2-111122223333/baseline/analysis.json",
    model_package_group_name="MyModelPackageGroup"
)

Utilisez cette QualityCheck étape pour effectuer des suggestions de référence et des vérifications de dérive par rapport à une référence précédente pour vérifier la qualité des données ou la qualité du modèle dans un pipeline. Vous pouvez ensuite générer et enregistrer vos lignes de base avec la model.register() méthode et transmettre le résultat de cette méthode à Étape du modèle l'utilisationstep_args.]

Model Monitor peut utiliser ces références pour la vérification de dérive pour les points de terminaison de votre modèle, de sorte que vous n'avez pas besoin d'effectuer une suggestion de référence séparément. L'étape QualityCheck peut également extraire des références pour la vérification de dérive à partir du registre des modèles. Cette QualityCheck étape utilise le conteneur prédéfini Amazon SageMaker AI Model Monitor. Ce conteneur dispose d'une gamme de fonctionnalités de surveillance des modèles, notamment la suggestion de contraintes, la génération de statistiques et la validation des contraintes par rapport à une base de référence. Pour de plus amples informations, veuillez consulter Conteneur préfabriqué Amazon SageMaker Model Monitor.

Configuration de l' QualityCheck étape

Vous pouvez configurer l'QualityCheckétape pour exécuter uniquement l'un des types de vérification suivants chaque fois qu'elle est utilisée dans un pipeline.

Pour ce faire, définissez le paramètre quality_check_config avec l'une des valeurs de type de vérification suivantes :

L'étape QualityCheck lance une tâche de traitement qui exécute le conteneur prédéfini Model Monitor et nécessite des configurations dédiées pour la vérification et la tâche de traitement. Les fonctions QualityCheckConfig et CheckJobConfig sont des fonctions d'assistance pour ces configurations. Ces fonctions d'assistance sont conformes à la manière dont Model Monitor crée une base de référence pour la surveillance de la qualité du modèle ou de la qualité des données. Pour plus d'informations sur les suggestions de référence Model Monitor, veuillez consulter Création d'une référence et Création d'une référence de qualité du modèle.

Contrôle des comportements d'étape pour la vérification de dérive

L'étape QualityCheck nécessite les deux indicateurs booléens suivants pour le contrôle de son comportement :

Pour de plus amples informations, veuillez consulter Calcul de référence, détection de la dérive et cycle de vie avec Amazon SageMaker Pipelines ClarifyCheck et QualityCheck étapes.

Utilisation des références

Vous pouvez spécifier une ligne de base précédente directement via les supplied_baseline_constraints paramètres supplied_baseline_statistics et. Vous pouvez également spécifier model_package_group_name et l'QualityCheckétape extrait DriftCheckBaselines le dernier modèle de package approuvé dans le groupe de modèles de packages.

Lorsque vous spécifiez ce qui suit, l'QualityCheckétape utilise la ligne de base spécifiée par supplied_baseline_constraints et supplied_baseline_statistics sur le type de vérification de l'QualityCheckétape.

Pour plus d'informations sur l'utilisation des exigences relatives aux QualityCheck étapes, consultez le document sagemaker.workflow.steps. QualityCheckStepdans l' SageMaker SageMaker IA d'Amazon SDK pour Python. Pour un bloc-notes Amazon SageMaker Studio Classic expliquant comment utiliser QualityCheck step dans Pipelines, consultez sagemaker-pipeline-model-monitor-clarify-steps.ipynb.

from sagemaker.workflow.check_job_config import CheckJobConfig
from sagemaker.workflow.quality_check_step import DataQualityCheckConfig, QualityCheckStep
from sagemaker.workflow.execution_variables import ExecutionVariables

check_job_config = CheckJobConfig(
    role=role,
    instance_count=1,
    instance_type="ml.c5.xlarge",
    volume_size_in_gb=120,
    sagemaker_session=sagemaker_session,
)

data_quality_check_config = DataQualityCheckConfig(
    baseline_dataset=step_process.properties.ProcessingOutputConfig.Outputs["train"].S3Output.S3Uri,
    dataset_format=DatasetFormat.csv(header=False, output_columns_position="START"),
    output_s3_uri=Join(on='/', values=['s3:/', your_bucket, base_job_prefix, ExecutionVariables.PIPELINE_EXECUTION_ID, 'dataqualitycheckstep'])
)

data_quality_check_step = QualityCheckStep(
    name="DataQualityCheckStep",
    skip_check=False,
    register_new_baseline=False,
    quality_check_config=data_quality_check_config,
    check_job_config=check_job_config,
    supplied_baseline_statistics="s3://sagemaker-us-west-2-555555555555/baseline/statistics.json",
    supplied_baseline_constraints="s3://sagemaker-us-west-2-555555555555/baseline/constraints.json",
    model_package_group_name="MyModelPackageGroup"
)

Utilisez l'EMRétape Amazon SageMaker Pipelines pour :

Pour plus d'informations sur AmazonEMR, consultez Getting started with Amazon EMR.

Cette EMR étape nécessite d'EMRStepConfiginclure l'emplacement du JAR fichier utilisé par le EMR cluster Amazon et tous les arguments à transmettre. Vous devez également fournir l'identifiant du EMR cluster Amazon si vous souhaitez exécuter l'étape sur un EMR cluster en cours d'exécution. Vous pouvez également transmettre la configuration du cluster pour exécuter l'EMRétape sur un cluster qu'il crée, gère et arrête pour vous. Les sections suivantes incluent des exemples et des liens vers des exemples de blocs-notes illustrant les deux méthodes.

Lancer une nouvelle tâche sur un EMR cluster Amazon en cours d'exécution

Pour lancer une nouvelle tâche sur un EMR cluster Amazon en cours d'exécution, transmettez l'ID du cluster sous forme de chaîne à l'cluster_idargument deEMRStep. L'exemple suivant illustre cette procédure.

from sagemaker.workflow.emr_step import EMRStep, EMRStepConfig

emr_config = EMRStepConfig(
    jar="jar-location", # required, path to jar file used
    args=["--verbose", "--force"], # optional list of arguments to pass to the jar
    main_class="com.my.Main1", # optional main class, this can be omitted if jar above has a manifest 
    properties=[ # optional list of Java properties that are set when the step runs
    {
        "key": "mapred.tasktracker.map.tasks.maximum",
        "value": "2"
    },
    {
        "key": "mapreduce.map.sort.spill.percent",
        "value": "0.90"
   },
   {
       "key": "mapreduce.tasktracker.reduce.tasks.maximum",
       "value": "5"
    }
  ]
)

step_emr = EMRStep (
    name="EMRSampleStep", # required
    cluster_id="j-1ABCDEFG2HIJK", # include cluster_id to use a running cluster
    step_config=emr_config, # required
    display_name="My EMR Step",
    description="Pipeline step to execute EMR job"
)

Pour un exemple de bloc-notes qui vous guide à travers un exemple complet, voir Pipelines EMR Step With Running EMR Cluster.

Lancer une nouvelle tâche sur un nouveau EMR cluster Amazon

Pour lancer une nouvelle tâche sur un nouveau cluster EMRStep créé pour vous, fournissez la configuration de votre cluster sous forme de dictionnaire. Le dictionnaire doit avoir la même structure qu'une RunJobFlowdemande. Toutefois, n'incluez pas les champs suivants dans la configuration de votre cluster :

Tous les autres arguments RunJobFlow peuvent être utilisés dans votre configuration de cluster. Pour plus de détails sur la syntaxe des demandes, consultez RunJobFlow.

L'exemple suivant transmet une configuration de cluster à une définition d'EMRétape. Cela indique l'étape de lancement d'une nouvelle tâche sur un nouveau EMR cluster. Dans cet exemple, la configuration du EMR cluster inclut des spécifications pour les nœuds de EMR cluster principaux et principaux. Pour plus d'informations sur les types de EMR nœuds Amazon, consultez Comprendre les types de nœuds : nœuds principaux, principaux et de tâches.

from sagemaker.workflow.emr_step import EMRStep, EMRStepConfig

emr_step_config = EMRStepConfig(
    jar="jar-location", # required, path to jar file used
    args=["--verbose", "--force"], # optional list of arguments to pass to the jar
    main_class="com.my.Main1", # optional main class, this can be omitted if jar above has a manifest 
    properties=[ # optional list of Java properties that are set when the step runs
    {
        "key": "mapred.tasktracker.map.tasks.maximum",
        "value": "2"
    },
    {
        "key": "mapreduce.map.sort.spill.percent",
        "value": "0.90"
   },
   {
       "key": "mapreduce.tasktracker.reduce.tasks.maximum",
       "value": "5"
    }
  ]
)

# include your cluster configuration as a dictionary
emr_cluster_config = {
    "Applications": [
        {
            "Name": "Spark", 
        }
    ],
    "Instances":{
        "InstanceGroups":[
            {
                "InstanceRole": "MASTER",
                "InstanceCount": 1,
                "InstanceType": "m5.2xlarge"
            },
            {
                "InstanceRole": "CORE",
                "InstanceCount": 2,
                "InstanceType": "m5.2xlarge"
            }
        ]
    },
    "BootstrapActions":[],
    "ReleaseLabel": "emr-6.6.0",
    "JobFlowRole": "job-flow-role",
    "ServiceRole": "service-role"
}

emr_step = EMRStep(
    name="emr-step",
    cluster_id=None,
    display_name="emr_step",
    description="MyEMRStepDescription",
    step_config=emr_step_config,
    cluster_config=emr_cluster_config
)

Pour un exemple de bloc-notes qui vous guide à travers un exemple complet, voir Pipelines EMR Step With Cluster Lifecycle Management.

Utilisez a NotebookJobStep pour exécuter votre SageMaker Notebook Job de manière non interactive en tant qu'étape du pipeline. Si vous créez votre pipeline dans l' drag-and-dropinterface utilisateur de Pipelines, utilisez-le Exécuter l'étape de code pour exécuter votre bloc-notes. Pour plus d'informations sur SageMaker Notebook Jobs, consultezSageMaker Emplois sur ordinateur portable.

A NotebookJobStep nécessite au minimum un bloc-notes d'entrée, une image URI et un nom de noyau. Pour plus d'informations sur les exigences relatives aux étapes de Notebook Job et sur les autres paramètres que vous pouvez définir pour personnaliser votre étape, consultez sagemaker.workflow.steps. NotebookJobStep.

L'exemple suivant utilise un minimum d'arguments pour définir unNotebookJobStep.

from sagemaker.workflow.notebook_job_step import NotebookJobStep


notebook_job_step = NotebookJobStep(
    input_notebook=input_notebook,
    image_uri=image_uri,
    kernel_name=kernel_name
)

L'étape de votre NotebookJobStep pipeline est traitée comme une tâche de SageMaker carnet. Par conséquent, suivez l'état d'exécution dans le tableau de bord des tâches du bloc-notes de l'interface utilisateur de Studio Classic en incluant des balises spécifiques dans l'tagsargument. Pour plus de détails sur les balises à inclure, consultezConsultez les tâches de votre bloc-notes dans le tableau de bord de l'interface utilisateur de Studio.

De plus, si vous planifiez votre tâche de bloc-notes à l'aide de SageMaker PythonSDK, vous ne pouvez spécifier que certaines images pour exécuter votre tâche de bloc-notes. Pour de plus amples informations, veuillez consulter Contraintes d'image pour les tâches de SDK bloc-notes SageMaker AI Python.

Utilisez une étape d'échec pour arrêter l'exécution d'Amazon SageMaker Pipelines lorsqu'une condition ou un état souhaité n'est pas atteint. L'étape Fail vous permet également de saisir un message d'erreur personnalisé indiquant la cause de l'échec d'exécution du pipeline.

Limitations liées à l'utilisation de l'étape Fail

Vous pouvez créer le message d'erreur de l'étape Fail sous la forme d'une chaîne de texte statique. Vous pouvez également utiliser les paramètres du pipeline, une opération de jointure ou d'autres propriétés d'étape pour créer un message d'erreur plus informatif si vous utilisez leSDK.