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.
# Définition d’un pipeline
Pour orchestrer vos flux de travail avec Amazon SageMaker Pipelines, vous devez générer un graphe acyclique dirigé (DAG) sous la forme d'une définition de pipeline JSON. Le graphique DAG spécifie les différentes étapes impliquées dans votre processus ML, telles que le prétraitement des données, l’entraînement des modèles, l’évaluation des modèles et le déploiement des modèles, ainsi que les dépendances et le flux de données entre ces étapes. La rubrique suivante explique comment générer une définition de pipeline.
Vous pouvez générer votre définition de pipeline JSON à l'aide du SDK SageMaker Python ou de la fonctionnalité de conception de pipeline par glisser-déposer visuelle d'Amazon Studio. SageMaker L’image suivante est une représentation du graphique DAG du pipeline que vous créez dans ce didacticiel :
Le pipeline que vous définissez dans les sections suivantes résout un problème de régression visant à déterminer l’âge d’un ormeau en fonction de ses dimensions physiques. Pour un bloc-notes Jupyter exécutable incluant le contenu de ce didacticiel, voir [ Orchestrating Jobs with Amazon Model Building Pipelines. SageMaker ](https://sagemaker-examples.readthedocs.io/en/latest/sagemaker-pipelines/tabular/abalone_build_train_deploy/sagemaker-pipelines-preprocess-train-evaluate-batch-transform.html)
**Note**
Vous pouvez faire référence à l'emplacement du modèle en tant que propriété de l'étape d'apprentissage, comme indiqué dans l'exemple de [ CustomerChurn pipeline ](https://github.com/aws-samples/customer-churn-sagemaker-pipelines-sample/blob/main/pipelines/customerchurn/pipeline.py) de bout en bout sur Github.
**Topics**
## Définition d’un pipeline (concepteur de pipeline)
La procédure pas à pas suivante vous guide tout au long des étapes de la création d’un pipeline simple à l’aide du concepteur de pipeline par glisser-déposer. Si vous devez suspendre ou mettre fin à votre session d’édition de pipeline dans le concepteur visuel à un moment quelconque, cliquez sur l’option **Exporter**. Cela vous permet de télécharger la définition actuelle de votre pipeline dans votre environnement local. Plus tard, lorsque vous souhaitez reprendre le processus d’édition du pipeline, vous pouvez importer le même fichier de définition JSON dans le concepteur visuel.
### Création d’une étape de traitement
Pour créer une étape de traitement des données, 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 **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. Pour ajouter un jeu de données d’entrée, choisissez **Ajouter** sous **Données (entrée)** dans la barre latérale droite et sélectionnez un jeu de données.
1. Pour ajouter un emplacement pour enregistrer les jeux de données de sortie, choisissez **Ajouter** sous **Données (sortie)** dans la barre latérale droite et naviguez jusqu’à la destination.
1. Complétez les champs restants dans la barre latérale droite. 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).
### Création d’une étape d’entraînement
Pour configurer une étape d’entraînement des modèles, procédez comme suit :
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. Pour ajouter un jeu de données d’entrée, choisissez **Ajouter** sous **Données (entrée)** dans la barre latérale droite et sélectionnez un jeu de données.
1. Pour choisir un emplacement où enregistrer les artefacts de votre modèle, entrez un URI Amazon S3 dans le champ **Emplacement (URI S3)** ou choisissez **Parcourir S3** pour accéder à l’emplacement de destination.
1. Complétez les champs restants dans la barre latérale droite. 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. Cliquez sur le curseur et faites le glisser de l’étape **Traiter les données** que vous avez ajoutée dans la section précédente vers l’étape **Entraîner le modèle** pour créer une périphérie reliant les deux étapes.
### Création d’un modèle de package avec une étape d’enregistrement du modèle
Pour créer un package de modèle avec une étape d’enregistrement de modèle, procédez comme suit :
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. Pour sélectionner un modèle à enregistrer, choisissez **Ajouter** sous **Modèle (entrée)**.
1. Choisissez **Créer un groupe de modèles** pour ajouter votre modèle à un nouveau groupe de modèles.
1. Complétez les champs restants dans la barre latérale droite. Pour plus d'informations sur les champs de ces onglets, consultez [ sagemaker.workflow.step\_collections. RegisterModel](https://sagemaker.readthedocs.io/en/stable/workflows/pipelines/sagemaker.workflow.pipelines.html#sagemaker.workflow.step_collections.RegisterModel).
1. Cliquez sur le curseur et faites-le glisser depuis l’étape **Entraîner le modèle** que vous avez ajoutée dans la section précédente jusqu’à l’étape **Enregistrer le modèle** pour créer une périphérie reliant les deux étapes.
### Déploiement du modèle sur un point de terminaison avec une étape Déployer le modèle (point de terminaison)
Pour déployer votre modèle à l’aide d’une étape de déploiement de modèle, procédez comme suit :
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. Pour choisir un modèle à déployer, choisissez **Ajouter** sous **Modèle (entrée)**.
1. Choisissez la case d’option **Créer un point de terminaison** pour créer un nouveau point de terminaison.
1. Entrez un **nom** et une **description** pour votre point de terminaison.
1. Cliquez sur le curseur et faites-le glisser depuis l’étape **Enregistrer le modèle** que vous avez ajoutée dans la section précédente jusqu’à l’étape **Déployer le modèle (point de terminaison)** pour créer une périphérie reliant les deux étapes.
1. Complétez les champs restants dans la barre latérale droite.
### Définition des paramètres du pipeline
Vous pouvez configurer un ensemble de paramètres de pipeline dont les valeurs peuvent être mises à jour pour chaque exécution. Pour définir les paramètres du pipeline et définir les valeurs par défaut, cliquez sur l’icône représentant un engrenage en bas du concepteur visuel.
### Enregistrement du pipeline
Après avoir saisi toutes les informations requises pour créer votre pipeline, cliquez sur **Enregistrer** en bas du concepteur visuel. Cela valide votre pipeline pour détecter toute erreur potentielle lors de l’exécution et vous en informe. L’opération **Enregistrer** ne réussira pas tant que vous n’aurez pas corrigé toutes les erreurs signalées par les contrôles de validation automatisés. Si vous souhaitez reprendre les modifications ultérieurement, vous pouvez enregistrer votre pipeline en cours sous forme de définition JSON dans votre environnement local. Vous pouvez exporter votre pipeline sous la forme d’un fichier de définition JSON en cliquant sur le bouton **Exporter** en bas du concepteur visuel. Plus tard, pour reprendre la mise à jour de votre pipeline, chargez ce fichier de définition JSON en cliquant sur le bouton **Importer**.
## Définir un pipeline (SDK SageMaker Python)
### Conditions préalables
Pour exécuter le didacticiel suivant, effectuez les opérations suivantes :
+ Configurez votre instance de bloc-notes comme indiqué dans [Création d’une instance de bloc-notes](https://docs.aws.amazon.com/sagemaker/latest/dg/howitworks-create-ws.html). Cela donne à votre rôle les autorisations nécessaires pour lire et écrire sur Amazon S3, et pour créer des tâches de formation, de transformation par lots et de traitement dans SageMaker AI.
+ Accordez à votre bloc-notes des autorisations pour obtenir et transmettre son propre rôle comme indiqué dans [Modification d’une politique d’autorisations de rôle](https://docs.aws.amazon.com/IAM/latest/UserGuide/roles-managingrole-editing-console.html#roles-modify_permissions-policy). Ajoutez l'extrait JSON suivant pour attacher cette politique à votre rôle. ``Remplacez-le par l'ARN utilisé pour créer votre instance de bloc-notes.
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Action": [
"iam:GetRole",
"iam:PassRole"
],
"Resource": "arn:aws:iam::{{111122223333}}:role/{{role-name}}"
}
]
}
```
------
+ Faites confiance au SageMaker responsable du service d'IA en suivant les étapes décrites dans [ Modification d'une politique de confiance des rôles](https://docs.aws.amazon.com/IAM/latest/UserGuide/roles-managingrole-editing-cli.html#roles-managingrole_edit-trust-policy-cli). Ajoutez le fragment d’instruction suivante à la relation de confiance de votre rôle :
```
{
"Sid": "",
"Effect": "Allow",
"Principal": {
"Service": "sagemaker.amazonaws.com"
},
"Action": "sts:AssumeRole"
}
```
#### Configuration de votre environnement
Créez une nouvelle session d' SageMaker IA à l'aide du bloc de code suivant. Cela renvoie le rôle ARN pour la session. Cet ARN de rôle doit être l'ARN du rôle d'exécution que vous avez configuré comme condition préalable.
```
import boto3
import sagemaker
from sagemaker.core.workflow.pipeline_context import PipelineSession
from sagemaker.core.helper.session_helper import Session, get_execution_role
region = boto3.Session().region_name
sagemaker_session = Session()
role = get_execution_role()
default_bucket = sagemaker_session.default_bucket()
pipeline_session = PipelineSession()
model_package_group_name = f"AbaloneModelPackageGroupName"
```
### Création d’un pipeline
**Important**
Les politiques IAM personnalisées qui permettent à Amazon SageMaker Studio ou Amazon SageMaker Studio Classic de créer SageMaker des ressources Amazon doivent également autoriser l'ajout de balises à ces ressources. L’autorisation d’ajouter des balises aux ressources est requise, car Studio et Studio Classic balisent automatiquement toutes les ressources qu’ils créent. Si une politique IAM autorise Studio et Studio Classic à créer des ressources mais n'autorise pas le balisage, des erreurs peuvent se produire lors de la tentative de création de ressources. AccessDenied Pour de plus amples informations, veuillez consulter [Fournir des autorisations pour le balisage des ressources d' SageMaker IA](security_iam_id-based-policy-examples.md#grant-tagging-permissions).
[AWS politiques gérées pour Amazon SageMaker AI](security-iam-awsmanpol.md)qui accordent des autorisations pour créer des SageMaker ressources incluent déjà des autorisations pour ajouter des balises lors de la création de ces ressources.
Exécutez les étapes suivantes à partir de votre instance de bloc-notes SageMaker AI pour créer un pipeline comprenant des étapes de prétraitement, de formation, d'évaluation, d'évaluation conditionnelle et d'enregistrement de modèles.
**Note**
Vous pouvez utiliser [ ExecutionVariables ](https://sagemaker.readthedocs.io/en/stable/workflows/pipelines/sagemaker.workflow.pipelines.html#execution-variables) et la [ fonction ](https://sagemaker.readthedocs.io/en/stable/workflows/pipelines/sagemaker.workflow.pipelines.html#execution-variables) Join pour spécifier votre emplacement de sortie.
#### Étape 1 : Téléchargement du jeu de données
Ce bloc-notes utilise le jeu de données Ormeau de machine learning de l'UCI. Le jeu de données contient les fonctions suivantes :
+ `length` – Mesure de la coquille la plus longue de l'ormeau.
+ `diameter` – Le diamètre de l'ormeau perpendiculaire à sa longueur.
+ `height` – La hauteur de l'ormeau avec de la viande dans la coquille.
+ `whole_weight` – Le poids de l'ormeau entier.
+ `shucked_weight` – Le poids de la viande retirée de l'ormeau.
+ `viscera_weight` – Poids des viscères d'ormeau après saignement.
+ `shell_weight` – Poids de la coquille de l'ormeau après avoir enlevé et séché la viande.
+ `sex` – Le sexe de l'ormeau. Une valeur « M », « F » ou « I », où « I » est un jeune ormeau.
+ `rings` – Le nombre d'anneaux dans la coquille de l'ormeau.
Le nombre d’anneaux dans la coquille de l’ormeau est une bonne approximation de son âge en utilisant la formule `age=rings + 1.5`. Toutefois, l’obtention de ce nombre est une tâche longue. Vous devez couper la coquille à travers le cône, tacher la section et compter le nombre d’anneaux à l’aide d’un microscope. Toutefois, les autres mesures physiques sont plus faciles à obtenir. Ce bloc-notes utilise le jeu de données pour créer un modèle prédictif des anneaux variables à l’aide des autres mesures physiques.
**Pour télécharger le jeu de données**
1. Téléchargez le jeu de données dans le compartiment Amazon S3 par défaut de votre compte.
```
!mkdir -p data
local_path = "data/abalone-dataset.csv"
s3 = boto3.resource("s3")
s3.Bucket(f"sagemaker-servicecatalog-seedcode-{region}").download_file(
"dataset/abalone-dataset.csv",
local_path
)
base_uri = f"s3://{default_bucket}/abalone"
input_data_uri = sagemaker.s3.S3Uploader.upload(
local_path=local_path,
desired_s3_uri=base_uri,
)
print(input_data_uri)
```
1. Téléchargez un deuxième jeu de données pour la transformation par lots après la création de votre modèle.
```
local_path = "data/abalone-dataset-batch.csv"
s3 = boto3.resource("s3")
s3.Bucket(f"sagemaker-servicecatalog-seedcode-{region}").download_file(
"dataset/abalone-dataset-batch",
local_path
)
base_uri = f"s3://{default_bucket}/abalone"
batch_data_uri = sagemaker.s3.S3Uploader.upload(
local_path=local_path,
desired_s3_uri=base_uri,
)
print(batch_data_uri)
```
#### Étape 2 : Définition des paramètres de pipeline
```
from sagemaker.core.workflow.parameters import (
ParameterInteger,
ParameterString,
)
processing_instance_count = ParameterInteger(name="ProcessingInstanceCount", default_value=1)
model_approval_status = ParameterString(name="ModelApprovalStatus", default_value="PendingManualApproval")
input_data = ParameterString(name="InputData", default_value=input_data_uri)
batch_data = ParameterString(name="BatchData", default_value=batch_data_uri)
```
#### Étape 3 : Définition d’une étape de traitement pour l’ingénierie des caractéristiques
Cette section vous indique comment créer une étape de traitement afin de préparer les données du jeu de données en vue de l'entraînement.
**Pour créer une étape de traitement**
1. Créez une instance d'un processeur à transmettre à l'étape de traitement.
```
from sagemaker.core.processing import Processor
from sagemaker.core import image_uris
framework_version = "0.23-1"
sklearn_image_uri = image_uris.retrieve(
framework="sklearn",
region=region,
version=framework_version,
instance_type="ml.m5.xlarge"
)
sklearn_processor = Processor(
image_uri=sklearn_image_uri,
instance_type="ml.m5.xlarge",
instance_count=processing_instance_count,
base_job_name="sklearn-abalone-process",
sagemaker_session=pipeline_session,
role=role,
)
```
1. Créer une étape de traitement.
```
from sagemaker.core.processing import ProcessingInput, ProcessingOutput
from sagemaker.mlops.workflow.steps import ProcessingStep
processor_args = sklearn_processor.run(
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")
],
code="abalone/preprocessing.py",
)
step_process = ProcessingStep(name="AbaloneProcess", step_args=processor_args)
```
#### Étape 4 : Définition d’une étape d’entraînement
Cette section montre comment utiliser l'algorithme SageMaker AI XGBoost pour entraîner un modèle à partir des données d'entraînement sorties des étapes de traitement.
**Pour définir une étape d’entraînement**
1. Spécifiez le chemin d'accès au modèle dans lequel vous souhaitez enregistrer les modèles de l'entraînement.
```
model_path = f"s3://{default_bucket}/AbaloneTrain"
```
1. Configurez un estimateur d'entraînement pour l'algorithme XGBoost et le jeu de données en entrée.
```
from sagemaker.train import ModelTrainer
from sagemaker.train.configs import Compute, OutputDataConfig
from sagemaker.core import image_uris
image_uri = image_uris.retrieve(
framework="xgboost",
region=region,
version="1.0-1",
py_version="py3",
instance_type="ml.m5.xlarge"
)
xgb_train = ModelTrainer(
training_image=image_uri,
compute=Compute(instance_type="ml.m5.xlarge", instance_count=1),
output_data_config=OutputDataConfig(s3_output_path=model_path),
hyperparameters={
"objective": "reg:linear",
"num_round": "50",
"max_depth": "5",
"eta": "0.2",
"gamma": "4",
"min_child_weight": "6",
"subsample": "0.7",
"silent": "0"
},
sagemaker_session=pipeline_session,
role=role,
)
```
1. Créez un `TrainingStep` à l'aide de l'instance d'entraînement et des propriétés du`ProcessingStep`.
```
from sagemaker.train.configs import InputData
from sagemaker.mlops.workflow.steps import TrainingStep
train_args = xgb_train.train(
input_data_config=[
InputData(
channel_name="train",
data_source=step_process.properties.ProcessingOutputConfig.Outputs[
"train"
].S3Output.S3Uri,
content_type="text/csv"
),
InputData(
channel_name="validation",
data_source=step_process.properties.ProcessingOutputConfig.Outputs[
"validation"
].S3Output.S3Uri,
content_type="text/csv"
)
],
)
step_train = TrainingStep(name="AbaloneTrain", step_args=train_args)
```
#### Étape 5 : Définition d’une étape de traitement pour l’évaluation des modèles
Cette section vous explique comment créer une étape de traitement pour évaluer la précision du modèle.
**Pour définir une étape de traitement pour l’évaluation du modèle**
1. Créez une instance de `Processor` pour évaluation.
```
from sagemaker.core.processing import Processor
script_eval = Processor(
image_uri=image_uri,
command=["python3"],
instance_type="ml.m5.xlarge",
instance_count=1,
base_job_name="script-abalone-eval",
sagemaker_session=pipeline_session,
role=role,
)
```
1. Créez un `ProcessingStep` à l'aide de l'instance du processeur, des canaux d'entrée et de sortie et du `evaluation.py` script.
```
from sagemaker.core.workflow.properties import PropertyFile
evaluation_report = PropertyFile(
name="EvaluationReport",
output_name="evaluation",
path="evaluation.json"
)
eval_args = script_eval.run(
inputs=[
ProcessingInput(
source=step_train.properties.ModelArtifacts.S3ModelArtifacts,
destination="/opt/ml/processing/model"
),
ProcessingInput(
source=step_process.properties.ProcessingOutputConfig.Outputs[
"test"
].S3Output.S3Uri,
destination="/opt/ml/processing/test"
)
],
outputs=[
ProcessingOutput(output_name="evaluation", source="/opt/ml/processing/evaluation"),
],
code="abalone/evaluation.py",
)
step_eval = ProcessingStep(
name="AbaloneEval",
step_args=eval_args,
property_files=[evaluation_report],
)
```
#### Étape 6 : Définir un CreateModelStep pour la transformation par lots
Cette section montre comment créer un modèle d' SageMaker IA à partir des résultats de l'étape d'entraînement.
**Pour définir un CreateModelStep pour la transformation par lots**
+ Créez un modèle d' SageMaker IA et une étape de modélisation.
```
from sagemaker.serve import ModelBuilder
from sagemaker.mlops.workflow.model_step import ModelStep
model_builder = ModelBuilder(
image_uri=image_uri,
s3_model_data_url=step_train.properties.ModelArtifacts.S3ModelArtifacts,
role_arn=role,
sagemaker_session=pipeline_session,
)
step_create_model = ModelStep(
name="AbaloneCreateModel",
step_args=model_builder.build(),
)
```
#### Étape 7 : Définissez un TransformStep pour effectuer une transformation par lots
Cette section explique comment créer une `TransformStep` pour effectuer une transformation par lots sur un jeu de données après l’entraînement du modèle.
**Pour définir un TransformStep pour effectuer une transformation par lots**
+ Créez une instance de transformateur et un`TransformStep`.
```
from sagemaker.core.transformer import Transformer
from sagemaker.mlops.workflow.steps import TransformStep
transformer = Transformer(
model_name=step_create_model.properties.ModelName,
instance_type="ml.m5.xlarge",
instance_count=1,
output_path=f"s3://{default_bucket}/AbaloneTransform",
sagemaker_session=pipeline_session,
)
transform_args = transformer.transform(data=batch_data)
step_transform = TransformStep(
name="AbaloneTransform",
step_args=transform_args,
)
```
#### Étape 8 : définir une RegisterModel étape pour créer un package de modèles
Cette section explique comment enregistrer un modèle. Le résultat est un package de modèles pour l'inférence.
**Pour définir une étape d'enregistrement de modèle afin de créer un package de modèles**
+ Créez une étape d'enregistrement modèle.
```
from sagemaker.core.model_metrics import MetricsSource, ModelMetrics
from sagemaker.mlops.workflow.model_step import ModelStep
from sagemaker.serve import ModelBuilder
model_metrics = ModelMetrics(
model_statistics=MetricsSource(
s3_uri="{{{}/evaluation.json}}".format(
step_eval.arguments["ProcessingOutputConfig"]["Outputs"][0]["S3Output"]["S3Uri"]
),
content_type="application/json"
)
)
model_builder = ModelBuilder(
image_uri=image_uri,
s3_model_data_url=step_train.properties.ModelArtifacts.S3ModelArtifacts,
role_arn=role,
sagemaker_session=pipeline_session,
)
register_args = model_builder.register(
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
)
step_register = ModelStep(
name="{{AbaloneRegisterModel}}",
step_args=register_args,
)
```
#### Étape 9 : Définition d’une étape de condition pour vérifier l’exactitude du modèle
Une étape `ConditionStep` permet à Pipelines de prendre en charge l’exécution conditionnelle dans le graphique DAG de votre pipeline en fonction de la condition des propriétés d’étape.
**Pour définir une étape de condition pour vérifier la précision du modèle**
+ Définissez une condition et construisez-en une`ConditionStep`.
```
from sagemaker.core.workflow.conditions import ConditionLessThanOrEqualTo
from sagemaker.mlops.workflow.condition_step import ConditionStep
from sagemaker.core.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=[],
)
```
#### Étape 10 : créer un pipeline
Maintenant que vous avez créé toutes les étapes, combinez-les dans un pipeline.
**Pour créer un pipeline**
1. Définissez les éléments suivants pour votre pipeline :`name`, `parameters`, et `steps`.
```
from sagemaker.mlops.workflow.pipeline import Pipeline
pipeline_name = f"AbalonePipeline"
pipeline = Pipeline(
name=pipeline_name,
parameters=[
processing_instance_count,
model_approval_status,
input_data,
batch_data,
],
steps=[step_process, step_train, step_eval, step_cond],
)
```
1. (Facultatif) Examinez la définition de pipeline JSON pour vous assurer qu’elle est bien formée.
```
import json
json.loads(pipeline.definition())
```
Cette définition de pipeline est prête à être soumise à SageMaker AI. Dans le didacticiel suivant, vous soumettrez ce pipeline à SageMaker AI et vous lancerez une exécution.
## Définition d’un pipeline (JSON)
Vous pouvez également utiliser [boto3](https://boto3.amazonaws.com/v1/documentation/api/latest/reference/services/sagemaker.html#SageMaker.Client.create_pipeline) ou [CloudFormation](https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-sagemaker-pipeline.html) pour créer un pipeline. La création d’un pipeline nécessite une définition de pipeline, qui est un objet JSON définissant chaque étape du pipeline. Le SageMaker SDK offre un moyen simple de créer la définition du pipeline, que vous pouvez utiliser avec n'importe laquelle des API mentionnées précédemment pour créer le pipeline lui-même. Sans utiliser le SDK, les utilisateurs doivent écrire la définition JSON brute pour créer le pipeline sans aucune des vérifications d'erreur fournies par le SDK SageMaker Python. Pour voir le schéma de la définition JSON du pipeline, voir Schéma JSON de définition du pipeline [ SageMaker AI](https://aws-sagemaker-mlops.github.io/sagemaker-model-building-pipeline-definition-JSON-schema/). L'exemple de code suivant montre un exemple d'objet JSON de définition de pipeline SageMaker AI :
```
{'Version': '2020-12-01',
'Metadata': {},
'Parameters': [{'Name': 'ProcessingInstanceType',
'Type': 'String',
'DefaultValue': 'ml.m5.xlarge'},
{'Name': 'ProcessingInstanceCount', 'Type': 'Integer', 'DefaultValue': 1},
{'Name': 'TrainingInstanceType',
'Type': 'String',
'DefaultValue': 'ml.m5.xlarge'},
{'Name': 'ModelApprovalStatus',
'Type': 'String',
'DefaultValue': 'PendingManualApproval'},
{'Name': 'ProcessedData',
'Type': 'String',
'DefaultValue': '{{S3_URL}}',
{'Name': 'InputDataUrl',
'Type': 'String',
'DefaultValue': '{{S3_URL}}',
'PipelineExperimentConfig': {'ExperimentName': {'Get': 'Execution.PipelineName'},
'TrialName': {'Get': 'Execution.PipelineExecutionId'}},
'Steps': [{'Name': 'ReadTrainDataFromFS',
'Type': 'Processing',
'Arguments': {'ProcessingResources': {'ClusterConfig': {'InstanceType': 'ml.m5.4xlarge',
'InstanceCount': 2,
'VolumeSizeInGB': 30}},
'AppSpecification': {'ImageUri': '{{IMAGE_URI}}',
'ContainerArguments': [....]},
'RoleArn': '{{ROLE}}',
'ProcessingInputs': [...],
'ProcessingOutputConfig': {'Outputs': [.....]},
'StoppingCondition': {'MaxRuntimeInSeconds': 86400}},
'CacheConfig': {'Enabled': True, 'ExpireAfter': '30d'}},
...
...
...
}
```
**Étape suivante :** [Exécuter un pipeline](run-pipeline.md)