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.
# SageMaker Flux de travail d'IA
Au fur et à mesure que vous développez vos opérations d'apprentissage automatique (ML), vous pouvez utiliser les services de flux de travail entièrement gérés d'Amazon SageMaker AI pour mettre en œuvre des pratiques d'intégration et de déploiement continus (CI/CD) pour votre cycle de vie de machine learning. Avec le kit SDK Pipelines, vous choisissez et intégrez les étapes de pipeline dans une solution unifiée qui automatise le processus de génération de modèles, de la préparation des données au déploiement des modèles. Pour les architectures basées sur Kubernetes, vous pouvez installer des opérateurs SageMaker AI sur votre cluster Kubernetes pour créer SageMaker des tâches d'IA de manière native à l'aide de l'API Kubernetes et d'outils Kubernetes en ligne de commande tels que. `kubectl` Grâce aux composants d' SageMaker IA pour les pipelines Kubeflow, vous pouvez créer et surveiller des tâches d' SageMaker IA natives à partir de vos pipelines Kubeflow. Les paramètres, le statut et les résultats des tâches de l' SageMaker IA sont accessibles depuis l'interface utilisateur de Kubeflow Pipelines. Enfin, si vous souhaitez planifier des tâches par lots, vous pouvez utiliser l'intégration de la file d'attente des tâches ou le service de flux de AWS Batch travail basé sur un bloc-notes Jupyter pour lancer des exécutions autonomes ou régulières selon un calendrier que vous définissez.
En résumé, l' SageMaker IA propose les technologies de flux de travail suivantes :
+ [Pipelines](pipelines.md) : outil de création et de gestion de pipelines de machine learning.
+ [Orchestration Kubernetes](kubernetes-workflows.md): opérateurs personnalisés SageMaker basés sur l'IA pour votre cluster Kubernetes et composants pour Kubeflow Pipelines.
+ [SageMaker Emplois sur ordinateur portable](notebook-auto-run.md) : exécutions par lots non interactives à la demande ou planifiées de votre bloc-notes Jupyter.
Vous pouvez également tirer parti d'autres services intégrés à l' SageMaker IA pour créer votre flux de travail. Les options incluent les services suivants :
+ Flux de [travail Airflow](https://sagemaker.readthedocs.io/en/stable/workflows/airflow/index.html) : SageMaker APIs pour exporter des configurations permettant de créer et de gérer des flux de travail Airflow.
+ [AWS Step Functions](https://sagemaker.readthedocs.io/en/stable/workflows/step_functions/index.html): flux de travail ML en plusieurs étapes en Python qui orchestrent l'infrastructure d' SageMaker IA sans avoir à provisionner vos ressources séparément.
+ [AWS Batch](https://docs.aws.amazon.com/batch/latest/userguide/getting-started-sagemaker.html): Soumettez les tâches de formation à l' SageMaker IA à une file d'attente de AWS Batch tâches, où vous pouvez hiérarchiser et planifier les tâches à exécuter dans un environnement informatique.
Pour plus d'informations sur la gestion de la SageMaker formation et de l'inférence, consultez les flux de travail du [SDK Amazon SageMaker Python](https://sagemaker.readthedocs.io/en/stable/workflows/index.html).
**Topics**
+ [Pipelines](pipelines.md)
+ [Orchestration Kubernetes](kubernetes-workflows.md)
+ [SageMaker Emplois sur ordinateur portable](notebook-auto-run.md)
+ [Planification de vos flux de travail ML](workflow-scheduling.md)
+ [AWS Batch soutien aux emplois de formation en SageMaker IA](training-job-queues.md)
# Pipelines
Amazon SageMaker Pipelines est un service d'orchestration de flux de travail spécialement conçu pour automatiser le développement du machine learning (ML).
Les pipelines offrent les avantages suivants par rapport aux autres offres AWS de flux de travail :
**Infrastructure sans serveur à mise à l'échelle automatique** Vous n'avez pas besoin de gérer l'infrastructure d'orchestration sous-jacente pour exécuter Pipelines, ce qui vous permet de vous concentrer sur les tâches principales du ML. SageMaker L'IA provisionne, fait évoluer et arrête automatiquement les ressources informatiques d'orchestration du pipeline en fonction de votre charge de travail de machine learning.
**Expérience utilisateur intuitive** Les pipelines peuvent être créés et gérés via l'interface de votre choix : éditeur visuel APIs, SDK ou JSON. Vous pouvez suivre drag-and-drop les différentes étapes du ML pour créer vos pipelines dans l'interface visuelle d'Amazon SageMaker Studio. La capture d’écran suivante montre l’éditeur visuel Studio pour les pipelines.
![\[Capture d'écran de l' drag-and-dropinterface visuelle de Pipelines in Studio.\]](http://docs.aws.amazon.com/fr_fr/sagemaker/latest/dg/images/pipelines/pipelines-studio-overview.png)
Si vous préférez gérer vos flux de travail ML par programmation, le SDK SageMaker Python propose des fonctionnalités d'orchestration avancées. Pour plus d'informations, consultez [Amazon SageMaker Pipelines](https://sagemaker.readthedocs.io/en/stable/amazon_sagemaker_model_building_pipeline.html) dans la documentation du SDK SageMaker Python.
**AWS intégrations Les** pipelines permettent une intégration fluide avec toutes les fonctionnalités de l' SageMaker IA et les autres AWS services afin d'automatiser le traitement des données, la formation des modèles, le réglage précis, l'évaluation, le déploiement et le suivi des tâches. Vous pouvez intégrer les fonctionnalités d' SageMaker IA dans vos pipelines et les parcourir à l'aide de liens profonds pour créer, surveiller et déboguer vos flux de travail ML à grande échelle.
**Coûts réduits** Avec Pipelines, vous ne payez que pour l'environnement SageMaker Studio et les tâches sous-jacentes orchestrées par Pipelines (par exemple, la SageMaker formation, le SageMaker traitement, l'inférence par l' SageMaker IA et le stockage de données Amazon S3).
**Auditabilité et suivi de la traçabilité** Avec les pipelines, vous pouvez suivre l’historique des mises à jour et des exécutions des pipelines à l’aide de la gestion des versions intégrée. Amazon SageMaker ML Lineage Tracking vous aide à analyser les sources de données et les consommateurs de données au cours du cycle de développement du end-to-end ML.
**Topics**
+ [Présentation des pipelines](pipelines-overview.md)
+ [Actions de pipeline](pipelines-build.md)
# Présentation des pipelines
Un pipeline Amazon SageMaker AI est une série d'étapes interconnectées dans un graphe acyclique dirigé (DAG) définies à l'aide de l' drag-and-dropinterface utilisateur ou du [SDK Pipelines](https://sagemaker.readthedocs.io/en/stable/workflows/pipelines/sagemaker.workflow.pipelines.html). Vous pouvez également générer votre pipeline à l’aide du [schéma JSON de définition de pipeline](https://aws-sagemaker-mlops.github.io/sagemaker-model-building-pipeline-definition-JSON-schema/). Cette définition JSON de graphique DAG fournit des informations sur les exigences de chaque étape de votre pipeline et les relations entre ces étapes. La structure du DAG d’un pipeline est déterminée par les dépendances de données entre les étapes. Ces dépendances de données sont créées lorsque les propriétés de la sortie d'une étape sont passées en tant qu'entrée à une autre étape. L’image suivante est un exemple de DAG de pipeline :
![\[\]](http://docs.aws.amazon.com/fr_fr/sagemaker/latest/dg/images/pipeline-full.png)
**Cet exemple de graphique DAG comprend les étapes suivantes :**
1. `AbaloneProcess`, une instance de l’étape [Traitement](https://docs.aws.amazon.com/sagemaker/latest/dg/build-and-manage-steps.html#step-type-processing), exécute un script de prétraitement sur les données utilisées pour l’entraînement. Par exemple, le script peut remplir les valeurs manquantes, normaliser les données numériques ou diviser les données entre les jeux de données d’entraînement, de validation et de test.
1. `AbaloneTrain`, une instance de l’étape [Entraînement](https://docs.aws.amazon.com/sagemaker/latest/dg/build-and-manage-steps.html#step-type-training), configure les hyperparamètres et entraîne un modèle à partir des données d’entrée prétraitées.
1. `AbaloneEval`, une autre instance de l’étape [Traitement](https://docs.aws.amazon.com/sagemaker/latest/dg/build-and-manage-steps.html#step-type-processing), évalue l’exactitude du modèle. Cette étape montre un exemple de dépendance des données : elle utilise la sortie du jeu de données de test de `AbaloneProcess`.
1. `AbaloneMSECond`est une instance d'une étape [Condition](https://docs.aws.amazon.com/sagemaker/latest/dg/build-and-manage-steps.html#step-type-condition) qui, dans cet exemple, vérifie que le mean-square-error résultat de l'évaluation du modèle est inférieur à une certaine limite. Si le modèle ne répond pas aux critères, l’exécution du pipeline s’arrête.
1. L’exécution du pipeline continue avec les étapes suivantes :
1. `AbaloneRegisterModel`, où SageMaker AI lance une [RegisterModel](https://docs.aws.amazon.com/sagemaker/latest/dg/build-and-manage-steps.html#step-type-register-model)étape pour enregistrer le modèle en tant que groupe de packages de modèles versionnés dans l'Amazon SageMaker Model Registry.
1. `AbaloneCreateModel`, où l' SageMaker IA appelle une [CreateModel](https://docs.aws.amazon.com/sagemaker/latest/dg/build-and-manage-steps.html#step-type-create-model)étape pour créer le modèle en vue de la transformation par lots. Dans`AbaloneTransform`, SageMaker AI appelle une étape de [transformation](https://docs.aws.amazon.com/sagemaker/latest/dg/build-and-manage-steps.html#step-type-transform) pour générer des prédictions de modèle sur un ensemble de données que vous spécifiez.
Les rubriques suivantes décrivent les concepts fondamentaux des pipelines. Pour obtenir un tutoriel décrivant l’implémentation de ces concepts, consultez [Actions de pipeline](pipelines-build.md).
**Topics**
+ [Structure et exécution du pipeline](build-and-manage-pipeline.md)
+ [Gestion d'accès IAM](build-and-manage-access.md)
+ [Configuration de la prise en charge entre comptes pour Pipelines](build-and-manage-xaccount.md)
+ [Paramètres du pipeline](build-and-manage-parameters.md)
+ [Étapes du pipeline](build-and-manage-steps.md)
+ [Lift-and-shift Code Python avec le décorateur @step](pipelines-step-decorator.md)
+ [Transmission de données entre les étapes](build-and-manage-propertyfile.md)
+ [Mise en cache des étapes du pipeline](pipelines-caching.md)
+ [Politique de nouvelle tentative pour les étapes du pipeline](pipelines-retry-policy.md)
+ [Exécution sélective des étapes d’un pipeline](pipelines-selective-ex.md)
+ [Calcul de référence, détection de la dérive et cycle de vie avec Amazon SageMaker Pipelines ClarifyCheck et QualityCheck étapes](pipelines-quality-clarify-baseline-lifecycle.md)
+ [Planification d’exécutions d’un pipeline](pipeline-eventbridge.md)
+ [Amazon SageMaker expérimente l'intégration](pipelines-experiments.md)
+ [Exécution de pipelines en mode local](pipelines-local-mode.md)
+ [Résolution des problèmes liés à Amazon SageMaker Pipelines](pipelines-troubleshooting.md)
# Structure et exécution du pipeline
**Topics**
+ [Structure du pipeline](#build-and-manage-pipeline-structure)
+ [Exécution de pipelines à l’aide de la configuration de parallélisme](#build-and-manage-pipeline-execution)
## Structure du pipeline
Une instance Amazon SageMaker Pipelines est composée d'un `name``parameters`, et`steps`. Les noms des pipelines doivent être uniques au sein d’une paire `(account, region)`. Tous les paramètres utilisés dans les définitions d’étapes doivent être définis dans le pipeline. Les étapes du pipeline répertoriées déterminent automatiquement leur ordre d’exécution en fonction de leurs dépendances de données les unes par rapport aux autres. Le service Pipelines résout les relations entre les étapes présentes dans le graphique DAG de dépendance des données afin de créer une série d’étapes que l’exécution effectue. Voici un exemple de structure de pipeline.
**Avertissement**
Lorsque vous créez un pipeline via l'éditeur visuel ou le SDK SageMaker AI Python, n'incluez aucune information sensible dans les paramètres du pipeline ni dans aucun champ de définition d'étape (comme les variables d'environnement). Ces champs seront visibles à l’avenir lorsqu’ils seront renvoyés dans une demande `DescribePipeline`.
```
from sagemaker.workflow.pipeline import Pipeline
pipeline_name = f"AbalonePipeline"
pipeline = Pipeline(
name=pipeline_name,
parameters=[
processing_instance_type,
processing_instance_count,
training_instance_type,
model_approval_status,
input_data,
batch_data,
],
steps=[step_process, step_train, step_eval, step_cond],
)
```
## Exécution de pipelines à l’aide de la configuration de parallélisme
Par défaut, un pipeline effectue toutes les étapes pouvant être exécutées en parallèle. Vous pouvez contrôler ce comportement à l'aide de la propriété `ParallelismConfiguration` lors de la création ou de la mise à jour d'un pipeline, ainsi que lors du démarrage ou de la nouvelle tentative d'exécution d'un pipeline.
Les configurations de parallélisme sont appliquées par exécution. Par exemple, si deux exécutions sont démarrées, elles peuvent chacune exécuter un maximum de 50 étapes simultanément, pour un total de 100 étapes exécutées simultanément. De plus, la ou les `ParallelismConfiguration`(s) spécifiées lors du démarrage, de la nouvelle tentative ou de la mise à jour d'une exécution sont prioritaires par rapport aux configurations de parallélisme définies dans le pipeline.
**Example Création d’une exécution de pipeline avec `ParallelismConfiguration`**
```
pipeline = Pipeline(
name="myPipeline",
steps=[step_process, step_train]
)
pipeline.create(role, parallelism_config={"MaxParallelExecutionSteps": 50})
```
# Gestion d'accès IAM
Les sections suivantes décrivent les exigences Gestion des identités et des accès AWS (IAM) pour Amazon SageMaker Pipelines. Pour obtenir un exemple de la façon dont vous pouvez implémenter ces autorisations, consultez [Conditions préalables](define-pipeline.md#define-pipeline-prereq).
**Topics**
+ [Autorisations de rôle de pipeline](#build-and-manage-role-permissions)
+ [Autorisations d’étape de pipeline](#build-and-manage-step-permissions)
+ [Configuration CORS avec des compartiments Amazon S3](#build-and-manage-cors-s3)
+ [Personnalisation de la gestion des accès pour les tâches de pipelines](#build-and-manage-step-permissions-prefix)
+ [Personnalisation de l’accès aux versions d’un pipeline](#build-and-manage-step-permissions-version)
+ [Politiques de contrôle des services avec les pipelines](#build-and-manage-scp)
## Autorisations de rôle de pipeline
Votre pipeline nécessite un rôle d'exécution de pipeline IAM qui est transmis à Pipelines lorsque vous créez un pipeline. Le rôle de l'instance d' SageMaker IA que vous utilisez pour créer le pipeline doit avoir une politique avec l'`iam:PassRole`autorisation qui spécifie le rôle d'exécution du pipeline. Cela est dû au fait que l'instance a besoin d'une autorisation pour transmettre votre rôle d'exécution de pipeline au service Pipelines afin de l'utiliser pour créer et exécuter des pipelines. Pour plus d’informations sur les rôles IAM, consultez [Rôles IAM](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_roles.html).
Votre rôle d’exécution de pipeline nécessite les autorisations suivantes :
+ Vous pouvez utiliser un rôle unique ou personnalisé pour chacune des étapes d'une tâche d' SageMaker IA de votre pipeline (plutôt que le rôle d'exécution du pipeline, qui est utilisé par défaut). Assurez-vous que votre rôle d'exécution de pipeline a ajouté une politique avec l'`iam:PassRole`autorisation qui spécifie chacun de ces rôles.
+ Les autorisations `Create` et `Describe` pour chacun des types de tâches dans le pipeline.
+ Autorisations Amazon S3 pour l'utilisation de la fonction `JsonGet`. Vous contrôlez l’accès à vos ressources Amazon S3 à l’aide de politiques basées sur les ressources et de politiques basées sur l’identité. Une politique basée sur les ressources est appliquée à votre compartiment Amazon S3 et accorde à Pipelines l’accès au compartiment. Une politique basée sur l’identité permet à votre pipeline de passer des appels Amazon S3 à partir de votre compte. Pour plus d’informations sur les politiques basées sur l’identité et les politiques basées sur les ressources, consultez [Politiques basées sur l’identité et politiques basées sur une ressource](https://docs.aws.amazon.com/IAM/latest/UserGuide/access_policies_identity-vs-resource.html).
```
{
"Action": [
"s3:GetObject"
],
"Resource": "arn:aws:s3:::/*",
"Effect": "Allow"
}
```
## Autorisations d’étape de pipeline
Les pipelines incluent des étapes qui exécutent des tâches d' SageMaker IA. Pour que les étapes de pipeline puissent exécuter ces tâches, elles nécessitent un rôle IAM dans votre compte qui fournit l’accès à la ressource nécessaire. Ce rôle est transmis au responsable du service SageMaker AI par votre pipeline. Pour plus d’informations sur les rôles IAM, consultez [Rôles IAM](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_roles.html).
Par défaut, chaque étape assume le rôle d'exécution du pipeline. Vous pouvez éventuellement transmettre un rôle différent à l'une des étapes de votre pipeline. Cela garantit que le code de chaque étape n'a pas la capacité d'affecter les ressources utilisées dans d'autres étapes, sauf s'il existe une relation directe entre les deux étapes spécifiées dans la définition du pipeline. Vous passez ces rôles lors de la définition du processeur ou de l’estimateur de votre étape. Pour des exemples expliquant comment inclure ces rôles dans ces définitions, consultez la [documentation du SDK SageMaker AI Python](https://sagemaker.readthedocs.io/en/stable/overview.html#using-estimators).
## Configuration CORS avec des compartiments Amazon S3
Pour garantir que vos images sont importées dans vos pipelines à partir d’un compartiment Amazon S3 de manière prévisible, une configuration CORS doit être ajoutée aux compartiments Amazon S3 d’où les images sont importées. Cette section fournit des instructions de définition de la configuration CORS requise pour votre compartiment Amazon S3. L’élément `CORSConfiguration` XML requis pour les pipelines est différent de celui figurant dans [Exigence CORS pour les données d’image d’entrée](sms-cors-update.md), sinon vous pouvez utiliser les informations qui s’y trouvent pour en savoir plus sur l’exigence CORS relative aux compartiments Amazon S3.
Utilisez le code de configuration CORS suivant pour les compartiments Amazon S3 qui hébergent vos images. Pour obtenir des instructions de configuration CORS, consultez [Configuration du partage des ressources entre origines multiples (CORS)](https://docs.aws.amazon.com/AmazonS3/latest/user-guide/add-cors-configuration.html) dans le Guide de l’utilisateur Amazon Simple Storage Service. Si vous utilisez la console Amazon S3 pour ajouter la stratégie à votre compartiment, vous devez utiliser le format JSON.
**JSON**
```
[
{
"AllowedHeaders": [
"*"
],
"AllowedMethods": [
"PUT"
],
"AllowedOrigins": [
"*"
],
"ExposeHeaders": [
"Access-Control-Allow-Origin"
]
}
]
```
**XML**
```
**PUTAccess-Control-Allow-Origin
```
Le fichier GIF suivant présente les instructions contenues dans la documentation Amazon S3 pour ajouter une stratégie d’en-tête CORS à l’aide de la console Amazon S3.
![\[Fichier GIF illustrant comment ajouter une stratégie d’en-tête CORS à l’aide de la console Amazon S3.\]](http://docs.aws.amazon.com/fr_fr/sagemaker/latest/dg/images/sms/gifs/cors-config.gif)
## Personnalisation de la gestion des accès pour les tâches de pipelines
Vous pouvez personnaliser davantage vos politiques IAM afin que les membres sélectionnés de votre organisation puissent exécuter une ou toutes les étapes de pipeline. Par exemple, vous pouvez autoriser certains utilisateurs à créer des tâches d'entraînement, autoriser un autre groupe d'utilisateurs à créer des tâches de traitement et autoriser tous vos utilisateurs à exécuter les étapes restantes. Pour utiliser cette fonctionnalité, vous devez sélectionner une chaîne personnalisée qui préfixe votre nom de tâche. Votre administrateur ajoute le préfixe autorisé ARNs au préfixe tandis que votre data scientist inclut ce préfixe dans les instanciations de pipeline. Étant donné que la politique IAM pour les utilisateurs autorisés contient un ARN de tâche avec le préfixe spécifié, les tâches suivantes de votre étape de pipeline disposent des autorisations nécessaires pour continuer. Le préfixage des tâches est désactivé par défaut. Vous devez activer cette option dans votre classe `Pipeline` pour pouvoir l'utiliser.
Pour les tâches dont le préfixage est désactivé, le nom de tâche est formaté comme indiqué et est une concaténation des champs décrits dans le tableau suivant :
`pipelines----`
| Champ | Définition |
| --- | --- |
| pipelines | Chaîne statique toujours ajoutée au début. Cette chaîne identifie le service d'orchestration de pipeline comme source de la tâche. |
| executionId | Mémoire tampon aléatoire pour l'instance d'exécution du pipeline. |
| stepNamePrefix | Nom d'étape spécifié par l'utilisateur (indiqué dans l'argument `name` de l'étape du pipeline), limité aux 20 premiers caractères. |
| entityToken | Jeton aléatoire pour garantir l'idempotence de l'entité d'étape. |
| failureCount | Nombre actuel de nouvelles tentatives pour terminer la tâche. |
Dans ce cas, aucun préfixe personnalisé n'est ajouté au nom de la tâche et la politique IAM correspondante doit correspondre à cette chaîne.
Pour les utilisateurs qui activent le préfixage de tâche, le nom de tâche sous-jacent prend la forme suivante, le préfixe personnalisé étant spécifié en tant que `MyBaseJobName` :
**-**-**-**
Le préfixe personnalisé remplace la `pipelines` chaîne statique pour vous aider à affiner la sélection d'utilisateurs autorisés à exécuter le job SageMaker AI dans le cadre d'un pipeline.
**Restrictions concernant la longueur des préfixes**
Les noms des tâches sont soumis à des contraintes de longueur internes spécifiques aux étapes de pipeline individuelles. Cette contrainte limite également la longueur du préfixe autorisé. Les exigences relatives à la longueur du préfixe sont les suivantes :
| Étape de pipeline | Longueur du préfixe |
| --- | --- |
| `[TrainingStep](https://sagemaker.readthedocs.io/en/stable/amazon_sagemaker_model_building_pipeline.html#trainingstep)`, `[ModelStep](https://sagemaker.readthedocs.io/en/stable/workflows/pipelines/sagemaker.workflow.pipelines.html#step-collections)`, `[TransformStep](https://sagemaker.readthedocs.io/en/stable/amazon_sagemaker_model_building_pipeline.html#transformstep)`, `[ProcessingStep](https://sagemaker.readthedocs.io/en/stable/amazon_sagemaker_model_building_pipeline.html#processingstep)`, `[ClarifyCheckStep](https://sagemaker.readthedocs.io/en/stable/amazon_sagemaker_model_building_pipeline.html#clarifycheckstep)`, `[QualityCheckStep](https://sagemaker.readthedocs.io/en/stable/amazon_sagemaker_model_building_pipeline.html#qualitycheckstep)`, `[RegisterModelStep](https://sagemaker.readthedocs.io/en/stable/workflows/pipelines/sagemaker.workflow.pipelines.html#step-collections)` | 38 |
| `[TuningStep](https://sagemaker.readthedocs.io/en/stable/amazon_sagemaker_model_building_pipeline.html#tuningstep)`, `[AutoML](https://sagemaker.readthedocs.io/en/stable/amazon_sagemaker_model_building_pipeline.html#automlstep)` | 6 |
### Application de préfixes de tâche à une politique IAM
Votre administrateur crée des politiques IAM permettant aux utilisateurs de préfixes spécifiques de créer des tâches. L'exemple de politique suivant permet aux scientifiques des données de créer des tâches d'entraînement s'ils utilisent le préfixe `MyBaseJobName`.
```
{
"Action": "sagemaker:CreateTrainingJob",
"Effect": "Allow",
"Resource": [
"arn:aws:sagemaker:region:account-id:*/MyBaseJobName-*"
]
}
```
### Application de préfixes de tâche aux instanciations de pipeline
Vous spécifiez votre préfixe avec l'argument `*base_job_name` de la classe d'instances de tâche.
**Note**
Vous transmettez votre préfixe de tâche avec l'argument `*base_job_name` à l'instance de tâche avant de créer une étape de pipeline. Cette instance de tâche contient les informations nécessaires pour que la tâche s'exécute en tant qu'étape d'un pipeline. Cet argument varie en fonction de l'instance de tâche utilisée. La liste suivante indique l'argument à utiliser pour chaque type d'étape de pipeline :
`base_job_name` pour les classes `[Estimator](https://sagemaker.readthedocs.io/en/stable/api/training/estimators.html)` (`[TrainingStep](https://sagemaker.readthedocs.io/en/stable/amazon_sagemaker_model_building_pipeline.html#trainingstep)`), `[Processor](https://sagemaker.readthedocs.io/en/stable/api/training/processing.html)` (`[ProcessingStep](https://sagemaker.readthedocs.io/en/stable/amazon_sagemaker_model_building_pipeline.html#processingstep)`) et `[AutoML](https://sagemaker.readthedocs.io/en/stable/api/training/automl.html)` (`[AutoMLStep](https://sagemaker.readthedocs.io/en/stable/amazon_sagemaker_model_building_pipeline.html#automlstep)`)
`tuning_base_job_name` pour la classe `[Tuner](https://sagemaker.readthedocs.io/en/stable/api/training/tuner.html)` (`[TuningStep](https://sagemaker.readthedocs.io/en/stable/amazon_sagemaker_model_building_pipeline.html#tuningstep)`)
`transform_base_job_name` pour la classe `[Transformer](https://sagemaker.readthedocs.io/en/stable/api/inference/transformer.html)` (`[TransformStep](https://sagemaker.readthedocs.io/en/stable/amazon_sagemaker_model_building_pipeline.html#transformstep)`)
`base_job_name` ou `[CheckJobConfig](https://sagemaker.readthedocs.io/en/stable/workflows/pipelines/sagemaker.workflow.pipelines.html#checkjobconfig)` pour les classes `[QualityCheckStep](https://sagemaker.readthedocs.io/en/stable/amazon_sagemaker_model_building_pipeline.html#qualitycheckstep)` (Vérification de la qualité) et `[ClarifyCheckstep](https://sagemaker.readthedocs.io/en/stable/amazon_sagemaker_model_building_pipeline.html#clarifycheckstep)` (Vérification Clarify)
Pour la classe `[Model](https://sagemaker.readthedocs.io/en/stable/api/inference/model.html)`, l'argument utilisé diffère si vous exécutez `create` ou `register` sur votre modèle avant de transmettre le résultat à `[ModelStep](https://sagemaker.readthedocs.io/en/stable/workflows/pipelines/sagemaker.workflow.pipelines.html#step-collections)`.
Si vous appelez `create`, le préfixe personnalisé provient de l'argument `name` lorsque vous construisez votre modèle (c'est-à-dire, `Model(name=)`)
Si vous appelez `register`, le préfixe personnalisé provient de l'argument `model_package_name` de votre appel à `register` (c'est-à-dire, `my_model.register(model_package_name=)`)
L'exemple suivant montre comment spécifier un préfixe pour une nouvelle instance de tâche d'entraînement.
```
# Create a job instance
xgb_train = Estimator(
image_uri=image_uri,
instance_type="ml.m5.xlarge",
instance_count=1,
output_path=model_path,
role=role,
subnets=["subnet-0ab12c34567de89f0"],
base_job_name="MyBaseJobName"
security_group_ids=["sg-1a2bbcc3bd4444e55"],
tags = [ ... ]
encrypt_inter_container_traffic=True,
)
# Attach your job instance to a pipeline step
step_train = TrainingStep(
name="TestTrainingJob",
estimator=xgb_train,
inputs={
"train": TrainingInput(...),
"validation": TrainingInput(...)
}
)
```
Le préfixage de tâche est désactivé par défaut. Pour activer cette fonctionnalité, utilisez l'option `use_custom_job_prefix` de `PipelineDefinitionConfig` comme indiqué dans l'extrait suivant :
```
from sagemaker.workflow.pipeline_definition_config import PipelineDefinitionConfig
# Create a definition configuration and toggle on custom prefixing
definition_config = PipelineDefinitionConfig(use_custom_job_prefix=True);
# Create a pipeline with a custom prefix
pipeline = Pipeline(
name="MyJobPrefixedPipeline",
parameters=[...]
steps=[...]
pipeline_definition_config=definition_config
)
```
Créez et exécutez votre pipeline. L'exemple suivant crée et exécute un pipeline, et il montre également comment désactiver le préfixage des tâches et réexécuter votre pipeline.
```
pipeline.create(role_arn=sagemaker.get_execution_role())
# Optionally, call definition() to confirm your prefixed job names are in the built JSON
pipeline.definition()
pipeline.start()
# To run a pipeline without custom-prefixes, toggle off use_custom_job_prefix, update the pipeline
# via upsert() or update(), and start a new run
definition_config = PipelineDefinitionConfig(use_custom_job_prefix=False)
pipeline.pipeline_definition_config = definition_config
pipeline.update()
execution = pipeline.start()
```
De même, vous pouvez activer cette fonctionnalité pour les pipelines existants et démarrer une nouvelle exécution utilisant des préfixes de tâche.
```
definition_config = PipelineDefinitionConfig(use_custom_job_prefix=True)
pipeline.pipeline_definition_config = definition_config
pipeline.update()
execution = pipeline.start()
```
Enfin, vous pouvez consulter votre tâche préfixée de façon personnalisée en appelant `list_steps` sur l’exécution du pipeline.
```
steps = execution.list_steps()
prefixed_training_job_name = steps['PipelineExecutionSteps'][0]['Metadata']['TrainingJob']['Arn']
```
## Personnalisation de l’accès aux versions d’un pipeline
Vous pouvez accorder un accès personnalisé à des versions spécifiques d'Amazon SageMaker Pipelines à l'aide de la clé de `sagemaker:PipelineVersionId` condition. Par exemple, la politique ci-dessous autorise l’accès pour démarrer des exécutions ou mettre à jour la version du pipeline uniquement pour les ID de version 6 et ultérieurs.
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": {
"Sid": "AllowStartPipelineExecution",
"Effect": "Allow",
"Action": [
"sagemaker:StartPipelineExecution",
"sagemaker:UpdatePipelineVersion"
],
"Resource": "*",
"Condition": {
"NumericGreaterThanEquals": {
"sagemaker:PipelineVersionId": 6
}
}
}
}
```
------
Pour plus d'informations sur les clés de condition prises en charge, consultez [Clés de condition pour Amazon SageMaker AI](https://docs.aws.amazon.com//service-authorization/latest/reference/list_amazonsagemaker.html#amazonsagemaker-policy-keys).
## Politiques de contrôle des services avec les pipelines
Les politiques de contrôle des services (SCPs) sont un type de politique d'organisation que vous pouvez utiliser pour gérer les autorisations au sein de votre organisation. SCPs offrez un contrôle centralisé sur le maximum d'autorisations disponibles pour tous les comptes de votre organisation. En utilisant des pipelines au sein de votre organisation, vous pouvez vous assurer que les data scientists gèrent les exécutions de vos pipelines sans avoir à interagir avec la AWS console.
Si vous utilisez un VPC avec votre SCP qui restreint l’accès à Amazon S3, vous devez prendre des mesures pour autoriser votre pipeline à accéder à d’autres ressources Amazon S3.
Pour permettre à Pipelines d’accéder à Amazon S3 en dehors de votre VPC à l’aide de la fonction `JsonGet`, mettez à jour le SCP de votre organisation pour vous assurer que le rôle utilisant Pipelines peut accéder à Amazon S3. Pour ce faire, créez une exception pour les rôles utilisés par l’exécuteur Pipelines via le rôle d’exécution de pipeline à l’aide d’une balise de principal et d’une clé de condition.
**Pour autoriser Pipelines à accéder à Amazon S3 en dehors de votre VPC**
1. Créez une balise unique pour votre rôle d’exécution de pipeline en suivant les étapes décrites dans [Balisage des utilisateurs et des rôles IAM](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_tags.html).
1. Accordez une exception dans votre SCP à l'aide de la clé de condition `Aws:PrincipalTag IAM` pour la balise que vous avez créée. Pour plus d’informations, consultez [Création, mise à jour et suppression de politiques de contrôle des services](https://docs.aws.amazon.com/organizations/latest/userguide/orgs_manage_policies_scps_create.html).
# Configuration de la prise en charge entre comptes pour Pipelines
La prise en charge multicompte d'Amazon SageMaker Pipelines vous permet de collaborer sur des pipelines d'apprentissage automatique avec d'autres équipes ou organisations qui opèrent sur AWS des comptes différents. En configurant le partage de pipelines entre comptes, vous pouvez accorder un accès contrôlé aux pipelines, autoriser d’autres comptes à visualiser les détails du pipeline, déclencher des exécutions et surveiller les exécutions. La rubrique suivante explique comment configurer le partage de pipeline entre comptes, les différentes politiques d'autorisation disponibles pour les ressources partagées, et comment accéder et interagir avec des entités de pipeline partagées via des appels d'API directs à l' SageMaker IA.
## Configuration du partage de pipelines entre comptes
SageMaker L'IA utilise [AWS Resource Access Manager](https://docs.aws.amazon.com/ram/latest/userguide/what-is.html) (AWS RAM) pour vous aider à partager en toute sécurité les entités de votre pipeline entre les comptes.
### Création d’un partage de ressources
1. Sélectionnez **Create a resource share** (Créer un partage de ressources) via la [console AWS RAM](https://console.aws.amazon.com/ram/home).
1. Lorsque vous spécifiez les détails du partage de ressources, choisissez le type de ressource Pipelines et sélectionnez un ou plusieurs pipelines que vous souhaitez partager. Lorsque vous partagez un pipeline avec un autre compte, toutes ses exécutions sont également partagées implicitement.
1. Associez des autorisations à votre partage de ressources. Choisissez la politique d'autorisation en lecture seule par défaut ou la politique d'autorisation d'exécution de pipeline étendue. Pour en savoir plus, consultez [Politiques d’autorisation pour les ressources Pipelines](#build-and-manage-xaccount-permissions).
**Note**
Si vous sélectionnez la politique d'exécution étendue du pipeline, notez que toutes les commandes de démarrage, d'arrêt et de nouvelle tentative appelées par des comptes partagés utilisent les ressources du AWS compte qui a partagé le pipeline.
1. Utilisez AWS compte IDs pour spécifier les comptes auxquels vous souhaitez accorder l'accès à vos ressources partagées.
1. Vérifiez la configuration de votre partage de ressources et sélectionnez **Create resource share** (Créer un partage de ressources). Les associations entre le partage de ressources et le principal peuvent prendre quelques minutes.
Pour plus d'informations, consultez [Partage de vos ressources AWS](https://docs.aws.amazon.com/ram/latest/userguide/getting-started-sharing.html) dans le *Guide de l'utilisateur AWS Ressource Access Manager*.
### Obtention de réponses à votre invitation de partage de ressources
Une fois que les associations entre le partage de ressources et le principal ont été définies, les comptes AWS spécifiés reçoivent une invitation à rejoindre le partage de ressources. Les AWS comptes doivent accepter l'invitation pour accéder à toutes les ressources partagées.
Pour plus d'informations sur l'acceptation d'une invitation au partage de ressources AWS RAM, consultez la section [Utilisation AWS des ressources partagées](https://docs.aws.amazon.com/ram/latest/userguide/getting-started-shared.html) dans le *guide de l'utilisateur de AWS Resource Access Manager*.
## Politiques d’autorisation pour les ressources Pipelines
Lorsque vous créez votre partage de ressources, choisissez l'une des deux politiques d'autorisation prises en charge à associer au type de ressource SageMaker AI Pipeline. Les deux politiques donnent accès à n’importe quel pipeline sélectionné et à toutes ses exécutions.
### Autorisations en lecture seule par défaut
La politique `AWSRAMDefaultPermissionSageMakerPipeline` autorise les actions en lecture seule suivantes :
```
"sagemaker:DescribePipeline"
"sagemaker:DescribePipelineDefinitionForExecution"
"sagemaker:DescribePipelineExecution"
"sagemaker:ListPipelineExecutions"
"sagemaker:ListPipelineExecutionSteps"
"sagemaker:ListPipelineParametersForExecution"
"sagemaker:Search"
```
### Autorisations d'exécution de pipeline étendues
La politique `AWSRAMPermissionSageMakerPipelineAllowExecution` inclut toutes les autorisations en lecture seule de la politique par défaut et permet également aux comptes partagés de démarrer, d'arrêter et de réessayer les exécutions de pipeline.
**Note**
Soyez attentif à l'utilisation des AWS ressources lorsque vous utilisez la politique d'autorisation d'exécution étendue du pipeline. Avec cette politique, les comptes partagés sont autorisés à démarrer, arrêter et réessayer les exécutions de pipeline. Toutes les ressources utilisées pour des exécutions de pipeline partagées sont consommées par le compte propriétaire.
La politique d'autorisation d'exécution de pipeline étendue autorise les actions suivantes :
```
"sagemaker:DescribePipeline"
"sagemaker:DescribePipelineDefinitionForExecution"
"sagemaker:DescribePipelineExecution"
"sagemaker:ListPipelineExecutions"
"sagemaker:ListPipelineExecutionSteps"
"sagemaker:ListPipelineParametersForExecution"
"sagemaker:StartPipelineExecution"
"sagemaker:StopPipelineExecution"
"sagemaker:RetryPipelineExecution"
"sagemaker:Search"
```
## Accès aux entités de pipeline partagées via des appels d'API directs
Une fois le partage de pipeline entre comptes configuré, vous pouvez appeler les actions d' SageMaker API suivantes à l'aide d'un ARN de pipeline :
**Note**
Vous ne pouvez appeler des commandes d'API que si elles sont incluses dans les autorisations associées à votre partage de ressources. Si vous sélectionnez la `AWSRAMPermissionSageMakerPipelineAllowExecution` politique, les commandes start, stop et retry utilisent les ressources du AWS compte qui a partagé le pipeline.
+ [DescribePipeline](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_DescribePipeline.html)
+ [DescribePipelineDefinitionForExecution](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_DescribePipelineDefinitionForExecution.html)
+ [DescribePipelineExecution](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_DescribePipelineExecution.html)
+ [ListPipelineExecutions](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_ListPipelineExecutions.html)
+ [ListPipelineExecutionSteps](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_ListPipelineExecutionSteps.html)
+ [ListPipelineParametersForExecution](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_ListPipelineParametersForExecution.html)
+ [StartPipelineExecution](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_StartPipelineExecution.html)
+ [StopPipelineExecution](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_StopPipelineExecution.html)
+ [RetryPipelineExecution](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_RetryPipelineExecution.html)
# Paramètres du pipeline
Vous pouvez introduire des variables dans la définition de votre pipeline à l’aide de paramètres. Vous pouvez référencer les paramètres que vous définissez tout au long de votre définition de pipeline. Les paramètres ont une valeur par défaut, que vous pouvez remplacer en spécifiant des valeurs de paramètre lors du démarrage d’une exécution de pipeline. La valeur par défaut doit être une instance correspondant au type de paramètre. Tous les paramètres utilisés dans les définitions d’étape doivent être définis dans votre définition de pipeline. Cette rubrique décrit les paramètres que vous pouvez définir et comment les mettre en œuvre.
Amazon SageMaker Pipelines prend en charge les types de paramètres suivants :
+ `ParameterString` - représente un paramètre de chaîne.
+ `ParameterInteger` - représente un paramètre entier.
+ `ParameterFloat` - représente un paramètre flottant.
+ `ParameterBoolean` - représente un type Python booléen.
Les paramètres prennent le format suivant :
```
= (
name="",
default_value=
)
```
Voici un exemple de mise en œuvre de paramètre.
```
from sagemaker.workflow.parameters import (
ParameterInteger,
ParameterString,
ParameterFloat,
ParameterBoolean
)
processing_instance_count = ParameterInteger(
name="ProcessingInstanceCount",
default_value=1
)
```
Vous transmettez le paramètre lors de la création de votre pipeline comme illustré dans l'exemple suivant.
```
pipeline = Pipeline(
name=pipeline_name,
parameters=[
processing_instance_count
],
steps=[step_process]
)
```
Vous pouvez également transmettre une valeur de paramètre qui diffère de la valeur par défaut à une exécution de pipeline, comme illustré dans l’exemple suivant.
```
execution = pipeline.start(
parameters=dict(
ProcessingInstanceCount="2",
ModelApprovalStatus="Approved"
)
)
```
Vous pouvez manipuler les paramètres avec des fonctions du SDK SageMaker Python telles que`[ sagemaker.workflow.functions.Join](https://sagemaker.readthedocs.io/en/stable/workflows/pipelines/sagemaker.workflow.pipelines.html#sagemaker.workflow.functions.Join)`. Pour plus d'informations sur les paramètres, consultez la section [Paramètres des SageMaker pipelines](https://sagemaker.readthedocs.io/en/stable/workflows/pipelines/sagemaker.workflow.pipelines.html#parameters).
Pour connaître les limites connues des paramètres des pipelines, consultez *[Limitations - Paramétrage](https://sagemaker.readthedocs.io/en/stable/amazon_sagemaker_model_building_pipeline.html#parameterization)* dans le SDK Amazon [ SageMaker Python](https://sagemaker.readthedocs.io/en/stable).
# Étapes du pipeline
Les pipelines se composent d’étapes. Ces étapes définissent les actions effectuées par le pipeline et les relations entre les étapes utilisant les propriétés. La page suivante décrit les types d’étapes, leurs propriétés et les relations entre elles.
**Topics**
+ [Ajout d’une étape](build-and-manage-steps-types.md)
+ [Ajouter une intégration](build-and-manage-steps-integration.md)
+ [Propriétés de l’étape](#build-and-manage-properties)
+ [Parallélisme d’étapes](#build-and-manage-parallelism)
+ [Dépendance des données entre étapes](#build-and-manage-data-dependency)
+ [Dépendance personnalisée entre étapes](#build-and-manage-custom-dependency)
+ [Images personnalisées dans une étape](#build-and-manage-images)
# Ajout d’une étape
La section suivante décrit les exigences de chaque type d’étape et fournit un exemple d’implémentation de l’étape, ainsi que la manière d’ajouter l’étape à un pipeline. Ce ne sont pas des implémentations fonctionnelles, car elles ne fournissent pas la ressource et les entrées nécessaires. Pour obtenir un tutoriel qui met en œuvre ces étapes, consultez [Actions de pipeline](pipelines-build.md).
**Note**
Vous pouvez également créer une étape à partir de votre code de machine learning local en le convertissant en étape Pipelines à l’aide du décorateur `@step`. Pour de plus amples informations, veuillez consulter [décorateur @step](#step-type-custom).
Amazon SageMaker Pipelines prend en charge les types d'étapes suivants :
+ [Exécuter le code](#step-type-executecode)
[Traitement](#step-type-processing)
+ [Entraînement](#step-type-training)
+ [Réglage](#step-type-tuning)
+ [AutoML](#step-type-automl)
+ [`Model`](#step-type-model)
+ [`Create model`](#step-type-create-model)
+ [`Register model`](#step-type-register-model)
+ [`Deploy model (endpoint)`](#step-type-deploy-model-endpoint)
+ [Transformation](#step-type-transform)
+ [Condition](#step-type-condition)
+ [`Callback`](#step-type-callback)
+ [Lambda](#step-type-lambda)
+ [`ClarifyCheck`](#step-type-clarify-check)
+ [`QualityCheck`](#step-type-quality-check)
+ [EMR](#step-type-emr)
+ [Tâche de bloc-notes](#step-type-notebook-job)
+ [Fail](#step-type-fail)
## décorateur @step
Si vous souhaitez orchestrer une tâche de ML personnalisée qui tire parti des fonctionnalités avancées de l' SageMaker IA ou d'autres AWS services de l'interface utilisateur de drag-and-drop Pipelines, utilisez le. [Étape Exécuter le code](#step-type-executecode)
Vous pouvez créer une étape à partir du code de machine learning local à l’aide du décorateur `@step`. Après avoir testé votre code, vous pouvez convertir la fonction en une étape de pipeline d' SageMaker IA en l'annotant avec le `@step` décorateur. Pipelines crée et exécute un pipeline lorsque vous transmettez la sortie de la fonction décorée avec `@step` en tant qu’étape à votre pipeline. Vous pouvez également créer un pipeline DAG en plusieurs étapes qui inclut une ou plusieurs fonctions `@step` décorées ainsi que des étapes de pipeline d' SageMaker IA traditionnelles. Pour plus de détails sur la création d’une étape avec le décorateur `@step`, consultez [Lift-and-shift Code Python avec le décorateur @step](pipelines-step-decorator.md).
## Étape Exécuter le code
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 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. Ce compartiment ne dispose pas des autorisations de partage des ressources entre origines multiples (CORS). Pour en savoir plus sur la configuration d’autorisations CORS, consultez [Exigence CORS pour les données d’image d’entrée](sms-cors-update.md).
L'étape **Execute Code** utilise une tâche de SageMaker formation Amazon pour exécuter votre code. Assurez-vous que votre rôle IAM dispose des autorisations d’API `sagemaker:DescribeTrainingJob` et `sagemaker:CreateTrainingJob`. Pour en savoir plus sur toutes les autorisations requises pour Amazon SageMaker AI et sur la façon de les configurer, consultez[Autorisations d'API Amazon SageMaker AI : référence sur les actions, les autorisations et les ressources](api-permissions-reference.md).
Pour ajouter une étape d’exécution de code à un pipeline à l’aide du concepteur de pipeline, procédez comme suit :
1. Ouvrez la console Amazon SageMaker Studio en suivant les instructions fournies dans[Lancez Amazon SageMaker Studio](studio-updated-launch.md).
1. Dans le volet de navigation de gauche, sélectionnez **Pipelines**.
1. Choisissez **Créer**.
1. Choisissez **Vide**.
1. Dans la barre latérale gauche, choisissez **Exécuter le code** et faites-le glisser vers le canevas.
1. Dans le canevas, choisissez l’étape **Exécuter le code** que vous avez ajoutée.
1. Dans la barre latérale droite, complétez les formulaires dans les onglets **Paramètre** et **Détails**.
1. Vous pouvez charger un fichier individuel à exécuter ou charger un dossier compressé contenant plusieurs artefacts.
1. Pour les chargements de fichiers uniques, vous pouvez fournir des paramètres facultatifs pour les blocs-notes, les fonctions Python ou les scripts.
1. Lorsque vous fournissez des fonctions Python, un gestionnaire doit être fourni au format `file.py:`
1. Pour les chargements de dossiers compressés, des chemins relatifs à votre code doivent être fournis, et vous pouvez éventuellement fournir des chemins vers un fichier `requirements.txt` ou un script d’initialisation dans le dossier compressé.
1. Si le canevas inclut une étape qui précède immédiatement l’étape **Exécuter le code** que vous avez ajoutée, cliquez et faites glisser le curseur de cette étape vers l’étape **Exécuter le code** pour créer une périphérie.
1. Si le canevas inclut une étape qui suit immédiatement l’étape **Exécuter le code** que vous avez ajoutée, cliquez et faites glisser le curseur de l’étape **Exécuter le code** vers cette étape pour créer une périphérie. Les sorties des étapes **Exécuter le code** peuvent être référencées pour les fonctions Python.
## Étape de traitement
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, consultez [Données de traitement et Modèles d’évaluation](https://docs.aws.amazon.com/sagemaker/latest/dg/processing-job.html).
------
#### [ Pipeline Designer ]
Pour ajouter une étape de traitement à un pipeline à l’aide du concepteur de pipeline, procédez comme suit :
1. Ouvrez la console Amazon SageMaker Studio en suivant les instructions fournies dans[Lancez Amazon SageMaker Studio](studio-updated-launch.md).
1. Dans le volet de navigation de gauche, sélectionnez **Pipelines**.
1. Choisissez **Créer**.
1. Dans la barre latérale gauche, choisissez **Traiter les données** et faites-le glisser vers le canevas.
1. Dans le canevas, choisissez l’étape **Traiter les données** que vous avez ajoutée.
1. Dans la barre latérale droite, complétez les formulaires dans les onglets **Paramètre** et **Détails**. Pour plus d'informations sur les champs de ces onglets, consultez [sagemaker.workflow.steps. ProcessingStep](https://sagemaker.readthedocs.io/en/stable/workflows/pipelines/sagemaker.workflow.pipelines.html#sagemaker.workflow.steps.ProcessingStep).
1. Si le canevas inclut une étape qui précède immédiatement l’étape **Traiter les données** que vous avez ajoutée, cliquez et faites glisser le curseur de cette étape vers l’étape **Traiter les données** pour créer une périphérie.
1. Si le canevas inclut une étape qui suit immédiatement l’étape **Traiter les données** que vous avez ajoutée, cliquez et faites glisser le curseur de l’étape **Traiter les données** vers cette étape pour créer une périphérie.
------
#### [ SageMaker Python SDK ]
Une étape de traitement nécessite un processeur, un script Python qui définit le code de traitement, les sorties pour le traitement et les arguments de tâche. L’exemple suivant montre comment créer une définition `ProcessingStep`.
```
from sagemaker.sklearn.processing import SKLearnProcessor
sklearn_processor = SKLearnProcessor(framework_version='1.0-1',
role=,
instance_type='ml.m5.xlarge',
instance_count=1)
```
```
from sagemaker.processing import ProcessingInput, ProcessingOutput
from sagemaker.workflow.steps import ProcessingStep
inputs = [
ProcessingInput(source=, destination="/opt/ml/processing/input"),
]
outputs = [
ProcessingOutput(output_name="train", source="/opt/ml/processing/train"),
ProcessingOutput(output_name="validation", source="/opt/ml/processing/validation"),
ProcessingOutput(output_name="test", source="/opt/ml/processing/test")
]
step_process = ProcessingStep(
name="AbaloneProcess",
step_args = sklearn_processor.run(inputs=inputs, outputs=outputs,
code="abalone/preprocessing.py")
)
```
**Transmission des paramètres d’exécution**
L'exemple suivant montre comment transmettre des paramètres d'exécution d'un PySpark processeur à un`ProcessingStep`.
```
from sagemaker.workflow.pipeline_context import PipelineSession
from sagemaker.spark.processing import PySparkProcessor
from sagemaker.processing import ProcessingInput, ProcessingOutput
from sagemaker.workflow.steps import ProcessingStep
pipeline_session = PipelineSession()
pyspark_processor = PySparkProcessor(
framework_version='2.4',
role=,
instance_type='ml.m5.xlarge',
instance_count=1,
sagemaker_session=pipeline_session,
)
step_args = pyspark_processor.run(
inputs=[ProcessingInput(source=, destination="/opt/ml/processing/input"),],
outputs=[
ProcessingOutput(output_name="train", source="/opt/ml/processing/train"),
ProcessingOutput(output_name="validation", source="/opt/ml/processing/validation"),
ProcessingOutput(output_name="test", source="/opt/ml/processing/test")
],
code="preprocess.py",
arguments=None,
)
step_process = ProcessingStep(
name="AbaloneProcess",
step_args=step_args,
)
```
Pour plus d'informations sur les exigences relatives aux étapes de traitement, consultez le document [sagemaker.workflow.steps. ProcessingStep](https://sagemaker.readthedocs.io/en/stable/workflows/pipelines/sagemaker.workflow.pipelines.html#sagemaker.workflow.steps.ProcessingStep)documentation. Pour un exemple détaillé, consultez le carnet d'exemples [Orchestrate Jobs to Train and Evaluate Models with Amazon SageMaker Pipelines](https://github.com/aws/amazon-sagemaker-examples/blob/62de6a1fca74c7e70089d77e36f1356033adbe5f/sagemaker-pipelines/tabular/abalone_build_train_deploy/sagemaker-pipelines-preprocess-train-evaluate-batch-transform.ipynb). La section *Définition d’une étape de traitement pour l’ingénierie des caractéristiques* contient plus d’informations.
------
## Étape d’entraînement
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](https://docs.aws.amazon.com/sagemaker/latest/dg/how-it-works-training.html).
Une étape d’entraînement nécessite un estimateur, ainsi que des entrées de données d’entraînement et de validation.
------
#### [ Pipeline Designer ]
Pour ajouter une étape d’entraînement à un pipeline à l’aide du concepteur de pipeline, procédez comme suit :
1. Ouvrez la console Amazon SageMaker Studio en suivant les instructions fournies dans[Lancez Amazon SageMaker Studio](studio-updated-launch.md).
1. Dans le volet de navigation de gauche, sélectionnez **Pipelines**.
1. Choisissez **Créer**.
1. Choisissez **Vide**.
1. Dans la barre latérale gauche, choisissez **Entraîner le modèle** et faites-le glisser vers le canevas.
1. Dans le canevas, choisissez l’étape **Entraîner le modèle** que vous avez ajoutée.
1. Dans la barre latérale droite, complétez les formulaires dans les onglets **Paramètre** et **Détails**. Pour plus d'informations sur les champs de ces onglets, consultez [sagemaker.workflow.steps. TrainingStep](https://sagemaker.readthedocs.io/en/stable/workflows/pipelines/sagemaker.workflow.pipelines.html#sagemaker.workflow.steps.TrainingStep).
1. Si le canevas inclut une étape qui précède immédiatement l’étape **Entraîner le modèle** que vous avez ajoutée, cliquez et faites glisser le curseur de cette étape vers l’étape **Entraîner le modèle** pour créer une périphérie.
1. Si le canevas inclut une étape qui suit immédiatement l’étape **Entraîner le modèle** que vous avez ajoutée, cliquez et faites glisser le curseur de l’étape **Entraîner le modèle** vers cette étape pour créer une périphérie.
------
#### [ SageMaker Python SDK ]
L’exemple suivant montre comment créer une définition `TrainingStep`. Pour plus d'informations sur les exigences relatives aux étapes de formation, consultez le document [sagemaker.workflow.steps. TrainingStep](https://sagemaker.readthedocs.io/en/stable/workflows/pipelines/sagemaker.workflow.pipelines.html#sagemaker.workflow.steps.TrainingStep)documentation.
```
from sagemaker.workflow.pipeline_context import PipelineSession
from sagemaker.inputs import TrainingInput
from sagemaker.workflow.steps import TrainingStep
from sagemaker.xgboost.estimator import XGBoost
pipeline_session = PipelineSession()
xgb_estimator = XGBoost(..., sagemaker_session=pipeline_session)
step_args = xgb_estimator.fit(
inputs={
"train": TrainingInput(
s3_data=step_process.properties.ProcessingOutputConfig.Outputs[
"train"
].S3Output.S3Uri,
content_type="text/csv"
),
"validation": TrainingInput(
s3_data=step_process.properties.ProcessingOutputConfig.Outputs[
"validation"
].S3Output.S3Uri,
content_type="text/csv"
)
}
)
step_train = TrainingStep(
name="TrainAbaloneModel",
step_args=step_args,
)
```
------
## Étape de réglage
Vous utilisez une étape de réglage pour créer une tâche de réglage d’hyperparamètres, également appelé optimisation des hyperparamètres (HPO). Une tâche de réglage d’hyperparamètres exécute plusieurs tâches d’entraînement, chacune produisant une version de modèle. Pour plus d’informations sur le réglage d’hyperparamètres, consultez [Réglage automatique du modèle grâce à l' SageMaker IA](automatic-model-tuning.md).
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](pipelines-experiments.md).
Une étape de réglage nécessite des entrées [HyperparameterTuner](https://sagemaker.readthedocs.io/en/stable/api/training/tuner.html)et 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, consultez [Exécution d'une tâche de réglage des hyperparamètres avec démarrage à chaud](automatic-model-tuning-warm-start.md).
[Vous utilisez la méthode [get\$1top\$1model\$1s3\$1uri](https://sagemaker.readthedocs.io/en/stable/workflows/pipelines/sagemaker.workflow.pipelines.html#sagemaker.workflow.steps.TuningStep.get_top_model_s3_uri) du sagemaker.workflow.steps. TuningStep](https://sagemaker.readthedocs.io/en/stable/workflows/pipelines/sagemaker.workflow.pipelines.html#sagemaker.workflow.steps.TuningStep)classe 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](https://github.com/aws/amazon-sagemaker-examples/blob/main/sagemaker-pipelines/tabular/tuning-step/sagemaker-pipelines-tuning-step.ipynb).
**Important**
Les étapes de réglage ont été introduites dans Amazon SageMaker Python SDK v2.48.0 et Amazon SageMaker Studio Classic v3.8.0. Vous devez mettre à jour Studio Classic avant d’utiliser une étape de réglage, ou le graphique DAG du pipeline ne s’affiche pas. Pour mettre à jour Studio Classic, consultez [Arrêter et mettre à jour Amazon SageMaker Studio Classic](studio-tasks-update-studio.md).
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](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_HyperParameterTuningJobObjective.html). 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. TuningStep](https://sagemaker.readthedocs.io/en/stable/workflows/pipelines/sagemaker.workflow.pipelines.html#sagemaker.workflow.steps.TuningStep)documentation.
## Étape de peaufinage
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 optimisez 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 la mise au point d'un modèle de base à partir de JumpStart, voir[Affiner un modèle](jumpstart-fine-tune.md).
L'étape de mise au point utilise une tâche de SageMaker formation Amazon pour personnaliser votre modèle. Assurez-vous que votre rôle IAM dispose des autorisations d’API `sagemaker:DescribeTrainingJob` et `sagemaker:CreateTrainingJob` nécessaires pour exécuter la tâche de peaufinage dans votre pipeline. Pour en savoir plus sur les autorisations requises pour Amazon SageMaker AI et sur la façon de les configurer, consultez[Autorisations d'API Amazon SageMaker AI : référence sur les actions, les autorisations et les ressources](api-permissions-reference.md).
Pour ajouter une étape de **modèle affinée** à votre pipeline à l'aide de l' drag-and-dropéditeur, procédez comme suit :
1. Ouvrez la console Studio en suivant les instructions figurant dans [Lancez Amazon SageMaker Studio](studio-updated-launch.md).
1. Dans le volet de navigation de gauche, sélectionnez **Pipelines**.
1. Choisissez **Créer**.
1. Choisissez **Vide**.
1. Dans la barre latérale gauche, choisissez **Ajuster le modèle** et faites-le glisser vers le canevas.
1. Dans le canevas, choisissez l’étape **Ajuster le modèle** que vous avez ajoutée.
1. Dans la barre latérale droite, complétez les formulaires dans les onglets **Paramètre** et **Détails**.
1. Si le canevas inclut une étape qui précède immédiatement l’étape **Ajuster le modèle** que vous avez ajoutée, cliquez et faites glisser le curseur de cette étape vers l’étape **Ajuster le modèle** pour créer une périphérie.
1. Si le canevas inclut une étape qui suit immédiatement l’étape **Ajuster le modèle** que vous avez ajoutée, cliquez et faites glisser le curseur de l’étape **Ajuster le modèle** vers cette étape pour créer une périphérie.
## Étape AutoML
Utilisez l'API [AutoML](https://sagemaker.readthedocs.io/en/stable/api/training/automl.html) 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 ](https://docs.aws.amazon.com/sagemaker/latest/dg/autopilot-automate-model-development.html) Autopilot.
**Note**
Actuellement, l'étape AutoML ne prend en charge que [le mode d'entraînement d'assemblage](https://docs.aws.amazon.com/sagemaker/latest/dg/autopilot-model-support-validation.html).
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="",
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 d’objectif de la tâche AutoML à l’aide de la méthode `get_best_auto_ml_model` comme suit. Vous devez également utiliser un `role` IAM pour accéder aux artefacts du modèle.
```
best_model = step_automl.get_best_auto_ml_model(role=)
```
Pour plus d'informations, consultez l'étape [AutoML](https://sagemaker.readthedocs.io/en/stable/workflows/pipelines/sagemaker.workflow.pipelines.html#sagemaker.workflow.automl_step.AutoMLStep) du SDK SageMaker Python.
## Étape du modèle
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\$1step. ModelStep](https://sagemaker.readthedocs.io/en/stable/workflows/pipelines/sagemaker.workflow.pipelines.html#sagemaker.workflow.model_step.ModelStep)documentation.
### 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](https://docs.aws.amazon.com/sagemaker/latest/dg/how-it-works-training.html).
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, consultez [Déploiement de l’enregistrement de modèles à l’aide du registre de modèles](model-registry.md).
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,
)
```
## Création d’une étape de modèle
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, consultez[Entraînez un modèle avec Amazon SageMaker](how-it-works-training.md).
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 Créer un modèle. Pour plus d'informations sur les exigences relatives aux étapes de création d'un modèle, consultez le document [sagemaker.workflow.steps. CreateModelStep](https://sagemaker.readthedocs.io/en/stable/workflows/pipelines/sagemaker.workflow.pipelines.html#sagemaker.workflow.steps.CreateModelStep)documentation.
------
#### [ Pipeline Designer ]
Pour ajouter une étape de création de modèle à votre pipeline, procédez comme suit :
1. Ouvrez la console Studio en suivant les instructions figurant dans [Lancez Amazon SageMaker Studio](studio-updated-launch.md).
1. Dans le volet de navigation de gauche, sélectionnez **Pipelines**.
1. Choisissez **Créer**.
1. Choisissez **Vide**.
1. Dans la barre latérale gauche, choisissez **Créer un modèle** et faites-le glisser vers le canevas.
1. Dans le canevas, choisissez l’étape **Créer un modèle** que vous avez ajoutée.
1. Dans la barre latérale droite, complétez les formulaires dans les onglets **Paramètre** et **Détails**. Pour plus d'informations sur les champs de ces onglets, consultez [sagemaker.workflow.steps. CreateModelStep](https://sagemaker.readthedocs.io/en/stable/workflows/pipelines/sagemaker.workflow.pipelines.html#sagemaker.workflow.steps.CreateModelStep).
1. Si le canevas inclut une étape qui précède immédiatement l’étape **Créer un modèle** que vous avez ajoutée, cliquez et faites glisser le curseur de cette étape vers l’étape **Créer un modèle** pour créer une périphérie.
1. Si le canevas inclut une étape qui suit immédiatement l’étape **Créer un modèle** que vous avez ajoutée, cliquez et faites glisser le curseur de l’étape **Créer un modèle** vers cette étape pour créer une périphérie.
------
#### [ SageMaker Python SDK ]
**Important**
Nous vous recommandons [Étape du modèle](#step-type-model) de l'utiliser pour créer des modèles à partir de la version 2.90.0 du SDK AI SageMaker Python. `CreateModelStep`continuera de fonctionner dans les versions précédentes du SDK SageMaker Python, mais n'est plus activement pris en charge.
```
from sagemaker.workflow.steps import CreateModelStep
step_create_model = CreateModelStep(
name="AbaloneCreateModel",
model=best_model,
inputs=inputs
)
```
------
## Étape Enregistrer le modèle
L'étape Enregistrer un modèle enregistre un modèle dans le registre des SageMaker modèles.
------
#### [ Pipeline Designer ]
Pour enregistrer un modèle à partir d’un pipeline à l’aide du concepteur de pipeline, procédez comme suit :
1. Ouvrez la console Amazon SageMaker Studio en suivant les instructions fournies dans[Lancez Amazon SageMaker Studio](studio-updated-launch.md).
1. Dans le volet de navigation de gauche, sélectionnez **Pipelines**.
1. Choisissez **Créer**.
1. Choisissez **Vide**.
1. Dans la barre latérale gauche, choisissez **Enregistrer le modèle** et faites-le glisser vers le canevas.
1. Dans le canevas, choisissez l’étape **Enregistrer le modèle** que vous avez ajoutée.
1. Dans la barre latérale droite, complétez les formulaires dans les onglets **Paramètre** et **Détails**. Pour plus d'informations sur les champs de ces onglets, consultez [sagemaker.workflow.step\$1collections. RegisterModel](https://sagemaker.readthedocs.io/en/stable/workflows/pipelines/sagemaker.workflow.pipelines.html#sagemaker.workflow.step_collections.RegisterModel).
1. Si le canevas inclut une étape qui précède immédiatement l’étape **Enregistrer le modèle** que vous avez ajoutée, cliquez et faites glisser le curseur de cette étape vers l’étape **Enregistrer le modèle** pour créer une périphérie.
1. Si le canevas inclut une étape qui suit immédiatement l’étape **Enregistrer le modèle** que vous avez ajoutée, cliquez et faites glisser le curseur de l’étape **Enregistrer le modèle** vers cette étape pour créer une périphérie.
------
#### [ SageMaker Python SDK ]
**Important**
Nous vous recommandons [Étape du modèle](#step-type-model) de l'utiliser pour enregistrer des modèles à partir de la version 2.90.0 du SDK AI SageMaker Python. `RegisterModel`continuera de fonctionner dans les versions précédentes du SDK SageMaker Python, mais n'est plus activement pris en charge.
[Vous utilisez une `RegisterModel` étape pour enregistrer un [SageMaker.Model.Model ou un sagemaker.pipeline.](https://sagemaker.readthedocs.io/en/stable/api/inference/model.html) PipelineModel](https://sagemaker.readthedocs.io/en/stable/api/inference/pipeline.html#pipelinemodel)auprès de 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, consultez [Déploiement de l’enregistrement de modèles à l’aide du registre de modèles](model-registry.md). Pour plus d'informations sur les exigences relatives aux `RegisterModel` étapes, consultez le document [sagemaker.workflow.step\$1collections. RegisterModel](https://sagemaker.readthedocs.io/en/stable/workflows/pipelines/sagemaker.workflow.pipelines.html#sagemaker.workflow.step_collections.RegisterModel)documentation.
L'exemple suivant montre comment créer une étape `RegisterModel` qui enregistre un `PipelineModel`.
```
import time
from sagemaker.sklearn import SKLearnModel
from sagemaker.xgboost import XGBoostModel
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=sagemaker_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=sagemaker_session,
role=role)
from sagemaker.workflow.step_collections import RegisterModel
from sagemaker import PipelineModel
pipeline_model = PipelineModel(models=[sklearn_model,xgboost_model],role=role,sagemaker_session=sagemaker_session)
step_register = RegisterModel(
name="AbaloneRegisterModel",
model=pipeline_model,
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',
)
```
Si le `model` n’est pas fourni, l’étape RegisterModel nécessite un estimateur, comme illustré dans l’exemple suivant.
```
from sagemaker.workflow.step_collections import RegisterModel
step_register = RegisterModel(
name="AbaloneRegisterModel",
estimator=xgb_train,
model_data=step_train.properties.ModelArtifacts.S3ModelArtifacts,
content_types=["text/csv"],
response_types=["text/csv"],
inference_instances=["ml.t2.medium", "ml.m5.xlarge"],
transform_instances=["ml.m5.xlarge"],
model_package_group_name=model_package_group_name,
approval_status=model_approval_status,
model_metrics=model_metrics
)
```
------
## Étape Déployer le modèle (point de terminaison)
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’autoscaling. Pour en savoir plus sur l'inférence en temps réel dans l' SageMaker IA, consultez[Inférence en temps réel](realtime-endpoints.md).
Avant d’ajouter une étape de déploiement de modèle à votre pipeline, assurez-vous que votre rôle IAM possède les autorisations suivantes :
+ `sagemaker:CreateModel`
+ `sagemaker:CreateEndpointConfig`
+ `sagemaker:CreateEndpoint`
+ `sagemaker:UpdateEndpoint`
+ `sagemaker:DescribeModel`
+ `sagemaker:DescribeEndpointConfig`
+ `sagemaker:DescribeEndpoint`
Pour en savoir plus sur toutes les autorisations requises pour l' SageMaker IA et sur la façon de les configurer, consultez[Autorisations d'API Amazon SageMaker AI : référence sur les actions, les autorisations et les ressources](api-permissions-reference.md).
Pour ajouter une étape de déploiement du modèle à votre pipeline dans l' drag-and-dropéditeur, procédez comme suit :
1. Ouvrez la console Studio en suivant les instructions figurant dans [Lancez Amazon SageMaker Studio](studio-updated-launch.md).
1. Dans le volet de navigation de gauche, sélectionnez **Pipelines**.
1. Choisissez **Créer**.
1. Choisissez **Vide**.
1. Dans la barre latérale gauche, choisissez **Déployer le modèle (point de terminaison)** et faites-le glisser vers le canevas.
1. Dans le canevas, choisissez l’étape **Déployer le modèle (point de terminaison)** que vous avez ajoutée.
1. Dans la barre latérale droite, complétez les formulaires dans les onglets **Paramètre** et **Détails**.
1. Si le canevas inclut une étape qui précède immédiatement l’étape **Déployer le modèle (point de terminaison)** que vous avez ajoutée, cliquez et faites glisser le curseur de cette étape vers l’étape **Déployer le modèle (point de terminaison)** pour créer une périphérie.
1. Si le canevas inclut une étape qui suit immédiatement l’étape **Déployer le modèle (point de terminaison)** que vous avez ajoutée, cliquez et faites glisser le curseur de l’étape **Déployer le modèle (point de terminaison)** vers cette étape pour créer une périphérie.
## Étape de transformation
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, consultez [Transformations par lots avec pipelines d’inférence](inference-pipeline-batch.md).
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. TransformStep](https://sagemaker.readthedocs.io/en/stable/workflows/pipelines/sagemaker.workflow.pipelines.html#sagemaker.workflow.steps.TransformStep)documentation.
------
#### [ Pipeline Designer ]
Pour ajouter une étape de transformation par lots à votre pipeline à l'aide de l'éditeur drag-and-drop visuel, procédez comme suit :
1. Ouvrez la console Studio en suivant les instructions figurant dans [Lancez Amazon SageMaker Studio](studio-updated-launch.md).
1. Dans le volet de navigation de gauche, sélectionnez **Pipelines**.
1. Choisissez **Créer**.
1. Choisissez **Vide**.
1. Dans la barre latérale gauche, choisissez **Déployer le modèle (transformation par lots)** et faites-le glisser vers le canevas.
1. Dans le canevas, choisissez l’étape **Déployer le modèle (transformation par lots)** que vous avez ajoutée.
1. Dans la barre latérale droite, complétez les formulaires dans les onglets **Paramètre** et **Détails**. Pour plus d'informations sur les champs de ces onglets, consultez [sagemaker.workflow.steps. TransformStep](https://sagemaker.readthedocs.io/en/stable/workflows/pipelines/sagemaker.workflow.pipelines.html#sagemaker.workflow.steps.TransformStep).
1. Si le canevas inclut une étape qui précède immédiatement l’étape **Déployer le modèle (transformation par lots)** que vous avez ajoutée, cliquez et faites glisser le curseur de cette étape vers l’étape **Déployer le modèle (transformation par lots)** pour créer une périphérie.
1. Si le canevas inclut une étape qui suit immédiatement l’étape **Déployer le modèle (transformation par lots)** que vous avez ajoutée, cliquez et faites glisser le curseur de l’étape **Déployer le modèle (transformation par lots)** vers cette étape pour créer une périphérie.
------
#### [ SageMaker Python SDK ]
```
from sagemaker.workflow.pipeline_context import PipelineSession
from sagemaker.transformer import Transformer
from sagemaker.inputs import TransformInput
from sagemaker.workflow.steps import TransformStep
transformer = Transformer(..., sagemaker_session=PipelineSession())
step_transform = TransformStep(
name="AbaloneTransform",
step_args=transformer.transform(data="s3://amzn-s3-demo-bucket/my-data"),
)
```
------
## Étape de condition
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 :
+ Une liste de conditions
+ Une liste d’étapes à exécuter si la condition a la valeur `true`
+ Une liste d’étapes à exécuter si la condition a la valeur `false`
------
#### [ Pipeline Designer ]
Pour ajouter une étape de condition à un pipeline à l’aide du concepteur de pipeline, procédez comme suit :
1. Ouvrez la console Amazon SageMaker Studio en suivant les instructions fournies dans[Lancez Amazon SageMaker Studio](studio-updated-launch.md).
1. Dans le volet de navigation de gauche, sélectionnez **Pipelines**.
1. Choisissez **Créer**.
1. Choisissez **Vide**.
1. Dans la barre latérale gauche, choisissez **Condition** et faites-la glisser vers le canevas.
1. Dans le canevas, choisissez l’étape **Condition** que vous avez ajoutée.
1. Dans la barre latérale droite, complétez les formulaires dans les onglets **Paramètre** et **Détails**. Pour plus d'informations sur les champs de ces onglets, consultez [sagemaker.workflow.condition\$1step. ConditionStep](https://sagemaker.readthedocs.io/en/stable/workflows/pipelines/sagemaker.workflow.pipelines.html#sagemaker.workflow.condition_step.ConditionStep).
1. Si le canevas inclut une étape qui précède immédiatement l’étape **Condition** que vous avez ajoutée, cliquez et faites glisser le curseur de cette étape vers l’étape **Condition** pour créer une périphérie.
1. Si le canevas inclut une étape qui suit immédiatement l’étape **Condition** que vous avez ajoutée, cliquez et faites glisser le curseur de l’étape **Condition** vers cette étape pour créer une périphérie.
------
#### [ SageMaker Python SDK ]
L’exemple suivant montre comment créer une définition `ConditionStep`.
**Limites**
+ Pipelines ne prend pas en charge l’utilisation d’étapes de condition imbriquées. Vous ne pouvez pas transmettre une étape de condition comme entrée pour une autre étape de condition.
+ Une étape de condition ne peut pas utiliser des étapes identiques dans les deux branches. Si vous avez besoin de la même fonctionnalité d’étape dans les deux branches, dupliquez l’étape et donnez-lui un nom différent.
```
from sagemaker.workflow.conditions import ConditionLessThanOrEqualTo
from sagemaker.workflow.condition_step import ConditionStep
from sagemaker.workflow.functions import JsonGet
cond_lte = ConditionLessThanOrEqualTo(
left=JsonGet(
step_name=step_eval.name,
property_file=evaluation_report,
json_path="regression_metrics.mse.value"
),
right=6.0
)
step_cond = ConditionStep(
name="AbaloneMSECond",
conditions=[cond_lte],
if_steps=[step_register, step_create_model, step_transform],
else_steps=[]
)
```
Pour plus d'informations sur les `ConditionStep` exigences, consultez le document [sagemaker.workflow.condition\$1step. ConditionStep](https://sagemaker.readthedocs.io/en/stable/workflows/pipelines/sagemaker.workflow.pipelines.html#conditionstep) Référence d'API. Pour plus d'informations sur les conditions prises en charge, consultez *[Amazon SageMaker Pipelines - Conditions](https://sagemaker.readthedocs.io/en/stable/amazon_sagemaker_model_building_pipeline.html#conditions)* dans la documentation du SDK SageMaker AI Python.
------
## Étape de rappel
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 :
+ Pipelines envoie un message à une file d’attente Amazon Simple Queue Service (Amazon SQS) spécifiée par le client. Le message contient un jeton généré par Pipelines et une liste de paramètres d’entrée fournie par le client. Après avoir envoyé le message, Pipelines attend une réponse du client.
+ Le client récupère le message dans la file d’attente Amazon SQS et démarre son processus personnalisé.
+ Lorsque le processus est terminé, le client appelle l'une des personnes suivantes APIs et envoie le jeton généré par les pipelines :
+ [SendPipelineExecutionStepSuccess](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_SendPipelineExecutionStepSuccess.html), ainsi qu'une liste de paramètres de sortie
+ [SendPipelineExecutionStepFailure](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_SendPipelineExecutionStepFailure.html), ainsi qu'une raison de l'échec
+ L’appel d’API entraîne la poursuite du processus de pipeline, ou son échec.
Pour plus d'informations sur les exigences relatives aux `Callback` étapes, consultez le document [sagemaker.workflow.callback\$1step. CallbackStep](https://sagemaker.readthedocs.io/en/stable/workflows/pipelines/sagemaker.workflow.pipelines.html#sagemaker.workflow.callback_step.CallbackStep)documentation. Pour une solution complète, voir [Étendre les SageMaker pipelines pour inclure des étapes personnalisées à l'aide d'étapes de rappel](https://aws.amazon.com/blogs/machine-learning/extend-amazon-sagemaker-pipelines-to-include-custom-steps-using-callback-steps/).
**Important**
`Callback`les étapes ont été introduites dans Amazon SageMaker Python SDK v2.45.0 et Amazon SageMaker Studio Classic v3.6.2. Vous devez mettre à jour Studio Classic avant d’utiliser une étape `Callback` ou le graphique DAG du pipeline ne s’affiche pas. Pour mettre à jour Studio Classic, consultez [Arrêter et mettre à jour Amazon SageMaker Studio Classic](studio-tasks-update-studio.md).
L’exemple suivant montre une mise en œuvre 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={...}
)
'
```
**Note**
Paramètres de sortie pour `CallbackStep` ne doit pas être imbriqué. Par exemple, si vous utilisez un dictionnaire imbriqué comme paramètre de sortie, le dictionnaire est traité comme une chaîne unique (par ex. `{"output1": "{\"nested_output1\":\"my-output\"}"}`). Si vous fournissez une valeur imbriquée, lorsque vous essayez de faire référence à un paramètre de sortie particulier, SageMaker AI génère une erreur client non réessayable.
**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 appelez un processus [StopPipelineExecution](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_StopPipelineExecution.html)de pipeline avec une `Callback` étape en cours d'exécution, Pipelines envoie un message Amazon SQS à la file d'attente SQS. Le corps du message SQS contient un champ **Status** (Statut), qui est défini sur `Stopping`. L’exemple suivant montre le corps d’un message SQS.
```
{
"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 ajouter une logique à votre consommateur de messages Amazon SQS pour effectuer toutes les actions nécessaires (par exemple, le nettoyage des ressources) dès la réception du message. Ajoutez ensuite un appel à `SendPipelineExecutionStepSuccess` ou à `SendPipelineExecutionStepFailure`.
Ce n’est que lorsque Pipelines reçoit l’un de ces appels, qu’il arrête le processus du pipeline.
## Étape Lambda
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. Si vous choisissez d'utiliser une fonction Lambda existante, elle doit être Région AWS identique au pipeline d' SageMaker IA. [Pour un bloc-notes expliquant comment utiliser une étape Lambda dans un pipeline d' SageMaker IA, consultez sagemaker-pipelines-lambda-step .ipynb.](https://github.com/aws/amazon-sagemaker-examples/blob/main/sagemaker-pipelines/tabular/lambda-step/sagemaker-pipelines-lambda-step.ipynb)
**Important**
Les étapes Lambda ont été introduites dans le SDK Amazon SageMaker Python v2.51.0 et dans Amazon SageMaker Studio Classic v3.9.1. Vous devez mettre à jour Studio Classic avant d’utiliser une étape Lambda ou le graphique DAG du pipeline ne s’affiche pas. Pour mettre à jour Studio Classic, consultez [Arrêter et mettre à jour Amazon SageMaker Studio Classic](studio-tasks-update-studio.md).
SageMaker L'IA fournit la classe [SageMaker.Lambda\$1Helper.Lambda pour créer, mettre à jour, invoquer et supprimer des fonctions Lambda](https://sagemaker.readthedocs.io/en/stable/api/utility/lambda_helper.html). `Lambda`porte 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\$1step. LambdaStep](https://sagemaker.readthedocs.io/en/stable/workflows/pipelines/sagemaker.workflow.pipelines.html#sagemaker.workflow.lambda_step.LambdaStep)la classe a un `lambda_func` argument de type`Lambda`. Pour appeler une fonction Lambda existante, la seule exigence est de fournir l'Amazon Resource Name (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 :
+ `zipped_code_dir` – Chemin de la fonction Lambda zippée
`s3_bucket` – Compartiment Amazon S3 où `zipped_code_dir` doit être téléchargé
+ `script` – Chemin d'accès du fichier script de la fonction Lambda
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`.
**Note**
Les paramètres d'entrée et de sortie ne doivent pas être imbriqués. Par exemple, si vous utilisez un dictionnaire imbriqué comme paramètre de sortie, le dictionnaire est traité comme une chaîne unique (par ex. `{"output1": "{\"nested_output1\":\"my-output\"}"}`). Si vous fournissez une valeur imbriquée et que vous essayez d'y faire référence ultérieurement, une erreur client non réessayable est renvoyée.
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 pendant 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 la première éventualité. 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`.
## ClarifyCheck étape
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](https://docs.aws.amazon.com/sagemaker/latest/dg/pipelines-quality-clarify-baseline-lifecycle.html#pipelines-quality-clarify-baseline-calculations) avec la méthode `model.register()` et transmettre la sortie de cette méthode à [Étape du modèle](#step-type-model) en utilisant `[step\$1args](https://sagemaker.readthedocs.io/en/stable/amazon_sagemaker_model_building_pipeline.html#model-step)`. 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](https://docs.aws.amazon.com/sagemaker/latest/dg/model-monitor-create-baseline.html) séparément.
L’étape `ClarifyCheck` peut également extraire des références pour la vérification de dérive à partir du registre de modèles. L'`ClarifyCheck`étape utilise le conteneur préconstruit SageMaker Clarify. Ce conteneur fournit diverses fonctions de surveillance de modèles, y compris des fonctions de suggestion de contraintes et de validation de contraintes par rapport à une référence donnée. Pour de plus amples informations, veuillez consulter [Conteneurs SageMaker Clarify préfabriqués](clarify-processing-job-configure-container.md).
### 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.
+ Vérification de biais des données
+ Vérification de biais de modèle
+ Vérification d’explicabilité de modèle
Pour ce faire, définissez le paramètre `clarify_check_config` avec l’une des valeurs de type de vérification suivantes :
+ `DataBiasCheckConfig`
+ `ModelBiasCheckConfig`
+ `ModelExplainabilityCheckConfig`
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](https://docs.aws.amazon.com/sagemaker/latest/dg/clarify-configure-processing-jobs.html). `ClarifyCheckConfig`et `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é](clarify-processing-job-run.md).
### 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 :
+ `skip_check` : ce paramètre indique si la vérification de dérive par rapport à la référence précédente est ignorée ou non. S'il est défini sur `False`, la référence précédente du type de contrôle configuré doit être disponible.
+ `register_new_baseline` : ce paramètre indique si une référence recalculée est accessible via la propriété `BaselineUsedForDriftCheckConstraints` de l'étape. S'il est défini sur `False`, la référence précédente du type de contrôle configuré doit également être disponible. Vous pouvez y accéder via la propriété `BaselineUsedForDriftCheckConstraints`.
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](pipelines-quality-clarify-baseline-lifecycle.md).
### Utilisation des références
Le cas échéant, vous pouvez spécifier l’élément `model_package_group_name` pour localiser la référence existante. Ensuite, l’étape `ClarifyCheck` tire (pull) l’élément `DriftCheckBaselines` sur le dernier package de modèle approuvé dans le groupe de packages de modèle.
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. ClarifyCheckStep](https://sagemaker.readthedocs.io/en/stable/workflows/pipelines/sagemaker.workflow.pipelines.html#sagemaker.workflow.clarify_check_step.ClarifyCheckStep)dans le *SDK Amazon SageMaker SageMaker AI AI 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](https://github.com/aws/amazon-sagemaker-examples/blob/main/sagemaker-pipelines/tabular/model-monitor-clarify-pipelines/sagemaker-pipeline-model-monitor-clarify-steps.ipynb).
**Example Créer une étape `ClarifyCheck` pour la vérification du biais de données**
```
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"
)
```
## QualityCheck étape
Utilisez l’étape `QualityCheck` pour effectuer des [suggestions de référence](https://docs.aws.amazon.com/sagemaker/latest/dg/model-monitor-create-baseline.html) et des vérifications de dérive par rapport à une référence précédente pour la qualité des données ou la qualité du modèle dans un pipeline. Vous pouvez ensuite générer et [enregistrer vos références](https://docs.aws.amazon.com/sagemaker/latest/dg/pipelines-quality-clarify-baseline-lifecycle.html#pipelines-quality-clarify-baseline-calculations) avec la méthode `model.register()` et transmettre la sortie de cette méthode à [Étape du modèle](#step-type-model) en utilisant `[step\$1args](https://sagemaker.readthedocs.io/en/stable/amazon_sagemaker_model_building_pipeline.html#model-step)`. ]
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 de modèles. Cette `QualityCheck` étape utilise le conteneur prédéfini Amazon SageMaker AI Model Monitor. Ce conteneur propose diverses fonctionnalités de surveillance de modèles, y compris la suggestion de contraintes, la génération de statistiques et la validation de contraintes par rapport à une référence. Pour de plus amples informations, veuillez consulter [Conteneur préfabriqué Amazon SageMaker Model Monitor](model-monitor-pre-built-container.md).
### Configuration de l' QualityCheck étape
Vous pouvez configurer l’étape `QualityCheck` pour effectuer seulement l’un des types de vérification suivants chaque fois qu’elle est utilisée dans un pipeline.
+ Vérification de la qualité des données
+ Vérification de la qualité du modèle
Pour ce faire, définissez le paramètre `quality_check_config` avec l'une des valeurs de type de vérification suivantes :
+ `DataQualityCheckConfig`
+ `ModelQualityCheckConfig`
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. `QualityCheckConfig` et `CheckJobConfig` sont des fonctions d’assistance pour ces configurations. Ces fonctions d’assistance sont alignées sur la façon dont Model Monitor crée une 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, consultez [Création d’une référence](model-monitor-create-baseline.md) et [Création d’une référence de qualité des modèles](model-monitor-model-quality-baseline.md).
### 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 :
+ `skip_check` : ce paramètre indique si la vérification de dérive par rapport à la référence précédente est ignorée ou non. S'il est défini sur `False`, la référence précédente du type de contrôle configuré doit être disponible.
+ `register_new_baseline` : ce paramètre indique si une référence recalculée est accessible via les propriétés `BaselineUsedForDriftCheckConstraints` et `BaselineUsedForDriftCheckStatistics` de l'étape. S'il est défini sur `False`, la référence précédente du type de contrôle configuré doit également être disponible. Vous pouvez y accéder via les propriétés `BaselineUsedForDriftCheckConstraints` et `BaselineUsedForDriftCheckStatistics`.
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](pipelines-quality-clarify-baseline-lifecycle.md).
### Utilisation des références
Vous pouvez spécifier une référence précédente directement via les paramètres `supplied_baseline_statistics` et `supplied_baseline_constraints`. Vous pouvez également spécifier `model_package_group_name`, et l’étape `QualityCheck` tire (pull) l’élément `DriftCheckBaselines` sur le dernier package de modèle approuvé dans le groupe de packages de modèle.
Lorsque vous spécifiez ce qui suit, l’étape `QualityCheck` utilise la référence spécifiée par les `supplied_baseline_constraints` et les `supplied_baseline_statistics` sur le type de vérification de l’étape `QualityCheck`.
+ `model_package_group_name`
+ `supplied_baseline_constraints`
+ `supplied_baseline_statistics`
Pour plus d'informations sur l'utilisation des exigences relatives aux `QualityCheck` étapes, consultez le document [sagemaker.workflow.steps. QualityCheckStep](https://sagemaker.readthedocs.io/en/stable/workflows/pipelines/sagemaker.workflow.pipelines.html#sagemaker.workflow.quality_check_step.QualityCheckStep)dans le *SDK Amazon SageMaker SageMaker AI AI 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](https://github.com/aws/amazon-sagemaker-examples/blob/main/sagemaker-pipelines/tabular/model-monitor-clarify-pipelines/sagemaker-pipeline-model-monitor-clarify-steps.ipynb).
**Example Créer une étape `QualityCheck` pour la vérification de la qualité des données**
```
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"
)
```
## Étape EMR
Utilisez l'étape [EMR](https://docs.aws.amazon.com/emr/latest/ManagementGuide/emr-overview.html) d'Amazon SageMaker Pipelines pour :
+ traiter les [étapes Amazon EMR](https://docs.aws.amazon.com/emr/latest/ManagementGuide/emr-work-with-steps.html) sur un cluster Amazon EMR en cours d’exécution ;
+ demander au pipeline de créer et de gérer un cluster Amazon EMR pour vous.
Pour plus d’informations sur Amazon EMR, consultez [Bien démarrer avec Amazon EMR](https://docs.aws.amazon.com/emr/latest/ManagementGuide/emr-gs.html).
L’étape EMR nécessite que l’élément `EMRStepConfig` inclue l’emplacement du fichier JAR utilisé par le cluster Amazon EMR et tous les arguments à transmettre. Vous fournissez également l’ID de cluster Amazon EMR si vous souhaitez exécuter l’étape sur un cluster EMR en cours d’exécution. Vous pouvez également transmettre la configuration du cluster pour exécuter l’étape EMR sur un cluster qu’il crée, gère et résilie pour vous. Les sections suivantes incluent des exemples et des liens vers des exemples de blocs-notes illustrant les deux méthodes.
**Note**
Les étapes EMR exigent que le rôle transmis à votre pipeline ait des autorisations supplémentaires. Attachez la [politique gérée par AWS : `AmazonSageMakerPipelinesIntegrations`](https://docs.aws.amazon.com/sagemaker/latest/dg/security-iam-awsmanpol-pipelines.html#security-iam-awsmanpol-AmazonSageMakerPipelinesIntegrations) à votre rôle de pipeline, ou assurez-vous que le rôle inclut les autorisations de cette politique.
Si vous traitez une étape EMR sur un cluster en cours d’exécution, vous pouvez uniquement utiliser un cluster dans l’un des états suivants :
`STARTING`
`BOOTSTRAPPING`
`RUNNING`
`WAITING`
Si vous traitez les étapes EMR sur un cluster en cours d’exécution, vous pouvez avoir au maximum 256 étapes EMR dans un état `PENDING` sur un cluster EMR. Les étapes EMR soumises au-delà de cette limite entraînent l'échec de l'exécution du pipeline. Vous pouvez envisager d’utiliser [Politique de nouvelle tentative pour les étapes du pipeline](pipelines-retry-policy.md).
Vous pouvez spécifier l'ID ou la configuration du cluster, mais pas les deux.
L'étape EMR repose sur Amazon EventBridge pour surveiller les modifications de l'étape EMR ou de l'état du cluster. Si vous traitez votre tâche Amazon EMR sur un cluster en cours d’exécution, l’étape EMR utilise la règle `SageMakerPipelineExecutionEMRStepStatusUpdateRule` pour surveiller son état. Si vous traitez votre tâche sur un cluster créé par l’étape EMR, l’étape utilise la règle `SageMakerPipelineExecutionEMRClusterStatusRule` pour surveiller les modifications de l’état du cluster. Si l'une de ces EventBridge règles apparaît dans votre AWS compte, ne la supprimez pas, sinon votre étape EMR risque de ne pas être terminée.
**Ajoutez une étape Amazon EMR à votre pipeline**
Pour ajouter une étape EMR à votre pipeline, procédez comme suit :
+ Ouvrez la console Studio en suivant les instructions de la section [Lancer Amazon SageMaker Studio](https://docs.aws.amazon.com/sagemaker/latest/dg/studio-updated-launch.html).
+ Dans le volet de navigation de gauche, sélectionnez **Pipelines**.
+ Choisissez **Créer**.
+ Choisissez **Vide**.
+ Dans la barre latérale gauche, choisissez **Traiter les données** et faites-le glisser vers le canevas.
+ Dans le canevas, choisissez l’étape **Traiter les données** que vous avez ajoutée.
+ Dans la barre latérale droite, sous mode, choisissez **EMR (**géré).
+ Dans la barre latérale droite, complétez les formulaires dans les onglets **Paramètres et Détails**. Pour plus d'informations sur les champs de ces onglets, consultez [sagemaker.workflow.fail\$1step. EMRstep](https://sagemaker.readthedocs.io/en/stable/workflows/pipelines/sagemaker.workflow.pipelines.html#sagemaker.workflow.emr_step.EMRStep).
**Lancement d’une nouvelle tâche sur un cluster Amazon EMR en cours d’exécution**
Si vous lancez une nouvelle tâche sur un cluster Amazon EMR en cours d’exécution, transmettez l’ID du cluster sous forme de chaîne à l’argument `cluster_id` de `EMRStep`. 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 obtenir un exemple de bloc-notes qui vous guide à travers un exemple complet, consultez [Pipelines EMR Step With Running EMR Cluster](https://github.com/aws/amazon-sagemaker-examples/blob/main/sagemaker-pipelines/tabular/emr-step/sagemaker-pipelines-emr-step-with-running-emr-cluster.ipynb).
**Lancement d’une nouvelle tâche sur un nouveau cluster Amazon EMR**
Pour lancer une nouvelle tâche sur un nouveau cluster créé pour vous par `EMRStep`, fournissez la configuration de votre cluster sous forme de dictionnaire. Le dictionnaire doit avoir la même structure qu'une [RunJobFlow](https://docs.aws.amazon.com/emr/latest/APIReference/API_RunJobFlow.html)demande. Toutefois, n’incluez pas les champs suivants dans la configuration de votre cluster :
+ [`Name`]
+ [`Steps`]
+ [`AutoTerminationPolicy`]
+ [`Instances`][`KeepJobFlowAliveWhenNoSteps`]
+ [`Instances`][`TerminationProtected`]
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](https://docs.aws.amazon.com/emr/latest/APIReference/API_RunJobFlow.html).
L’exemple suivant transmet une configuration de cluster à une définition d’étape EMR. Cela invite l’étape à lancer une nouvelle tâche sur un nouveau cluster EMR. Dans cet exemple, la configuration du cluster EMR inclut des spécifications pour les nœuds primaires et principaux du cluster EMR. Pour plus d’informations sur les types de nœuds Amazon EMR, consultez [Comprendre les types de nœuds : nœuds primaires, principaux et de tâches](https://docs.aws.amazon.com/emr/latest/ManagementGuide/emr-master-core-task-nodes.html).
```
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 obtenir un exemple de bloc-notes qui vous guide à travers un exemple complet, consultez [Pipelines EMR Step With Cluster Lifecycle Management](https://github.com/aws/amazon-sagemaker-examples/blob/main/sagemaker-pipelines/tabular/emr-step/sagemaker-pipelines-emr-step-with-cluster-lifecycle-management.ipynb).
## Étape EMR sans serveur
Pour ajouter une étape EMR sans serveur à votre pipeline, procédez comme suit :
+ Ouvrez la console Studio en suivant les instructions de la section [Lancer Amazon SageMaker Studio](https://docs.aws.amazon.com/sagemaker/latest/dg/studio-updated-launch.html).
+ Dans le volet de navigation de gauche, sélectionnez **Pipelines**.
+ Choisissez **Créer**.
+ Choisissez **Vide**.
+ Dans la barre latérale gauche, choisissez **Traiter les données** et faites-le glisser vers le canevas.
+ Dans le canevas, choisissez l’étape **Traiter les données** que vous avez ajoutée.
+ Dans la barre latérale droite, sous mode, choisissez **EMR (**serverless).
+ Dans la barre latérale droite, complétez les formulaires dans les onglets **Paramètres et Détails**.
## Étape Tâche de bloc-notes
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 [Étape Exécuter le code](#step-type-executecode) pour exécuter votre bloc-notes. Pour plus d'informations sur SageMaker Notebook Jobs, consultez[SageMaker Emplois sur ordinateur portable](notebook-auto-run.md).
Un élément `NotebookJobStep` nécessite au minimum un bloc-notes d’entrée, une URI d’image 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](https://sagemaker.readthedocs.io/en/stable/workflows/pipelines/sagemaker.workflow.pipelines.html#sagemaker.workflow.notebook_job_step.NotebookJobStep).
L’exemple suivant utilise un minimum d’arguments pour définir une `NotebookJobStep`.
```
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 de notes. Par conséquent, suivez le statut d’exécution dans le tableau de bord des tâches de bloc-notes de l’interface utilisateur de Studio Classic en incluant des balises spécifiques avec l’argument `tags`. Pour plus d’informations sur les balises à inclure, consultez [Visualisation de vos tâches de bloc-notes dans le tableau de bord de l’interface utilisateur de Studio](create-notebook-auto-run-sdk.md#create-notebook-auto-run-dash).
De plus, si vous planifiez votre tâche de bloc-notes à l'aide du SDK SageMaker Python, 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 SageMaker tâches de bloc-notes du SDK AI Python](notebook-auto-run-constraints.md#notebook-auto-run-constraints-image-sdk).
## Étape Échec
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 Échec vous permet également d’entrer un message d’erreur personnalisé, indiquant la cause de l’échec de l’exécution du pipeline.
**Note**
Lorsqu’une étape Échec et d’autres étapes du pipeline s’exécutent simultanément, le pipeline ne se termine pas tant que toutes les étapes simultanées ne sont pas terminées.
### Limitations liées à l’utilisation de l’étape Échec
+ Vous ne pouvez pas ajouter d’étape Échec à la liste `DependsOn` d’autres étapes. Pour de plus amples informations, veuillez consulter [Dépendance personnalisée entre étapes](build-and-manage-steps.md#build-and-manage-custom-dependency).
+ Les autres étapes ne peuvent pas faire référence à l’étape Échec. C’est *toujours* la dernière étape de l’exécution d’un pipeline.
+ Vous ne pouvez pas réessayer une exécution de pipeline se terminant par une étape Échec.
Vous pouvez créer l’étape Échec sous la forme d’une chaîne de texte statique. Vous pouvez également utiliser les [Paramètres du pipeline](https://docs.aws.amazon.com/sagemaker/latest/dg/build-and-manage-parameters.html), une opération de [jointure](https://sagemaker.readthedocs.io/en/stable/workflows/pipelines/sagemaker.workflow.pipelines.html?highlight=Join#sagemaker.workflow.functions.Join), ou d’autres [propriétés d’étape](https://docs.aws.amazon.com/sagemaker/latest/dg/build-and-manage-steps.html#build-and-manage-properties) pour créer un message d’erreur plus informatif si vous utilisez le kit SDK.
------
#### [ Pipeline Designer ]
Pour ajouter une étape Échec à votre pipeline, procédez comme suit :
1. Ouvrez la console Studio en suivant les instructions figurant dans [Lancez Amazon SageMaker Studio](studio-updated-launch.md).
1. Dans le volet de navigation de gauche, sélectionnez **Pipelines**.
1. Choisissez **Créer**.
1. Choisissez **Vide**.
1. Dans la barre latérale gauche, choisissez **Échec** et faites-le glisser vers le canevas.
1. Dans le canevas, choisissez l’étape **Échec** que vous avez ajoutée.
1. Dans la barre latérale droite, complétez les formulaires dans les onglets **Paramètre** et **Détails**. Pour plus d'informations sur les champs de ces onglets, consultez [sagemaker.workflow.fail\$1step. FailStep](https://sagemaker.readthedocs.io/en/stable/workflows/pipelines/sagemaker.workflow.pipelines.html#sagemaker.workflow.fail_step.FailStep).
1. Si le canevas inclut une étape qui précède immédiatement l’étape **Échec** que vous avez ajoutée, cliquez et faites glisser le curseur de cette étape vers l’étape **Échec** pour créer une périphérie.
1. Si le canevas inclut une étape qui suit immédiatement l’étape **Échec** que vous avez ajoutée, cliquez et faites glisser le curseur de l’étape **Échec** vers cette étape pour créer une périphérie.
------
#### [ SageMaker Python SDK ]
**Example**
L’exemple d’extrait de code suivant utilise une `FailStep` avec un `ErrorMessage` configuré avec les paramètres du pipeline et une opération de `Join`.
```
from sagemaker.workflow.fail_step import FailStep
from sagemaker.workflow.functions import Join
from sagemaker.workflow.parameters import ParameterInteger
mse_threshold_param = ParameterInteger(name="MseThreshold", default_value=5)
step_fail = FailStep(
name="AbaloneMSEFail",
error_message=Join(
on=" ", values=["Execution failed due to MSE >", mse_threshold_param]
),
)
```
------
# Ajouter une intégration
MLflow l'intégration vous permet de l'utiliser MLflow avec des pipelines pour sélectionner un serveur de suivi ou une application sans serveur, choisir une expérience et enregistrer des métriques.
## Concepts clés
**Création d'applications par** défaut : une MLflow application par défaut est créée lorsque vous entrez dans l'éditeur visuel du pipeline.
**Panneau d'intégrations** - Un nouveau panneau d'intégrations inclut MLflow, que vous pouvez sélectionner et configurer.
**Mettre à jour l'application et expérimenter** : option permettant de remplacer l'application et l'expérience sélectionnées pendant l'exécution du pipeline.
## Comment ça marche
+ Accédez à l'**éditeur visuel Pipeline**
+ Choisissez **Intégration dans** la barre d'outils
+ Choisissez **MLflow**
+ Configurez l' MLflow application et testez
## Exemples de captures d'écran
Panneau latéral des intégrations
![\[La description de la tâche.\]](http://docs.aws.amazon.com/fr_fr/sagemaker/latest/dg/images/screenshot-pipeline-1.png)
MLflow configuration
![\[La description de la tâche.\]](http://docs.aws.amazon.com/fr_fr/sagemaker/latest/dg/images/screenshot-pipeline-2.png)
Comment annuler une expérience lors de l'exécution du pipeline
![\[La description de la tâche.\]](http://docs.aws.amazon.com/fr_fr/sagemaker/latest/dg/images/screenshot-pipeline-3.png)
## Propriétés de l’étape
Utilisez l’attribut `properties` pour ajouter des dépendances de données entre les étapes du pipeline. Pipelines utilise ces dépendances de données pour construire le graphique DAG à partir de la définition du pipeline. Ces propriétés peuvent être référencées en tant que valeurs d’espace réservé et sont résolues lors de l’exécution.
L'`properties`attribut d'une étape Pipelines correspond à l'objet renvoyé par un `Describe` appel pour le type de tâche SageMaker AI correspondant. Pour chaque type de tâche, l’appel `Describe` renvoie l’objet de réponse suivant :
+ `ProcessingStep` – [DescribeProcessingJob](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_DescribeProcessingJob.html)
+ `TrainingStep` – [DescribeTrainingJob](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_DescribeTrainingJob.html)
+ `TransformStep` – [DescribeTransformJob](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_DescribeTransformJob.html)
Pour vérifier quelles propriétés peuvent être référencées pour chaque type d'étape lors de la création de dépendances de données, consultez *[Data Dependency - Property Reference](https://sagemaker.readthedocs.io/en/stable/amazon_sagemaker_model_building_pipeline.html#data-dependency-property-reference)* dans le SDK Amazon [ SageMaker Python](https://sagemaker.readthedocs.io/en/stable).
## Parallélisme d’étapes
Lorsqu’une étape ne dépend d’aucune autre étape, elle est exécutée immédiatement lors de l’exécution du pipeline. Toutefois, l’exécution en parallèle d’un trop grand nombre d’étapes du pipeline peut rapidement épuiser les ressources disponibles. Contrôlez le nombre d'étapes simultanées pour une exécution de pipeline avec `ParallelismConfiguration`.
L'exemple suivant utilise `ParallelismConfiguration` pour définir la limite des étapes simultanées à cinq.
```
pipeline.create(
parallelism_config=ParallelismConfiguration(5),
)
```
## Dépendance des données entre étapes
Vous définissez la structure de votre DAG en spécifiant les relations des données entre les étapes. Pour créer des dépendances de données entre les étapes, transmettez les propriétés d’une étape comme entrée à une autre étape du pipeline. L'étape recevant l'entrée n'est démarrée qu'après l'étape fournissant l'entrée a terminé l'exécution.
Une dépendance de données utilise une JsonPath notation au format suivant. Ce format traverse le fichier de propriétés JSON. Cela signifie que vous pouvez ajouter autant d'**instances que nécessaire pour atteindre la propriété imbriquée souhaitée dans le fichier. Pour plus d'informations sur la JsonPath notation, consultez le [JsonPath dépôt.](https://github.com/json-path/JsonPath)
```
.properties..
```
Ce qui suit montre comment spécifier un compartiment Amazon S3 à l'aide de la propriété `ProcessingOutputConfig` d'une étape de traitement.
```
step_process.properties.ProcessingOutputConfig.Outputs["train_data"].S3Output.S3Uri
```
Pour créer la dépendance des données, transmettez le compartiment à une étape d’entraînement comme suit.
```
from sagemaker.workflow.pipeline_context import PipelineSession
sklearn_train = SKLearn(..., sagemaker_session=PipelineSession())
step_train = TrainingStep(
name="CensusTrain",
step_args=sklearn_train.fit(inputs=TrainingInput(
s3_data=step_process.properties.ProcessingOutputConfig.Outputs[
"train_data"].S3Output.S3Uri
))
)
```
Pour vérifier quelles propriétés peuvent être référencées pour chaque type d'étape lors de la création de dépendances de données, consultez *[Data Dependency - Property Reference](https://sagemaker.readthedocs.io/en/stable/amazon_sagemaker_model_building_pipeline.html#data-dependency-property-reference)* dans le SDK Amazon [ SageMaker Python](https://sagemaker.readthedocs.io/en/stable).
## Dépendance personnalisée entre étapes
Lorsque vous spécifiez une dépendance de données, Pipelines fournit la connexion de données entre les étapes. Par ailleurs, une étape peut accéder aux données d’une étape précédente sans utiliser directement Pipelines. Dans ce cas, vous pouvez créer une dépendance personnalisée qui indique à Pipelines de ne pas démarrer une étape tant qu’une autre étape n’a pas été exécutée. Vous créez une dépendance personnalisée en spécifiant l’attribut `DependsOn` d’une étape.
À titre d’exemple, ce qui suit définit une étape `C` qui démarre seulement après que les deux étapes `A` et `B` terminent leur exécution.
```
{
'Steps': [
{'Name':'A', ...},
{'Name':'B', ...},
{'Name':'C', 'DependsOn': ['A', 'B']}
]
}
```
Pipelines lève une exception de validation si la dépendance crée une dépendance cyclique.
L’exemple suivant crée une étape d’entraînement qui démarre après l’exécution d’une étape de traitement.
```
processing_step = ProcessingStep(...)
training_step = TrainingStep(...)
training_step.add_depends_on([processing_step])
```
L'exemple suivant crée une étape d'entraînement qui ne démarre pas tant que l'exécution de deux étapes de traitement différentes n'est pas terminée.
```
processing_step_1 = ProcessingStep(...)
processing_step_2 = ProcessingStep(...)
training_step = TrainingStep(...)
training_step.add_depends_on([processing_step_1, processing_step_2])
```
Ce qui suit fournit un autre moyen de créer la dépendance personnalisée.
```
training_step.add_depends_on([processing_step_1])
training_step.add_depends_on([processing_step_2])
```
L'exemple suivant crée une étape d'entraînement qui reçoit les entrées d'une étape de traitement et attend que l'exécution d'une autre étape de traitement se termine.
```
processing_step_1 = ProcessingStep(...)
processing_step_2 = ProcessingStep(...)
training_step = TrainingStep(
...,
inputs=TrainingInput(
s3_data=processing_step_1.properties.ProcessingOutputConfig.Outputs[
"train_data"
].S3Output.S3Uri
)
training_step.add_depends_on([processing_step_2])
```
L’exemple suivant montre comment extraire une liste de chaînes des dépendances personnalisées d’une étape.
```
custom_dependencies = training_step.depends_on
```
## Images personnalisées dans une étape
Vous pouvez utiliser n'importe laquelle des [images SageMaker AI Deep Learning Container](https://github.com/aws/deep-learning-containers/blob/master/available_images.md) disponibles lorsque vous créez une étape dans votre pipeline.
Vous pouvez également utiliser votre propre conteneur avec des étapes de pipeline. Comme vous ne pouvez pas créer d’image depuis Studio Classic, vous devez créer votre image à l’aide d’une autre méthode avant de l’utiliser avec Pipelines.
Pour utiliser votre propre conteneur lors de la création des étapes pour votre pipeline, incluez l’URI de l’image dans la définition de l’estimateur. Pour plus d'informations sur l'utilisation de votre propre conteneur avec l' SageMaker IA, consultez la section [Utilisation de conteneurs Docker avec l' SageMaker IA](https://docs.aws.amazon.com/sagemaker/latest/dg/docker-containers.html).
# Lift-and-shift Code Python avec le décorateur @step
Le décorateur `@step` est une fonctionnalité qui convertit votre code de machine learning (ML) local en une ou plusieurs étapes de pipeline. Vous pouvez écrire votre fonction ML comme vous le feriez pour n’importe quel projet ML. Une fois testée localement ou en tant que tâche de formation à l'aide du `@remote` décorateur, vous pouvez convertir la fonction en une étape de pipeline d' SageMaker IA en ajoutant un `@step` décorateur. Vous pouvez alors transmettre à Pipelines la sortie de l’appel de fonction décorée avec `@step` en tant qu’étape pour créer et exécuter un pipeline. Vous pouvez chaîner une série de fonctions avec le décorateur `@step` pour créer également un pipeline de graphe orienté acyclique (DAG) à plusieurs étapes.
La configuration permettant d’utiliser le décorateur `@step` est la même que celle pour utiliser le décorateur `@remote`. Vous pouvez vous reporter à la documentation des fonctions à distance pour plus de détails sur la [configuration de l’environnement](https://docs.aws.amazon.com/sagemaker/latest/dg/train-remote-decorator.html#train-remote-decorator-env) et sur l’[utilisation d’un fichier de configuration](https://docs.aws.amazon.com/sagemaker/latest/dg/train-remote-decorator-config.html) pour définir des valeurs par défaut. Pour plus d’informations sur le décorateur `@step`, consultez [sagemaker.workflow.function\$1step.step](https://sagemaker.readthedocs.io/en/stable/workflows/pipelines/sagemaker.workflow.pipelines.html#sagemaker.workflow.function_step.step).
Pour consulter des exemples de blocs-notes illustrant l’utilisation du décorateur `@step`, consultez les [exemples de blocs-notes du décorateur @step](https://github.com/aws/amazon-sagemaker-examples/tree/main/sagemaker-pipelines/step-decorator).
Les sections suivantes expliquent comment annoter votre code ML local à l’aide d’un décorateur `@step` pour créer une étape, créer et exécuter un pipeline utilisant cette étape, et personnaliser l’expérience pour votre cas d’utilisation.
**Topics**
+ [Création d’un pipeline avec des fonctions décorées avec `@step`](pipelines-step-decorator-create-pipeline.md)
+ [Exécuter un pipeline](pipelines-step-decorator-run-pipeline.md)
+ [Configuration de votre pipeline](pipelines-step-decorator-cfg-pipeline.md)
+ [Bonnes pratiques](pipelines-step-decorator-best.md)
+ [Limitations](pipelines-step-decorator-limit.md)
# Création d’un pipeline avec des fonctions décorées avec `@step`
Vous pouvez créer un pipeline en convertissant les fonctions Python en étapes de pipeline à l’aide du décorateur `@step`, en créant des dépendances entre ces fonctions pour créer un graphe de pipeline (ou graphe orienté acyclique (DAG)) et en transmettant les nœuds terminaux de ce graphe sous forme de liste d’étapes au pipeline. Les sections suivantes expliquent cette procédure en détail avec des exemples.
**Topics**
+ [Conversion d’une fonction en étape](#pipelines-step-decorator-run-pipeline-convert)
+ [Création de dépendances entre les étapes](#pipelines-step-decorator-run-pipeline-link)
+ [Utilisation de `ConditionStep` avec des étapes décorées avec `@step`](#pipelines-step-decorator-condition)
+ [Définition d’un pipeline à l’aide de la sortie `DelayedReturn` des étapes](#pipelines-step-define-delayed)
+ [Création d’un pipeline](#pipelines-step-decorator-pipeline-create)
## Conversion d’une fonction en étape
Pour créer une étape à l’aide du décorateur `@step`, annotez la fonction avec `@step`. L’exemple suivant illustre une fonction décorée avec `@step` qui prétraite les données.
```
from sagemaker.workflow.function_step import step
@step
def preprocess(raw_data):
df = pandas.read_csv(raw_data)
...
return procesed_dataframe
step_process_result = preprocess(raw_data)
```
Lorsque vous invoquez une fonction `@step` décorée, SageMaker AI renvoie une `DelayedReturn` instance au lieu d'exécuter la fonction. Une instance `DelayedReturn` est un proxy pour le retour réel de cette fonction. L’instance `DelayedReturn` peut être transmise à une autre fonction en tant qu’argument ou directement à une instance de pipeline en tant qu’étape. Pour plus d'informations sur la `DelayedReturn` classe, consultez [sagemaker.workflow.function\$1step. DelayedReturn](https://sagemaker.readthedocs.io/en/stable/workflows/pipelines/sagemaker.workflow.pipelines.html#sagemaker.workflow.function_step.DelayedReturn).
## Création de dépendances entre les étapes
Lorsque vous créez une dépendance entre deux étapes, vous créez une connexion entre les étapes de votre graphe de pipeline. Les sections suivantes présentent plusieurs manières de créer une dépendance entre les étapes de votre pipeline.
### Dépendances des données via des arguments d’entrée
Le fait de transmettre la sortie `DelayedReturn` d’une fonction en entrée d’une autre fonction crée automatiquement une dépendance de données dans le graphique DAG du pipeline. Dans l’exemple suivant, la transmission de la sortie `DelayedReturn` de la fonction `preprocess` à la fonction `train` crée une dépendance entre `preprocess` et `train`.
```
from sagemaker.workflow.function_step import step
@step
def preprocess(raw_data):
df = pandas.read_csv(raw_data)
...
return procesed_dataframe
@step
def train(training_data):
...
return trained_model
step_process_result = preprocess(raw_data)
step_train_result = train(step_process_result)
```
L’exemple précédent définit une fonction d’entraînement qui est décorée avec `@step`. Lorsque cette fonction est invoquée, elle reçoit la sortie `DelayedReturn` de l’étape de pipeline de prétraitement en entrée. L’invocation de la fonction d’entraînement renvoie une autre instance `DelayedReturn`. Cette instance contient les informations sur toutes les étapes précédentes, définies dans cette fonction (c’est-à-dire l’étape `preprocess` de cet exemple), qui forment le graphique DAG du pipeline.
Dans l’exemple précédent, la fonction `preprocess` renvoie une valeur unique. Pour des types de retour plus complexes tels que des listes ou des tuples, reportez-vous à [Limitations](pipelines-step-decorator-limit.md).
### Définition de dépendances personnalisées
Dans l’exemple précédent, la fonction `train` a reçu la sortie `DelayedReturn` de `preprocess` et a créé une dépendance. Si vous souhaitez définir cette dépendance de manière explicite sans transmettre la sortie de l’étape précédente, utilisez la fonction `add_depends_on` avec l’étape. Vous pouvez utiliser la fonction `get_step()` pour extraire l’étape sous-jacente depuis son instance `DelayedReturn`, puis appeler `add_depends_on` avec la dépendance en entrée. Pour visualiser la définition de la fonction `get_step()`, consultez [sagemaker.workflow.step\$1outputs.get\$1step](https://sagemaker.readthedocs.io/en/stable/workflows/pipelines/sagemaker.workflow.pipelines.html#sagemaker.workflow.step_outputs.get_step). L’exemple suivant montre comment créer une dépendance entre `preprocess` et `train` en utilisant `get_step()` et `add_depends_on()`.
```
from sagemaker.workflow.step_outputs import get_step
@step
def preprocess(raw_data):
df = pandas.read_csv(raw_data)
...
processed_data = ..
return s3.upload(processed_data)
@step
def train():
training_data = s3.download(....)
...
return trained_model
step_process_result = preprocess(raw_data)
step_train_result = train()
get_step(step_train_result).add_depends_on([step_process_result])
```
### Transmission de données depuis et vers une fonction décorée avec `@step` vers une étape de pipeline traditionnelle
Vous pouvez créer un pipeline qui inclut une étape décorée avec `@step` et une étape de pipeline traditionnelle et qui transmet des données entre les deux. Par exemple, vous pouvez utiliser `ProcessingStep` pour traiter les données et transmettre le résultat à la fonction d’entraînement décorée avec `@step`. Dans l’exemple suivant, une étape d’entraînement décorée avec `@step` fait référence à la sortie d’une étape de traitement.
```
# Define processing step
from sagemaker.sklearn.processing import SKLearnProcessor
from sagemaker.processing import ProcessingInput, ProcessingOutput
from sagemaker.workflow.steps import ProcessingStep
sklearn_processor = SKLearnProcessor(
framework_version='1.2-1',
role='arn:aws:iam::123456789012:role/SagemakerExecutionRole',
instance_type='ml.m5.large',
instance_count='1',
)
inputs = [
ProcessingInput(source=input_data, destination="/opt/ml/processing/input"),
]
outputs = [
ProcessingOutput(output_name="train", source="/opt/ml/processing/train"),
ProcessingOutput(output_name="validation", source="/opt/ml/processing/validation"),
ProcessingOutput(output_name="test", source="/opt/ml/processing/test")
]
process_step = ProcessingStep(
name="MyProcessStep",
step_args=sklearn_processor.run(inputs=inputs, outputs=outputs,code='preprocessing.py'),
)
```
```
# Define a @step-decorated train step which references the
# output of a processing step
@step
def train(train_data_path, test_data_path):
...
return trained_model
step_train_result = train(
process_step.properties.ProcessingOutputConfig.Outputs["train"].S3Output.S3Uri,
process_step.properties.ProcessingOutputConfig.Outputs["test"].S3Output.S3Uri,
)
```
## Utilisation de `ConditionStep` avec des étapes décorées avec `@step`
Pipelines prend en charge une classe `ConditionStep` qui évalue les résultats des étapes précédentes pour décider de l’action à entreprendre dans le pipeline. Vous pouvez également utiliser `ConditionStep` avec une étape décorée avec `@step`. Pour utiliser la sortie d’une étape `@step` quelconque décorée avec `ConditionStep`, entrez la sortie de cette étape en tant qu’argument de `ConditionStep`. Dans l’exemple suivant, l’étape de condition reçoit la sortie de l’étape d’évaluation des modèles décorée avec `@step`.
```
# Define steps
@step(name="evaluate")
def evaluate_model():
# code to evaluate the model
return {
"rmse":rmse_value
}
@step(name="register")
def register_model():
# code to register the model
...
```
```
# Define ConditionStep
from sagemaker.workflow.condition_step import ConditionStep
from sagemaker.workflow.conditions import ConditionGreaterThanOrEqualTo
from sagemaker.workflow.fail_step import FailStep
conditionally_register = ConditionStep(
name="conditional_register",
conditions=[
ConditionGreaterThanOrEqualTo(
# Output of the evaluate step must be json serializable
left=evaluate_model()["rmse"], #
right=5,
)
],
if_steps=[FailStep(name="Fail", error_message="Model performance is not good enough")],
else_steps=[register_model()],
)
```
## Définition d’un pipeline à l’aide de la sortie `DelayedReturn` des étapes
Vous définissez un pipeline de la même manière, que vous utilisiez ou non un décorateur `@step`. Lorsque vous transmettez une instance `DelayedReturn` à votre pipeline, vous n’avez pas besoin de transmettre la liste complète des étapes pour générer le pipeline. Le kit SDK déduit automatiquement les étapes précédentes en fonction des dépendances que vous définissez. Toutes les étapes précédentes des objets `Step` que vous avez transmis au pipeline ou aux objets `DelayedReturn` sont incluses dans le graphique du pipeline. Dans l’exemple suivant, le pipeline reçoit l’objet `DelayedReturn` pour la fonction `train`. SageMaker L'IA ajoute l'`preprocess`étape, en tant qu'étape précédente de`train`, au graphe du pipeline.
```
from sagemaker.workflow.pipeline import Pipeline
pipeline = Pipeline(
name="",
steps=[step_train_result],
sagemaker_session=,
)
```
S’il n’existe aucune donnée ou dépendance personnalisée entre les étapes et que vous exécutez plusieurs étapes en parallèle, le graphe du pipeline comporte plusieurs nœuds terminaux. Transmettez tous ces nœuds terminaux dans une liste à l’argument `steps` de votre définition de pipeline, comme indiqué dans l’exemple suivant :
```
@step
def process1():
...
return data
@step
def process2():
...
return data
step_process1_result = process1()
step_process2_result = process2()
pipeline = Pipeline(
name="",
steps=[step_process1_result, step_process2_result],
sagemaker_session=sagemaker-session,
)
```
Lorsque le pipeline s’exécute, les deux étapes s’exécutent en parallèle.
Vous transmettez uniquement les nœuds terminaux du graphe au pipeline, car ils contiennent des informations sur toutes les étapes précédentes définies par le biais de dépendances de données ou personnalisées. Lorsqu'elle compile le pipeline, l' SageMaker IA déduit également toutes les étapes suivantes qui forment le graphe du pipeline et ajoute chacune d'elles en tant qu'étape distincte au pipeline.
## Création d’un pipeline
Créez un pipeline en appelant `pipeline.create()`, comme illustré dans l’extrait suivant. Pour plus de détails sur `create()`, consultez [sagemaker.workflow.pipeline.Pipeline.create](https://sagemaker.readthedocs.io/en/stable/workflows/pipelines/sagemaker.workflow.pipelines.html#sagemaker.workflow.pipeline.Pipeline.create).
```
role = "pipeline-role"
pipeline.create(role)
```
Lorsque vous appelez`pipeline.create()`, SageMaker AI compile toutes les étapes définies dans le cadre de l'instance de pipeline. SageMaker L'IA télécharge la fonction sérialisée, les arguments et tous les autres artefacts liés aux étapes sur Amazon S3.
Les données résident dans le compartiment S3 selon la structure suivante :
```
s3_root_uri/
pipeline_name/
sm_rf_user_ws/
workspace.zip # archive of the current working directory (workdir)
step_name/
timestamp/
arguments/ # serialized function arguments
function/ # serialized function
pre_train_dependencies/ # any dependencies and pre_execution scripts provided for the step
execution_id/
step_name/
results # returned output from the serialized function including the model
```
`s3_root_uri`est défini dans le fichier de configuration SageMaker AI et s'applique à l'ensemble du pipeline. S'il n'est pas défini, le bucket SageMaker AI par défaut est utilisé.
**Note**
Chaque fois que l' SageMaker IA compile un pipeline, elle SageMaker enregistre les fonctions sérialisées, les arguments et les dépendances des étapes dans un dossier horodaté avec l'heure actuelle. Cela se produit chaque fois que vous exécutez `pipeline.create()`, `pipeline.update()`, `pipeline.upsert()` ou `pipeline.definition()`.
# Exécuter un pipeline
La page suivante décrit comment exécuter un pipeline avec Amazon SageMaker Pipelines, avec des ressources d' SageMaker IA ou localement.
Démarrez une nouvelle exécution de pipeline avec cette `pipeline.start()` fonction, comme vous le feriez pour une exécution de pipeline d' SageMaker IA traditionnelle. Pour en savoir plus sur la fonction `start()`, consultez [sagemaker.workflow.pipeline.Pipeline.start](https://sagemaker.readthedocs.io/en/stable/workflows/pipelines/sagemaker.workflow.pipelines.html#sagemaker.workflow.pipeline.Pipeline.start).
**Note**
Une étape définie à l’aide du décorateur `@step` s’exécute comme tâche d’entraînement. Par conséquent, tenez compte des limitations suivantes :
Limites d’instances et limites de tâches d’entraînement dans vos comptes. Mettez à jour vos limites en conséquence pour éviter tout problème de limitation ou de limite de ressources.
Les coûts monétaires associés à chaque exécution d’une étape d’entraînement dans le pipeline. Pour plus de détails, consultez les [ SageMaker tarifs Amazon](https://aws.amazon.com/sagemaker/pricing/).
## Extraction des résultats d’un pipeline exécuté localement
Pour afficher le résultat de n’importe quelle étape d’une exécution de pipeline, utilisez [execution.result()](https://sagemaker.readthedocs.io/en/stable/workflows/pipelines/sagemaker.workflow.pipelines.html#sagemaker.workflow.pipeline._PipelineExecution.result ), comme indiqué dans l’extrait suivant :
```
execution = pipeline.start()
execution.result(step_name="train")
```
**Note**
Pipelines ne prend pas en charge `execution.result()` en mode local.
Vous ne pouvez récupérer les résultats que pour une seule étape à la fois. Si le nom de l'étape a été généré par l' SageMaker IA, vous pouvez le récupérer en appelant `list_steps` comme suit :
```
execution.list_step()
```
## Exécution d’un pipeline localement
Vous pouvez exécuter un pipeline avec des étapes décorées avec `@step` localement, comme vous le feriez pour des étapes de pipeline traditionnelles. Pour plus de détails sur les exécutions de pipelines en mode local, consultez [Exécution de pipelines en mode local](pipelines-local-mode.md). Pour utiliser le mode local, fournissez un élément `LocalPipelineSession` à la place d’un élément `SageMakerSession` dans la définition de votre pipeline, comme illustré dans l’exemple suivant :
```
from sagemaker.workflow.function_step import step
from sagemaker.workflow.pipeline import Pipeline
from sagemaker.workflow.pipeline_context import LocalPipelineSession
@step
def train():
training_data = s3.download(....)
...
return trained_model
step_train_result = train()
local_pipeline_session = LocalPipelineSession()
local_pipeline = Pipeline(
name="",
steps=[step_train_result],
sagemaker_session=local_pipeline_session # needed for local mode
)
local_pipeline.create(role_arn="role_arn")
# pipeline runs locally
execution = local_pipeline.start()
```
# Configuration de votre pipeline
Il est conseillé d'utiliser le fichier de configuration SageMaker AI pour définir les valeurs par défaut du pipeline. Pour plus d'informations sur le fichier de configuration SageMaker AI, consultez [Configuration et utilisation des valeurs par défaut avec le SDK SageMaker Python](https://sagemaker.readthedocs.io/en/stable/overview.html#configuring-and-using-defaults-with-the-sagemaker-python-sdk). Toute configuration ajoutée au fichier de configuration s’applique à toutes les étapes du pipeline. Si vous souhaitez remplacer les options de l’une des étapes, fournissez de nouvelles valeurs dans les arguments du décorateur `@step`. La rubrique suivante explique comment configurer un fichier de configuration.
La configuration du décorateur `@step` dans le fichier de configuration est identique à celle du décorateur `@remote`. Pour configurer l’ARN du rôle de pipeline et les balises de pipeline dans le fichier de configuration, utilisez la section `Pipeline` illustrée dans l’extrait de code suivant :
```
SchemaVersion: '1.0'
SageMaker:
Pipeline:
RoleArn: 'arn:aws:iam::555555555555:role/IMRole'
Tags:
- Key: 'tag_key'
Value: 'tag_value'
```
Vous pouvez également remplacer la plupart des valeurs par défaut que vous pouvez définir dans le fichier de configuration, en transmettant de nouvelles valeurs au décorateur `@step`. Par exemple, vous pouvez remplacer le type d’instance défini dans le fichier de configuration pour votre étape de prétraitement, comme illustré dans l’exemple suivant :
```
@step(instance_type="ml.m5.large")
def preprocess(raw_data):
df = pandas.read_csv(raw_data)
...
return procesed_dataframe
```
Quelques arguments ne figurent pas dans la liste des paramètres du `@step` décorateur. Ils peuvent être configurés pour l'ensemble du pipeline uniquement via le fichier de configuration SageMaker AI. Ils sont répertoriés comme suit :
+ `sagemaker_session`(`sagemaker.session.Session`) : session d' SageMaker IA sous-jacente à laquelle l' SageMaker IA délègue les appels de service. Si elle n’est pas spécifiée, une session est créée à l’aide d’une configuration par défaut, comme suit :
```
SageMaker:
PythonSDK:
Modules:
Session:
DefaultS3Bucket: 'default_s3_bucket'
DefaultS3ObjectKeyPrefix: 'key_prefix'
```
+ `custom_file_filter` (`CustomFileFilter)` : objet `CustomFileFilter` qui spécifie les répertoires et fichiers locaux à inclure dans l’étape du pipeline. S’il n’est pas spécifié, la valeur utilisée par défaut est `None`. Pour que `custom_file_filter` prenne effet, vous devez définir `IncludeLocalWorkdir` sur `True`. L’exemple suivant montre une configuration qui ignore tous les fichiers de bloc-notes, ainsi que les fichiers et répertoires nommés `data`.
```
SchemaVersion: '1.0'
SageMaker:
PythonSDK:
Modules:
RemoteFunction:
IncludeLocalWorkDir: true
CustomFileFilter:
IgnoreNamePatterns: # files or directories to ignore
- "*.ipynb" # all notebook files
- "data" # folder or file named "data"
```
Pour plus de détails sur la façon d’utiliser `IncludeLocalWorkdir` avec `CustomFileFilter`, consultez [Utilisation d’un code modulaire avec le décorateur @remote](train-remote-decorator-modular.md).
+ `s3_root_uri (str)`: le dossier racine Amazon S3 dans lequel SageMaker AI télécharge les archives de code et les données. S'il n'est pas spécifié, le bucket SageMaker AI par défaut est utilisé.
+ `s3_kms_key (str)` : clé utilisée pour chiffrer les données d’entrée et de sortie. Vous ne pouvez configurer cet argument que dans le fichier de configuration SageMaker AI et l'argument s'applique à toutes les étapes définies dans le pipeline. S’il n’est pas spécifié, la valeur utilisée par défaut est `None`. Consultez l’extrait de code suivant pour un exemple de configuration de clé KMS S3 :
```
SchemaVersion: '1.0'
SageMaker:
PythonSDK:
Modules:
RemoteFunction:
S3KmsKeyId: 's3kmskeyid'
S3RootUri: 's3://amzn-s3-demo-bucket/my-project
```
# Bonnes pratiques
Les sections suivantes suggèrent de bonnes pratiques à suivre lorsque vous utilisez le décorateur `@step` pour les étapes de votre pipeline.
## Utilisation de groupes à chaud
Pour accélérer les exécutions des étapes du pipeline, utilisez la fonctionnalité des groupes à chaud fournie pour les tâches d’entraînement. Vous pouvez activer la fonctionnalité des groupes à chaud en fournissant l’argument `keep_alive_period_in_seconds` au décorateur `@step`, comme illustré dans l’extrait de code suivant :
```
@step(
keep_alive_period_in_seconds=900
)
```
Pour plus d’informations sur les groupes d’instances pré-initialisées, consultez [SageMaker Piscines d'eau chaude gérées par l'IA](train-warm-pools.md).
## Structuration de votre répertoire
Il est conseillé d’utiliser des modules de code lors de l’utilisation du décorateur `@step`. Placez le module `pipeline.py`, dans lequel vous invoquez les fonctions d’étape et définissez le pipeline, à la racine de l’espace de travail. La structure recommandée se présente comme suit :
```
.
├── config.yaml # the configuration file that define the infra settings
├── requirements.txt # dependencies
├── pipeline.py # invoke @step-decorated functions and define the pipeline here
├── steps/
| ├── processing.py
| ├── train.py
├── data/
├── test/
```
# Limitations
Les sections suivantes décrivent les limites dont vous devez tenir compte lorsque vous utilisez le décorateur `@step` pour les étapes de votre pipeline.
## Limites des arguments des fonctions
Lorsque vous transmettez un argument d’entrée à la fonction décorée avec `@step`, les limites suivantes s’appliquent :
+ Vous pouvez transmettre les objets `DelayedReturn`, `Properties` (d’étapes d’autres types), `Parameter` et `ExecutionVariable` aux fonctions décorées avec `@step` en tant qu’arguments. Mais les fonctions décorées avec `@step` ne prennent pas en charge les objets `JsonGet` et `Join` en tant qu’arguments.
+ Vous ne pouvez pas accéder directement à une variable de pipeline à partir d’une fonction `@step`. L’exemple suivant génère une erreur :
```
param = ParameterInteger(name="", default_value=10)
@step
def func():
print(param)
func() # this raises a SerializationError
```
+ Vous ne pouvez pas imbriquer une variable de pipeline dans un autre objet et la transmettre à une fonction `@step`. L’exemple suivant génère une erreur :
```
param = ParameterInteger(name="", default_value=10)
@step
def func(arg):
print(arg)
func(arg=(param,)) # this raises a SerializationError because param is nested in a tuple
```
+ Les entrées et sorties d’une fonction étant sérialisées, le type de données pouvant être transmis en entrée ou en sortie à partir d’une fonction est soumis à des restrictions. Consultez la section *Sérialisation et désérialisation des données* de [Invoquer une fonction à distance](train-remote-decorator-invocation.md) pour plus de détails. Les mêmes restrictions s’appliquent aux fonctions décorées avec `@step`.
+ Tout objet doté d’un client boto ne peut pas être sérialisé. Vous ne pouvez donc pas transmettre de tels objets en entrée ou en sortie à partir d’une fonction décorée avec `@step`. Par exemple, les classes clientes du SDK SageMaker Python telles que `Estimator``Predictor`, et ne `Processor` peuvent pas être sérialisées.
## Importations de fonctions
Vous devez importer les bibliothèques requises par l’étape à l’intérieur plutôt qu’à l’extérieur de la fonction. Si vous les importez à l’échelle mondiale, vous risquez une collision d’importation lors de la sérialisation de la fonction. Par exemple, `sklearn.pipeline.Pipeline` pourrait être remplacé par `sagemaker.workflow.pipeline.Pipeline`.
## Référencement des membres enfants de la valeur de retour de la fonction
Si vous référencez des membres enfants d’une valeur de retour d’une fonction décorée avec `@step`, les limites suivantes s’appliquent :
+ Vous pouvez référencer les membres enfants avec `[]` si l’objet `DelayedReturn` représente un tuple, une liste ou un dict, comme indiqué dans l’exemple suivant :
```
delayed_return[0]
delayed_return["a_key"]
delayed_return[1]["a_key"]
```
+ Vous ne pouvez pas décompresser la sortie d’un tuple ou d’une liste, car la longueur exacte du tuple ou de la liste sous-jacent(e) ne peut pas être connue lorsque vous invoquez la fonction. L’exemple suivant génère une erreur :
```
a, b, c = func() # this raises ValueError
```
+ Vous ne pouvez pas itérer sur un objet `DelayedReturn`. L’exemple suivant déclenche une erreur :
```
for item in func(): # this raises a NotImplementedError
```
+ Vous ne pouvez pas référencer des membres enfants arbitraires avec « `.` ». L’exemple suivant génère une erreur :
```
delayed_return.a_child # raises AttributeError
```
## Fonctionnalités de pipeline existantes qui ne sont pas prises en charge
Vous ne pouvez pas utiliser le décorateur `@step` avec les fonctionnalités de pipeline suivantes :
+ [Mise en cache des étapes d’un pipeline](https://docs.aws.amazon.com/sagemaker/latest/dg/pipelines-caching.html)
+ [Fichiers de propriétés](https://docs.aws.amazon.com/sagemaker/latest/dg/build-and-manage-propertyfile.html#build-and-manage-propertyfile-property)
# Transmission de données entre les étapes
Lorsque vous créez des pipelines avec Amazon SageMaker Pipelines, vous devrez peut-être transmettre des données d'une étape à l'autre. Par exemple, vous souhaiterez peut-être utiliser les artefacts de modèle générés par une étape d’entraînement comme entrée pour une étape d’évaluation ou de déploiement des modèles. Vous pouvez utiliser cette fonctionnalité pour créer des étapes de pipeline interdépendantes et générer vos flux de travail ML.
Lorsque vous avez besoin d’extraire des informations de la sortie d’une étape du pipeline, vous pouvez utiliser `JsonGet`. `JsonGet` vous aide à extraire des informations d’Amazon S3 ou des fichiers de propriétés. Les sections suivantes expliquent les méthodes que vous pouvez utiliser pour extraire les résultats des étapes avec `JsonGet`.
## Transmission des données entre les étapes avec Amazon S3
Vous pouvez utiliser `JsonGet` dans une étape `ConditionStep` pour récupérer la sortie JSON directement depuis Amazon S3. L’URI Amazon S3 peut être une fonction `Std:Join` contenant des chaînes primitives, des variables d’exécution de pipeline ou des paramètres de pipeline. L’exemple suivant montre comment vous pouvez utiliser `JsonGet` dans une étape `ConditionStep` :
```
# Example json file in s3 bucket generated by a processing_step
{
"Output": [5, 10]
}
cond_lte = ConditionLessThanOrEqualTo(
left=JsonGet(
step_name="",
s3_uri="",
json_path="Output[1]"
),
right=6.0
)
```
Si vous utilisez `JsonGet` avec un chemin Amazon S3 dans l’étape de condition, vous devez explicitement ajouter une dépendance entre l’étape de condition et l’étape générant la sortie JSON. Dans l’exemple suivant, l’étape de condition est créée avec une dépendance sur l’étape de traitement :
```
cond_step = ConditionStep(
name="",
conditions=[cond_lte],
if_steps=[fail_step],
else_steps=[register_model_step],
depends_on=[processing_step],
)
```
## Transmission de données entre les étapes à l’aide de fichiers de propriétés
Utilisez des fichiers de propriétés pour stocker des informations à partir de la sortie d'une étape de traitement. Ceci est particulièrement utile lors de l’analyse des résultats d’une étape de traitement pour décider comment une étape conditionnelle doit être exécutée. La `JsonGet` fonction traite un fichier de propriétés et vous permet d'utiliser la JsonPath notation pour interroger le fichier JSON de propriétés. Pour plus d'informations sur la JsonPath notation, consultez le [JsonPath dépôt.](https://github.com/json-path/JsonPath)
Pour stocker un fichier de propriétés en vue d’une utilisation ultérieure, vous devez d’abord créer une instance `PropertyFile` au format suivant. Le `path` Paramètre est le nom du fichier JSON dans lequel le fichier de propriétés est enregistré. Tout `output_name` doit correspondre à l'interface `output_name` du `ProcessingOutput` que vous définissez dans votre étape de traitement. Cela permet au fichier de propriétés de capturer la `ProcessingOutput` dans l’étape.
```
from sagemaker.workflow.properties import PropertyFile
= PropertyFile(
name="",
output_name="",
path=""
)
```
Lorsque vous créez votre `ProcessingStep` instance, ajoutez le `property_files` paramètre pour répertorier tous les fichiers de paramètres que le service Amazon SageMaker Pipelines doit indexer. Cela enregistre le fichier de propriétés en vue d’une utilisation ultérieure.
```
property_files=[]
```
Pour utiliser votre fichier de propriétés dans une étape de condition, ajoutez le `property_file` à la condition que vous transmettez à votre étape de condition, comme illustré dans l’exemple suivant pour interroger le fichier JSON pour votre propriété souhaitée à l’aide du paramètre `json_path`.
```
cond_lte = ConditionLessThanOrEqualTo(
left=JsonGet(
step_name=step_eval.name,
property_file=,
json_path="mse"
),
right=6.0
)
```
Pour des exemples plus détaillés, consultez *[Property File](https://sagemaker.readthedocs.io/en/stable/amazon_sagemaker_model_building_pipeline.html#property-file)* dans le [SDK Amazon SageMaker Python](https://sagemaker.readthedocs.io/en/stable).
# Mise en cache des étapes du pipeline
Dans Amazon SageMaker Pipelines, vous pouvez utiliser la mise en cache des étapes pour économiser du temps et des ressources lorsque vous réexécutez des pipelines. La mise en cache des étapes réutilise la sortie d’une exécution précédente réussie d’une étape (au lieu de la recalculer) lorsque l’étape présente la même configuration et les mêmes entrées. Cela vous aide à obtenir des résultats cohérents lors de réexécutions du pipeline avec des paramètres identiques. La rubrique suivante vous montre comment configurer et activer la mise en cache des étapes pour vos pipelines.
Lorsque vous utilisez la mise en cache de signature d’étape, Pipelines tente de trouver une exécution précédente de votre étape de pipeline actuelle avec les mêmes valeurs pour certains attributs. S’il les trouve, Pipelines propage les sorties de l’exécution précédente au lieu de recalculer l’étape. Les attributs cochés sont spécifiques au type d’étape et sont répertoriés dans [Attributs de clé de cache par défaut par type d’étape du pipeline](pipelines-default-keys.md).
Vous devez vous inscrire à la mise en cache d'étape, car elle est désactivée par défaut. Lorsque vous activez la mise en cache d'étape, vous devez également définir un délai d'expiration. Ce délai définit la période au cours de laquelle une exécution précédente peut rester candidate à une réutilisation.
La mise en cache des étapes ne prend en compte que les exécutions réussies ; elle ne réutilise jamais celles ayant échoué. Lorsqu’il existe plusieurs exécutions réussies au cours de la période d’expiration, Pipelines utilise le résultat pour l’exécution réussie la plus récente. Si aucune exécution réussie ne correspond au délai imparti, Pipelines réexécute l’étape. Si l’exécuteur trouve une exécution précédente qui répond aux critères mais qui est toujours en cours, les deux étapes poursuivent leur exécution et mettent à jour le cache si elles réussissent.
La mise en cache d'étape n'est limitée que pour les pipelines individuels, de sorte que vous ne pouvez pas réutiliser une étape d'un autre pipeline même s'il existe une correspondance de signature d'étape.
La mise en cache d’étape est disponible pour les types d’étape suivants :
+ [Traitement](build-and-manage-steps-types.md#step-type-processing)
+ [Entraînement](build-and-manage-steps-types.md#step-type-training)
+ [Réglage](build-and-manage-steps-types.md#step-type-tuning)
+ [AutoML](build-and-manage-steps-types.md#step-type-automl)
+ [Transformation](build-and-manage-steps-types.md#step-type-transform)
+ [`ClarifyCheck`](build-and-manage-steps-types.md#step-type-clarify-check)
+ [`QualityCheck`](build-and-manage-steps-types.md#step-type-quality-check)
+ [EMR](build-and-manage-steps-types.md#step-type-emr)
**Topics**
+ [Activer la mise en cache des étapes](pipelines-caching-enabling.md)
+ [Désactiver la mise en cache des étapes](pipelines-caching-disabling.md)
+ [Attributs de clé de cache par défaut par type d’étape du pipeline](pipelines-default-keys.md)
+ [Contrôle d’accès aux données mises en cache](pipelines-access-control.md)
# Activer la mise en cache des étapes
Pour activer la mise en cache des étapes, vous devez ajouter une propriété `CacheConfig` à la définition de l’étape. Les propriétés `CacheConfig` utilisent le format suivant dans le fichier de définition de pipeline :
```
{
"CacheConfig": {
"Enabled": false,
"ExpireAfter": "