As traduções são geradas por tradução automática. Em caso de conflito entre o conteúdo da tradução e da versão original em inglês, a versão em inglês prevalecerá.
# Adicionar uma etapa
O seguinte descreve os requisitos de cada tipo de etapa e fornece um exemplo de implantação da etapa, além de como adicionar a etapa a um Pipelines: Não são implantações funcionais porque não fornecem os recursos e as entradas necessários. Para obter um tutorial que implementa essas etapas, consulte [Ações de pipelines](pipelines-build.md).
**nota**
Você também pode criar uma etapa a partir do seu código de machine learning convertendo-o em uma etapa do Pipelines com o decorador `@step`. Para obter mais informações, consulte [decorador @step](#step-type-custom).
O Amazon SageMaker Pipelines oferece suporte aos seguintes tipos de etapas:
+ [Executar código](#step-type-executecode)
[Processamento](#step-type-processing)
+ [Treinamento](#step-type-training)
+ [Ajustar](#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)
+ [Transformação](#step-type-transform)
+ [Condição](#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)
+ [Trabalho de caderno](#step-type-notebook-job)
+ [Falha](#step-type-fail)
## decorador @step
Se você quiser orquestrar um trabalho de ML personalizado que aproveite recursos avançados de SageMaker IA ou outros AWS serviços na interface de usuário do Pipelines de arrastar e soltar, use o. [Executar a etapa de código](#step-type-executecode)
Você pode criar uma etapa a partir do código de machine learning local usando o decorador `@step`. Depois de testar seu código, você pode converter a função em uma etapa do pipeline de SageMaker IA anotando-a com o `@step` decorador. O Pipelines cria e executa um pipeline quando você passa o resultado da função decorada por `@step` como uma etapa para o seu pipeline. Você também pode criar um pipeline DAG de várias etapas que inclua uma ou mais funções `@step` decoradas, bem como etapas tradicionais do pipeline de SageMaker IA. Para obter mais detalhes sobre como criar uma etapa com o decorador `@step`, consulte [Lift-and-shift Código Python com o decorador @step](pipelines-step-decorator.md).
## Executar a etapa de código
Na interface de usuário de arrastar e soltar do Pipelines, você pode usar uma etapa **Executar código** para executar seu próprio código como uma etapa do pipeline. Você pode fazer upload de uma função Python, script ou caderno para ser executado como parte do seu pipeline. Você deve usar essa etapa se quiser orquestrar um trabalho de ML personalizado que aproveite recursos avançados de SageMaker IA ou outros serviços. AWS
A etapa **Execute Code** carrega arquivos em seu bucket padrão do Amazon S3 para Amazon SageMaker AI. Esse bucket pode não ter as permissões necessárias Cross-Origin de compartilhamento de recursos (CORS) definidas. Para saber mais sobre como configurar as permissões CORS, consulte [Requisito do CORS para dados de imagem de entrada](sms-cors-update.md).
A etapa **Execute Code** usa um trabalho SageMaker de treinamento da Amazon para executar seu código. Certifique-se de que seu perfil do IAM tenha as permissões da API `sagemaker:DescribeTrainingJob` e `sagemaker:CreateTrainingJob`. Para saber mais sobre todas as permissões necessárias para a Amazon SageMaker AI e como configurá-las, consulte[Permissões da API Amazon SageMaker AI: referência de ações, permissões e recursos](api-permissions-reference.md).
Para adicionar uma etapa de execução de código a um pipeline usando o Pipeline Designer, faça o seguinte:
1. Abra o console do Amazon SageMaker Studio seguindo as instruções em[Inicie o Amazon SageMaker Studio](studio-updated-launch.md).
1. No painel de navegação à esquerda, selecione **Pipelines**.
1. Escolha **Criar**.
1. Escolha **Em branco**.
1. Na barra lateral esquerda, escolha **Executar código** e arraste-o para o canvas.
1. No canvas, escolha a etapa **Executar código** que você adicionou.
1. Na barra lateral direita, preencha os formulários nas guias **Configuração** e **Detalhes**.
1. Você pode carregar um único arquivo para executar ou carregar uma pasta compactada contendo vários artefatos.
1. Para uploads de um único arquivo, você pode fornecer parâmetros opcionais para cadernos, funções Python ou scripts.
1. Ao fornecer funções em Python, um manipulador deve ser fornecido no formato `file.py:{{}}`
1. Para uploads de pastas compactadas, caminhos relativos para seu código devem ser fornecidos e, opcionalmente, você pode fornecer caminhos para um arquivo `requirements.txt` ou script de inicialização dentro da pasta compactada.
1. Se o canvas incluir alguma etapa que preceda imediatamente a etapa **Executar código** que você adicionou, clique e arraste o cursor da etapa até a etapa **Executar código** para criar uma borda.
1. Se o canvas incluir alguma etapa que suceda imediatamente a etapa **Executar código** que você adicionou, clique e arraste o cursor da etapa **Executar código** até a etapa para criar uma borda. As saídas das etapas de **Executar código** podem ser referenciadas para funções do Python.
## Processamento de etapas
Use uma etapa de processamento para criar um trabalho de processamento para processamento de dados. Para obter mais informações sobre trabalhos de processamento, consulte [Processar dados e avaliar modelos](https://docs.aws.amazon.com/sagemaker/latest/dg/processing-job.html).
------
#### [ Pipeline Designer ]
Para adicionar uma etapa de processamento a um pipeline usando o Pipeline Designer, faça o seguinte:
1. Abra o console do Amazon SageMaker Studio seguindo as instruções em[Inicie o Amazon SageMaker Studio](studio-updated-launch.md).
1. No painel de navegação à esquerda, selecione **Pipelines**.
1. Escolha **Criar**.
1. Na barra lateral esquerda, escolha **Processar dados** e arraste-o para o canvas.
1. No canvas, escolha a etapa **Processar dados** que você adicionou.
1. Na barra lateral direita, preencha os formulários nas guias **Configuração** e **Detalhes**. Para obter informações sobre os campos nessas guias, consulte [sagemaker.workflow.steps. ProcessingStep](https://sagemaker.readthedocs.io/en/stable/workflows/pipelines/sagemaker.workflow.pipelines.html#sagemaker.workflow.steps.ProcessingStep).
1. Se o canvas incluir alguma etapa que preceda imediatamente a etapa **Processar dados** que você adicionou, clique e arraste o cursor da etapa até a etapa **Processar dados** para criar uma borda.
1. Se o canvas incluir alguma etapa que suceda imediatamente a etapa **Processar dados** que você adicionou, clique e arraste o cursor da etapa **Processar dados** até a etapa para criar uma borda.
------
#### [ SageMaker Python SDK ]
Uma etapa de processamento requer um processador, um script Python que defina o código de processamento, as saídas para processamento e os argumentos do trabalho. O exemplo a seguir mostra como criar uma definição de `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")
)
```
**Passe parâmetros de runtime**
O exemplo a seguir mostra como passar parâmetros de tempo de execução de um PySpark processador para um`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,
)
```
Para obter mais informações sobre os requisitos das etapas de processamento, consulte [sagemaker.workflow.steps. ProcessingStep](https://sagemaker.readthedocs.io/en/stable/workflows/pipelines/sagemaker.workflow.pipelines.html#sagemaker.workflow.steps.ProcessingStep)documentação. Para ver um exemplo detalhado, consulte o caderno de exemplo [Orchestrate Jobs to Training 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). A seção *Definir uma etapa de processamento para engenharia de atributos* inclui mais informações.
------
## Etapa de treinamento
Você usa uma etapa de treinamento para criar um trabalho de treinamento para treinar um modelo. Para obter mais informações sobre trabalhos de treinamento, consulte [Treinar um modelo com a Amazon SageMaker AI](https://docs.aws.amazon.com/sagemaker/latest/dg/how-it-works-training.html).
Uma etapa de treinamento requer um estimador, bem como entradas de dados de treinamento e validação.
------
#### [ Pipeline Designer ]
Para adicionar uma etapa de treinamento a um pipeline usando o Pipeline Designer, faça o seguinte:
1. Abra o console do Amazon SageMaker Studio seguindo as instruções em[Inicie o Amazon SageMaker Studio](studio-updated-launch.md).
1. No painel de navegação à esquerda, selecione **Pipelines**.
1. Escolha **Criar**.
1. Escolha **Em branco**.
1. Na barra lateral esquerda, escolha **Treinar modelo** e arraste-o até o canvas.
1. No canvas, escolha a etapa **Treinar modelo** que você adicionou.
1. Na barra lateral direita, preencha os formulários nas guias **Configuração** e **Detalhes**. Para obter informações sobre os campos nessas guias, consulte [sagemaker.workflow.steps. TrainingStep](https://sagemaker.readthedocs.io/en/stable/workflows/pipelines/sagemaker.workflow.pipelines.html#sagemaker.workflow.steps.TrainingStep).
1. Se o canvas incluir alguma etapa que preceda imediatamente a etapa **Treinar modelo** que você adicionou, clique e arraste o cursor da etapa até a etapa **Treinar modelo** para criar uma borda.
1. Se o canvas incluir alguma etapa que suceda imediatamente a etapa **Treinar modelo** que você adicionou, clique e arraste o cursor da etapa **Treinar modelo** até a etapa para criar uma borda.
------
#### [ SageMaker Python SDK ]
O exemplo a seguir mostra como criar uma definição de `TrainingStep`. Para obter mais informações sobre os requisitos das etapas de treinamento, consulte [sagemaker.workflow.steps. TrainingStep](https://sagemaker.readthedocs.io/en/stable/workflows/pipelines/sagemaker.workflow.pipelines.html#sagemaker.workflow.steps.TrainingStep)documentação.
```
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,
)
```
------
## Etapa de ajuste
Você usa uma etapa de ajuste para criar um trabalho de ajuste de hiperparâmetros, também conhecido como otimização de hiperparâmetros (HPO). Um trabalho de ajuste de hiperparâmetros executa vários trabalhos de treinamento, cada um produzindo uma versão do modelo. Para obter mais informações sobre ajuste de hiperparâmetros, consulte [Ajuste automático do modelo com SageMaker IA](automatic-model-tuning.md).
O trabalho de ajuste está associado ao experimento de SageMaker IA do pipeline, com os trabalhos de treinamento criados como testes. Para obter mais informações, consulte [Integração de experimentos](pipelines-experiments.md).
Uma etapa de ajuste requer uma [HyperparameterTuner](https://sagemaker.readthedocs.io/en/stable/api/training/tuner.html)e entradas de treinamento. Você pode retreinar trabalhos de ajuste anteriores especificando o parâmetro `warm_start_config` do `HyperparameterTuner`. Para obter mais informações sobre ajuste de hiperparâmetros e inicialização a quente, consulte [Executar um trabalho de ajuste de hiperparâmetros de inicialização a quente](automatic-model-tuning-warm-start.md).
[Você usa o método [get\_top\_model\_s3\_uri do sagemaker.workflow.steps](https://sagemaker.readthedocs.io/en/stable/workflows/pipelines/sagemaker.workflow.pipelines.html#sagemaker.workflow.steps.TuningStep.get_top_model_s3_uri). TuningStep](https://sagemaker.readthedocs.io/en/stable/workflows/pipelines/sagemaker.workflow.pipelines.html#sagemaker.workflow.steps.TuningStep)classe para obter o artefato do modelo de uma das versões do modelo de melhor desempenho. Para um notebook que mostra como usar uma etapa de ajuste em um pipeline de SageMaker IA, consulte [sagemaker-pipelines-tuning-step.ipynb](https://github.com/aws/amazon-sagemaker-examples/blob/main/sagemaker-pipelines/tabular/tuning-step/sagemaker-pipelines-tuning-step.ipynb).
**Importante**
As etapas de ajuste foram introduzidas no Amazon SageMaker Python SDK v2.48.0 e no Amazon Studio Classic v3.8.0. SageMaker Você deve atualizar o Studio Classic antes de usar uma etapa de ajuste; caso contrário, o DAG do pipeline não será exibido. Para atualizar o Studio Classic, consulte [Desligue e atualize o Amazon SageMaker Studio Classic](studio-tasks-update-studio.md).
Os exemplos a seguir mostram como criar uma definição de `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}}"))
)
```
**Obtenha a melhor versão do modelo**
O exemplo a seguir mostra como obter a melhor versão do modelo do trabalho de ajuste usando o método `get_top_model_s3_uri`. No máximo, as 50 versões com melhor desempenho estão disponíveis, classificadas de acordo com [HyperParameterTuningJobObjective](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_HyperParameterTuningJobObjective.html). O `top_k` argumento é um índice das versões, onde `top_k=0` está a versão com melhor desempenho e `top_k=49` a versão com pior desempenho.
```
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()
),
...
)
```
Para obter mais informações sobre os requisitos das etapas de ajuste, consulte [sagemaker.workflow.steps. TuningStep](https://sagemaker.readthedocs.io/en/stable/workflows/pipelines/sagemaker.workflow.pipelines.html#sagemaker.workflow.steps.TuningStep)documentação.
## Fine-tuning etapa
Fine-tuning treina um modelo básico pré-treinado da Amazon SageMaker JumpStart em um novo conjunto de dados. Esse processo, também conhecido como aprendizado por transferência, pode produzir modelos precisos com conjuntos de dados menores e menos tempo de treinamento. Ao ajustar um modelo, você pode usar o conjunto de dados padrão ou escolher seus próprios dados. Para saber mais sobre como ajustar um modelo básico a partir de JumpStart, consulte. [Fine-Tune um modelo](jumpstart-fine-tune.md)
A etapa de ajuste fino usa um trabalho de SageMaker treinamento da Amazon para personalizar seu modelo. Certifique-se de que seu perfil do IAM tenha as permissões de API `sagemaker:DescribeTrainingJob` e `sagemaker:CreateTrainingJob` para executar o trabalho de ajuste fino em seu pipeline. Para saber mais sobre as permissões necessárias para o Amazon SageMaker AI e como configurá-las, consulte[Permissões da API Amazon SageMaker AI: referência de ações, permissões e recursos](api-permissions-reference.md).
Para adicionar uma etapa **Fine-tune do modelo** ao seu pipeline usando o editor de arrastar e soltar, siga estas etapas:
1. Abra o console do Studio seguindo as instruções em [Inicie o Amazon SageMaker Studio](studio-updated-launch.md).
1. No painel de navegação à esquerda, selecione **Pipelines**.
1. Escolha **Criar**.
1. Escolha **Em branco**.
1. Na barra lateral esquerda, escolha o **Fine-tune modelo** e arraste-o até a tela.
1. Na tela, escolha a etapa do **Fine-tune modelo** que você adicionou.
1. Na barra lateral direita, preencha os formulários nas guias **Configuração** e **Detalhes**.
1. Se a tela incluir qualquer etapa que preceda imediatamente a etapa do **Fine-tunemodelo** que você adicionou, clique e arraste o cursor da etapa até a etapa do **Fine-tune modelo** para criar uma borda.
1. Se a tela incluir qualquer etapa que suceda imediatamente à etapa do **Fine-tunemodelo** que você adicionou, clique e arraste o cursor da etapa do **Fine-tune modelo** até a etapa para criar uma borda.
## Etapa do AutoML
Use a API [AutoML](https://sagemaker.readthedocs.io/en/stable/api/training/automl.html) para criar um trabalho do AutoML para treinar automaticamente um modelo. Para obter mais informações sobre trabalhos do AutoML, consulte [Automatize o desenvolvimento de modelos com o Amazon Autopilot](https://docs.aws.amazon.com/sagemaker/latest/dg/autopilot-automate-model-development.html). SageMaker
**nota**
Atualmente, a etapa do AutoML oferece suporte somente ao [modo de treinamento de agrupamento](https://docs.aws.amazon.com/sagemaker/latest/dg/autopilot-model-support-validation.html).
Os exemplos a seguir mostram como criar uma definição usando `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,
)
```
**Obtenha a melhor versão do modelo**
A etapa do AutoML treina automaticamente vários candidatos a modelos. Obtenha o modelo com a melhor métrica objetiva do trabalho do AutoML usando o método `get_best_auto_ml_model` da seguinte forma: Você também deve usar um `role` do IAM para acessar os artefatos do modelo.
```
best_model = step_automl.get_best_auto_ml_model({{role=}})
```
Para obter mais informações, consulte a etapa do [AutoML](https://sagemaker.readthedocs.io/en/stable/workflows/pipelines/sagemaker.workflow.pipelines.html#sagemaker.workflow.automl_step.AutoMLStep) no SDK do Python SageMaker .
## Etapa do modelo
Use a `ModelStep` para criar ou registrar um modelo de SageMaker IA. Para obter mais informações sobre `ModelStep` os requisitos, consulte o [sagemaker.workflow.model\_step. ModelStep](https://sagemaker.readthedocs.io/en/stable/workflows/pipelines/sagemaker.workflow.pipelines.html#sagemaker.workflow.model_step.ModelStep)documentação.
### Criar um modelo
Você pode usar `ModelStep` a para criar um modelo de SageMaker IA. A `ModelStep` exige artefatos do modelo e informações sobre o tipo de instância de SageMaker IA que você precisa usar para criar o modelo. Para obter mais informações sobre modelos de SageMaker IA, consulte [Treinar um modelo com o Amazon SageMaker AI](https://docs.aws.amazon.com/sagemaker/latest/dg/how-it-works-training.html).
O exemplo a seguir mostra como criar uma definição de `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"),
)
```
### Registrar um modelo
Você pode usar `ModelStep` a para registrar um `sagemaker.model.Model` ou um `sagemaker.pipeline.PipelineModel` no Amazon SageMaker Model Registry. Um `PipelineModel` representa um pipeline de inferência, que é um modelo composto por uma sequência linear de contêineres que processam solicitações de inferência. Para obter mais informações sobre como registrar um modelo, consulte [Implantação do registro do modelo com o Model Registry](model-registry.md).
O exemplo a seguir mostra como criar um `ModelStep` que registra a `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,
)
```
## Criar etapa de modelo
Você usa a etapa Criar modelo para criar um modelo de SageMaker IA. Para obter mais informações sobre modelos de SageMaker IA, consulte[Treine um modelo com a Amazon SageMaker](how-it-works-training.md).
Uma etapa de criação do modelo requer artefatos do modelo e informações sobre o tipo de instância de SageMaker IA que você precisa usar para criar o modelo. O exemplo a seguir mostra como criar uma definição de etapa de criar modelo. Para obter mais informações sobre os requisitos da etapa de criação de modelo, consulte [sagemaker.workflow.steps. CreateModelStep](https://sagemaker.readthedocs.io/en/stable/workflows/pipelines/sagemaker.workflow.pipelines.html#sagemaker.workflow.steps.CreateModelStep)documentação.
------
#### [ Pipeline Designer ]
Para adicionar uma etapa de criação de modelo ao pipeline, faça o seguinte:
1. Abra o console do Studio seguindo as instruções em [Inicie o Amazon SageMaker Studio](studio-updated-launch.md).
1. No painel de navegação à esquerda, selecione **Pipelines**.
1. Escolha **Criar**.
1. Escolha **Em branco**.
1. Na barra lateral esquerda, escolha **Criar modelo** e arraste-o para o canvas.
1. No canvas, escolha a etapa **Criar modelo** que você adicionou.
1. Na barra lateral direita, preencha os formulários nas guias **Configuração** e **Detalhes**. Para obter informações sobre os campos nessas guias, consulte [sagemaker.workflow.steps. CreateModelStep](https://sagemaker.readthedocs.io/en/stable/workflows/pipelines/sagemaker.workflow.pipelines.html#sagemaker.workflow.steps.CreateModelStep).
1. Se o canvas incluir alguma etapa que preceda imediatamente a etapa **Criar modelo** que você adicionou, clique e arraste o cursor da etapa até a etapa **Criar modelo** para criar uma borda.
1. Se o canvas incluir alguma etapa que suceda imediatamente a etapa **Criar modelo** que você adicionou, clique e arraste o cursor da etapa **Criar modelo** até a etapa para criar uma borda.
------
#### [ SageMaker Python SDK ]
**Importante**
Recomendamos usar [Etapa do modelo](#step-type-model) para criar modelos a partir da versão 2.90.0 do SDK AI SageMaker Python. `CreateModelStep`continuará funcionando nas versões anteriores do SDK do SageMaker Python, mas não tem mais suporte ativo.
```
from sagemaker.workflow.steps import CreateModelStep
step_create_model = CreateModelStep(
name="AbaloneCreateModel",
model=best_model,
inputs=inputs
)
```
------
## Etapa de registrar modelo
A etapa Registrar modelo registra um modelo no Registro de SageMaker Modelos.
------
#### [ Pipeline Designer ]
Para registrar um modelo de um pipeline usando o Pipeline Designer, faça o seguinte:
1. Abra o console do Amazon SageMaker Studio seguindo as instruções em[Inicie o Amazon SageMaker Studio](studio-updated-launch.md).
1. No painel de navegação à esquerda, selecione **Pipelines**.
1. Escolha **Criar**.
1. Escolha **Em branco**.
1. Na barra lateral esquerda, escolha **Registrar modelo** e arraste-o para o canvas.
1. No canvas, escolha a etapa **Registrar modelo** que você adicionou.
1. Na barra lateral direita, preencha os formulários nas guias **Configuração** e **Detalhes**. Para obter informações sobre os campos nessas guias, consulte [sagemaker.workflow.step\_collections. RegisterModel](https://sagemaker.readthedocs.io/en/stable/workflows/pipelines/sagemaker.workflow.pipelines.html#sagemaker.workflow.step_collections.RegisterModel).
1. Se o canvas incluir alguma etapa que preceda imediatamente a etapa **Registrar modelo** que você adicionou, clique e arraste o cursor da etapa até a etapa **Registrar modelo** para criar uma borda.
1. Se o canvas incluir alguma etapa que suceda imediatamente a etapa **Registrar modelo** que você adicionou, clique e arraste o cursor da etapa **Registrar modelo** até a etapa para criar uma borda.
------
#### [ SageMaker Python SDK ]
**Importante**
Recomendamos usar [Etapa do modelo](#step-type-model) para registrar modelos a partir da versão 2.90.0 do SDK AI SageMaker Python. `RegisterModel`continuará funcionando nas versões anteriores do SDK do SageMaker Python, mas não tem mais suporte ativo.
[Você usa uma `RegisterModel` etapa para registrar um SageMaker.model.Model ou um [sagemaker.pipeline.](https://sagemaker.readthedocs.io/en/stable/api/inference/model.html) PipelineModel](https://sagemaker.readthedocs.io/en/stable/api/inference/pipeline.html#pipelinemodel)com o Amazon SageMaker Model Registry. Um `PipelineModel` representa um pipeline de inferência, que é um modelo composto por uma sequência linear de contêineres que processam solicitações de inferência.
Para obter mais informações sobre como registrar um modelo, consulte [Implantação do registro do modelo com o Model Registry](model-registry.md). Para obter mais informações sobre os requisitos das `RegisterModel` etapas, consulte [sagemaker.workflow.step\_collections. RegisterModel](https://sagemaker.readthedocs.io/en/stable/workflows/pipelines/sagemaker.workflow.pipelines.html#sagemaker.workflow.step_collections.RegisterModel)documentação.
O exemplo a seguir mostra como criar uma etapa `RegisterModel` que registra um `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}}',
)
```
Se `model` não for fornecida, a etapa do modelo de registro requer um estimador, conforme mostrado no exemplo a seguir.
```
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
)
```
------
## Etapa de implantação de modelo (endpoint)
No Pipeline Designer, use a etapa de implantar modelo (endpoint) para implantar o modelo em um endpoint. Você pode criar um novo endpoint ou usar um endpoint existente. Real-time a inferência é ideal para cargas de trabalho de inferência em que você tem requisitos em tempo real, interativos e de baixa latência. Você pode implantar seu modelo nos serviços de hospedagem de SageMaker IA e obter um endpoint em tempo real que pode ser usado para inferência. Esses endpoints são totalmente gerenciados e oferecem apoio ao ajuste de escala automático. Para saber mais sobre inferência em tempo real em SageMaker IA, consulte[Real-time inferência](realtime-endpoints.md).
Antes de adicionar uma etapa de implantar modelo ao pipeline, certifique-se de que seu perfil do IAM tenha as seguintes permissões:
+ `sagemaker:CreateModel`
+ `sagemaker:CreateEndpointConfig`
+ `sagemaker:CreateEndpoint`
+ `sagemaker:UpdateEndpoint`
+ `sagemaker:DescribeModel`
+ `sagemaker:DescribeEndpointConfig`
+ `sagemaker:DescribeEndpoint`
Para saber mais sobre todas as permissões necessárias para SageMaker IA e como configurá-las, consulte[Permissões da API Amazon SageMaker AI: referência de ações, permissões e recursos](api-permissions-reference.md).
Para adicionar uma etapa de implantação de modelo ao seu Pipeline no editor de arrastar e soltar, conclua as seguintes etapas:
1. Abra o console do Studio seguindo as instruções em [Inicie o Amazon SageMaker Studio](studio-updated-launch.md).
1. No painel de navegação à esquerda, selecione **Pipelines**.
1. Escolha **Criar**.
1. Escolha **Em branco**.
1. Na barra lateral esquerda, escolha **Implantar modelo (endpoint)** e arraste-o até o canvas.
1. No canvas, escolha a etapa **Implantar modelo (endpoint)** que você adicionou.
1. Na barra lateral direita, preencha os formulários nas guias **Configuração** e **Detalhes**.
1. Se o canvas incluir alguma etapa que preceda imediatamente a etapa **Implantar modelo (endpoint)** que você adicionou, clique e arraste o cursor da etapa até a etapa **Implantar modelo (endpoint)** para criar uma borda.
1. Se o canvas incluir alguma etapa que suceda imediatamente a etapa **Implantar modelo (endpoint)** que você adicionou, clique e arraste o cursor da etapa **Implantar modelo (endpoint)** até a etapa para criar uma borda.
## Etapa de transformação
Você usa uma etapa de transformação para transformação em lote para executar inferência em um conjunto de dados inteiro. Para obter mais informações sobre a transformação em lotes, consulte [Transformações em lotes com pipelines de inferência](inference-pipeline-batch.md).
Uma etapa de transformação requer um transformador e os dados nos quais executar a transformação em lote. O exemplo a seguir mostra como criar uma definição de etapa de transformação. Para obter mais informações sobre os requisitos da etapa de transformação, consulte [sagemaker.workflow.steps. TransformStep](https://sagemaker.readthedocs.io/en/stable/workflows/pipelines/sagemaker.workflow.pipelines.html#sagemaker.workflow.steps.TransformStep)documentação.
------
#### [ Pipeline Designer ]
Para adicionar uma etapa de transformação em lote ao seu pipeline usando o editor visual de arrastar e soltar, faça o seguinte:
1. Abra o console do Studio seguindo as instruções em [Inicie o Amazon SageMaker Studio](studio-updated-launch.md).
1. No painel de navegação à esquerda, selecione **Pipelines**.
1. Escolha **Criar**.
1. Escolha **Em branco**.
1. Na barra lateral esquerda, escolha **Implantar modelo (transformação em lote)** e arraste-o até o canvas.
1. No canvas, escolha a etapa **Implantar modelo (transformação em lote)** que você adicionou.
1. Na barra lateral direita, preencha os formulários nas guias **Configuração** e **Detalhes**. Para obter informações sobre os campos nessas guias, consulte [sagemaker.workflow.steps. TransformStep](https://sagemaker.readthedocs.io/en/stable/workflows/pipelines/sagemaker.workflow.pipelines.html#sagemaker.workflow.steps.TransformStep).
1. Se o canvas incluir alguma etapa que preceda imediatamente a etapa **Implantar modelo (transformação em lote)** que você adicionou, clique e arraste o cursor da etapa até a etapa **Implantar modelo (transformação em lote)** para criar uma borda.
1. Se o canvas incluir alguma etapa que suceda imediatamente a etapa **Implantar modelo (transformação em lote)** que você adicionou, clique e arraste o cursor da etapa **Implantar modelo (transformação em lote)** até a etapa para criar uma borda.
------
#### [ 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}}"),
)
```
------
## Etapa de condição
Você usa uma etapa de condição para avaliar a condição das propriedades da etapa para avaliar qual ação deve ser tomada em seguida no pipeline.
Uma etapa de condição exige:
+ Uma lista de condições.
+ Uma lista de etapas a executar se a condição for avaliada como `true`.
+ Uma lista de etapas a executar se a condição for avaliada como `false`.
------
#### [ Pipeline Designer ]
Para adicionar uma etapa de condição a um pipeline usando o Pipeline Designer, faça o seguinte:
1. Abra o console do Amazon SageMaker Studio seguindo as instruções em[Inicie o Amazon SageMaker Studio](studio-updated-launch.md).
1. No painel de navegação à esquerda, selecione **Pipelines**.
1. Escolha **Criar**.
1. Escolha **Em branco**.
1. Na barra lateral esquerda, escolha **Condição** e arraste-o até o canvas.
1. No canvas, escolha a etapa **Condição** que você adicionou.
1. Na barra lateral direita, preencha os formulários nas guias **Configuração** e **Detalhes**. Para obter informações sobre os campos nessas guias, consulte [sagemaker.workflow.condition\_step. ConditionStep](https://sagemaker.readthedocs.io/en/stable/workflows/pipelines/sagemaker.workflow.pipelines.html#sagemaker.workflow.condition_step.ConditionStep).
1. Se o canvas incluir alguma etapa que preceda imediatamente a etapa **Condição** que você adicionou, clique e arraste o cursor da etapa até a etapa **Condição** para criar uma borda.
1. Se o canvas incluir alguma etapa que suceda imediatamente a etapa **Condição** adicionada, clique e arraste o cursor da etapa **Condição** até a etapa para criar uma borda.
------
#### [ SageMaker Python SDK ]
O exemplo a seguir mostra como criar uma definição de `ConditionStep`.
**Limitações**
+ O Pipelines não oferece apoio ao uso de etapas de condições aninhadas. Você não pode passar uma etapa de condição como entrada para outra etapa de condição.
+ Uma etapa de condição não pode usar etapas idênticas nas duas ramificações. Se você precisar da mesma funcionalidade de etapa em ambas as ramificações, duplique a etapa e dê a ela um nome diferente.
```
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=[]
)
```
Para obter mais informações sobre `ConditionStep` os requisitos, consulte o [sagemaker.workflow.condition\_step. ConditionStep](https://sagemaker.readthedocs.io/en/stable/workflows/pipelines/sagemaker.workflow.pipelines.html#conditionstep) Referência da API. Para obter mais informações sobre as condições suportadas, consulte *[Amazon SageMaker Pipelines -](https://sagemaker.readthedocs.io/en/stable/amazon_sagemaker_model_building_pipeline.html#conditions)* Conditions na documentação do SageMaker SDK para AI Python.
------
## Etapa de retorno de chamada
Use uma `Callback` etapa para adicionar outros processos e AWS serviços ao seu fluxo de trabalho que não são fornecidos diretamente pelo Amazon SageMaker Pipelines. Quando uma etapa `Callback` é executada, ocorre o seguinte procedimento:
+ O Pipelines envia uma mensagem para uma fila do Amazon Simple Queue Service (Amazon SQS) especificada pelo cliente. A mensagem contém um token gerado pelo Pipelines e uma lista de parâmetros de entrada fornecida pelo cliente. Depois de enviar a mensagem, o Pipelines aguarda uma resposta do cliente.
+ O cliente recupera a mensagem da fila do Amazon SQS e inicia seu processo personalizado.
+ Quando o processo termina, o cliente chama uma das seguintes APIs e envia o token gerado pelo Pipelines:
+ [SendPipelineExecutionStepSuccess](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_SendPipelineExecutionStepSuccess.html), junto com uma lista de parâmetros de saída
+ [SendPipelineExecutionStepFailure](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_SendPipelineExecutionStepFailure.html), junto com um motivo de falha
+ A chamada de API faz com que o Pipelines continue com o processo do pipeline ou falhe no processo.
Para obter mais informações sobre os requisitos das `Callback` etapas, consulte [sagemaker.workflow.callback\_step. CallbackStep](https://sagemaker.readthedocs.io/en/stable/workflows/pipelines/sagemaker.workflow.pipelines.html#sagemaker.workflow.callback_step.CallbackStep)documentação. Para obter uma solução completa, consulte [Estender SageMaker pipelines para incluir etapas personalizadas usando etapas de retorno de chamada](https://aws.amazon.com/blogs/machine-learning/extend-amazon-sagemaker-pipelines-to-include-custom-steps-using-callback-steps/).
**Importante**
`Callback`etapas foram introduzidas no Amazon SageMaker Python SDK v2.45.0 e no Amazon Studio Classic v3.6.2. SageMaker Você deve atualizar o Studio Classic antes de usar uma etapa `Callback`; caso contrário, o DAG do pipeline não será exibido. Para atualizar o Studio Classic, consulte [Desligue e atualize o Amazon SageMaker Studio Classic](studio-tasks-update-studio.md).
O exemplo a seguir demonstra uma implementação do procedimento anterior.
```
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={...}
)
'
```
**nota**
Os parâmetros de saída para `CallbackStep` não devem ser aninhados. Por exemplo, se você usar um dicionário aninhado como parâmetro de saída, o dicionário será tratado como uma única string (p. ex., `{"output1": "{\"nested_output1\":\"my-output\"}"}`). Se você fornecer um valor aninhado, ao tentar se referir a um determinado parâmetro de saída, a SageMaker IA gerará um erro de cliente que não pode ser repetido.
**Parando o comportamento**
Um processo de pipeline não para durante a execução de uma etapa `Callback`.
Quando você chama um processo de pipeline com uma `Callback` etapa [StopPipelineExecution](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_StopPipelineExecution.html)em execução, o Pipelines envia uma mensagem do Amazon SQS para a fila do SQS. O corpo da mensagem SQS contém um campo **Status**, que está definido como `Stopping`. O exemplo a seguir mostra um exemplo de corpo de mensagem 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"
}
```
Você deve adicionar lógica ao seu consumidor de mensagens do Amazon SQS para realizar qualquer ação necessária (por exemplo, limpeza de recursos) após o recebimento da mensagem. Em seguida, adicione uma chamada para `SendPipelineExecutionStepSuccess` ou `SendPipelineExecutionStepFailure`.
O Pipelines interrompe o processo de pipeline somente quando recebe uma dessas chamadas.
## Etapa Lambda
Você usa uma etapa do Lambda para executar uma AWS Lambda função. Você pode executar uma função Lambda existente ou a SageMaker IA pode criar e executar uma nova função Lambda. Se você optar por usar uma função Lambda existente, ela deverá estar no mesmo pipeline Região da AWS de SageMaker IA. [Para um notebook que mostra como usar uma etapa do Lambda em um pipeline de SageMaker IA, consulte sagemaker-pipelines-lambda-step.ipynb.](https://github.com/aws/amazon-sagemaker-examples/blob/main/sagemaker-pipelines/tabular/lambda-step/sagemaker-pipelines-lambda-step.ipynb)
**Importante**
As etapas do Lambda foram introduzidas no Amazon SageMaker Python SDK v2.51.0 e no Amazon Studio Classic v3.9.1. SageMaker Você deve atualizar o Studio Classic antes de usar uma etapa Lambda; caso contrário, o DAG do pipeline não será exibido. Para atualizar o Studio Classic, consulte [Desligue e atualize o Amazon SageMaker Studio Classic](studio-tasks-update-studio.md).
SageMaker A IA fornece a [classe SageMaker.lambda\_helper.Lambda para criar, atualizar, invocar e excluir funções do Lambda](https://sagemaker.readthedocs.io/en/stable/api/utility/lambda_helper.html). `Lambda`tem a seguinte assinatura.
```
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
...
)
```
O [sagemaker.workflow.lambda\_step. LambdaStep](https://sagemaker.readthedocs.io/en/stable/workflows/pipelines/sagemaker.workflow.pipelines.html#sagemaker.workflow.lambda_step.LambdaStep)classe tem um `lambda_func` argumento do tipo`Lambda`. Para invocar uma função do Lambda existente, o único requisito é fornecer o nome do recurso da Amazon (ARN) da função para `function_arn`. Se você não fornecer um valor para `function_arn`, deverá especificar `handler` uma das seguintes opções:
+ `zipped_code_dir`: o caminho da função do Lambda compactada
`s3_bucket`: bucket do Amazon S3 onde `zipped_code_dir` deve ser carregado
+ `script`: o caminho do arquivo de script da função do Lambda
O exemplo a seguir mostra como criar uma definição de etapa `Lambda` que invoca uma função do Lambda existente.
```
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"
]
)
```
O exemplo a seguir mostra como criar uma definição de etapa `Lambda` que cria e invoca uma função do Lambda usando um script de função do Lambda.
```
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"
]
)
```
**Entradas e saídas**
Se sua função `Lambda` tiver entradas ou saídas, elas também devem ser definidas em sua etapa `Lambda`.
**nota**
Os parâmetros de entrada e saída não devem ser aninhados. Por exemplo, se você usar um dicionário aninhado como parâmetro de saída, o dicionário será tratado como uma única string (ex. `{"output1": "{\"nested_output1\":\"my-output\"}"}`). Se você fornecer um valor aninhado e tentar referenciá-lo posteriormente, será gerado um erro de cliente que não pode ser repetido.
Ao definir a etapa `Lambda`, `inputs` deve ser um dicionário de pares de valores-chave. Cada valor do `inputs` dicionário deve ser de um tipo primitivo (string, número inteiro ou flutuante). Não há compatibilidade com objetos aninhados. Se não for definido, o `inputs` valor padrão será `None`.
O `outputs` valor deve ser uma lista de chaves. Essas chaves se referem a um dicionário definido na saída da `Lambda` função. Por exemplo `inputs`, essas chaves devem ser de tipos primitivos e não há compatibilidade com objetos aninhados.
**Tempo limite e comportamento de parada**
A `Lambda` classe tem um `timeout` argumento que especifica o tempo máximo que a função do Lambda pode ser executada. O valor padrão é de 120 segundos, com máximo de 10 minutos. Se a função do Lambda estiver em execução quando o tempo limite for atingido, a etapa Lambda falhará; no entanto, a função do Lambda continuará em execução.
Um processo de pipeline não pode ser interrompido enquanto uma etapa do Lambda está em execução porque a função do Lambda invocada pela etapa do Lambda não pode ser interrompida. Se você tentar interromper o processo enquanto a função do Lambda estiver em execução, o pipeline aguardará a conclusão da função ou até que o tempo limite seja atingido. Isso depende do que ocorrer primeiro. O processo, então, é interrompido. Se a função do Lambda terminar, o status do processo do pipeline será `Stopped`. Se o tempo limite for atingido, o status do processo do pipeline será `Failed`.
## ClarifyCheck etapa
Você pode usar a etapa `ClarifyCheck` para realizar verificações de oscilação da linha de base em relação às linhas de base anteriores para análise de desvio e explicabilidade do modelo. Em seguida, você pode gerar e [registrar suas linhas de base](https://docs.aws.amazon.com/sagemaker/latest/dg/pipelines-quality-clarify-baseline-lifecycle.html#pipelines-quality-clarify-baseline-calculations) com o método `model.register()` e passar a saída desse método para [Etapa do modelo](#step-type-model) usando `[step\_args](https://sagemaker.readthedocs.io/en/stable/amazon_sagemaker_model_building_pipeline.html#model-step)`. Essas linhas de base para verificação de deriva podem ser usadas pelo Amazon SageMaker Model Monitor para os endpoints do seu modelo. Como resultado, você não precisa fazer uma sugestão [de linha de base](https://docs.aws.amazon.com/sagemaker/latest/dg/model-monitor-create-baseline.html) separadamente.
A etapa `ClarifyCheck` também pode extrair linhas de base para verificação de oscilação do registro do modelo. A `ClarifyCheck` etapa usa o contêiner pré-construído SageMaker Clarify. O contêiner fornece uma variedade de recursos de monitoramento de modelos, incluindo sugestão de restrições e validação de restrições em relação a uma determinada linha de base. Para obter mais informações, consulte [Contêineres SageMaker Clarify pré-construídos](clarify-processing-job-configure-container.md).
### Configurando a etapa ClarifyCheck
Você pode configurar a etapa `ClarifyCheck` para realizar somente um dos seguintes tipos de verificação sempre que ela for usada em um pipeline:
+ Verificação de desvio de dados
+ Verificação de desvio do modelo
+ Verificação da explicabilidade do modelo
Para fazer isso, defina o parâmetro `clarify_check_config` com um dos seguintes valores de tipo de verificação:
+ `DataBiasCheckConfig`
+ `ModelBiasCheckConfig`
+ `ModelExplainabilityCheckConfig`
A `ClarifyCheck` etapa inicia uma tarefa de processamento que executa o contêiner pré-construído do SageMaker AI Clarify e exige [configurações dedicadas para a verificação e a tarefa de processamento](https://docs.aws.amazon.com/sagemaker/latest/dg/clarify-configure-processing-jobs.html). `ClarifyCheckConfig`e `CheckJobConfig` são funções auxiliares para essas configurações. Essas funções auxiliares estão alinhadas com a forma como a tarefa de processamento do SageMaker Clarify calcula para verificar o viés do modelo, o viés de dados ou a explicabilidade do modelo. Para obter mais informações, consulte [Execute trabalhos de processamento do SageMaker Clarify para análise de viés e explicabilidade](clarify-processing-job-run.md).
### Controlar os comportamentos das etapas para verificação de oscilação
A etapa `ClarifyCheck` requer os dois sinalizadores booleanos a seguir para controlar seu comportamento:
+ `skip_check`: esse parâmetro indica se a verificação de oscilação em relação à linha de base anterior foi ignorada ou não. Se estiver definido como `False`, a linha de base anterior do tipo de verificação configurado deverá estar disponível.
+ `register_new_baseline`: esse parâmetro indica se uma linha de base recém-calculada pode ser acessada por meio da propriedade de etapa `BaselineUsedForDriftCheckConstraints`. Se estiver definido como `False`, a linha de base anterior do tipo de verificação configurado também deve estar disponível. Isso pode ser acessado através da propriedade `BaselineUsedForDriftCheckConstraints`.
Para obter mais informações, consulte [Cálculo básico, detecção de desvios, ciclo de vida e ClarifyCheck etapas QualityCheck no Amazon Pipelines SageMaker](pipelines-quality-clarify-baseline-lifecycle.md).
### Trabalhar com linhas de base
Opcionalmente, você pode especificar o `model_package_group_name` para localizar a linha de base existente. Em seguida, a etapa `ClarifyCheck` extrai o `DriftCheckBaselines` do pacote de modelo aprovado mais recente no grupo de pacotes de modelo.
Ou você pode fornecer uma linha de base anterior por meio do parâmetro `supplied_baseline_constraints`. Se você especificar o `model_package_group_name` e o `supplied_baseline_constraints`, a etapa `ClarifyCheck` usará a linha de base especificada pelo parâmetro `supplied_baseline_constraints`.
Para obter mais informações sobre como usar os requisitos das `ClarifyCheck` etapas, consulte [sagemaker.workflow.steps. ClarifyCheckStep](https://sagemaker.readthedocs.io/en/stable/workflows/pipelines/sagemaker.workflow.pipelines.html#sagemaker.workflow.clarify_check_step.ClarifyCheckStep)no *Amazon SageMaker AI SageMaker AI SDK para Python*. Para um notebook Amazon SageMaker Studio Classic que mostra como usar o `ClarifyCheck` step in Pipelines, consulte [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 Crie uma etapa `ClarifyCheck` para verificação de desvio de dados**
```
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 etapa
Você pode usar a etapa `QualityCheck` para realizar [sugestões de linha de base](https://docs.aws.amazon.com/sagemaker/latest/dg/model-monitor-create-baseline.html) e verificar oscilações em relação a uma linha de base anterior para verificar a qualidade dos dados ou a qualidade do modelo em um pipeline. Em seguida, você pode gerar e [registrar suas linhas de base](https://docs.aws.amazon.com/sagemaker/latest/dg/pipelines-quality-clarify-baseline-lifecycle.html#pipelines-quality-clarify-baseline-calculations) com o método `model.register()` e passar a saída desse método para [Etapa do modelo](#step-type-model) usando `[step\_args](https://sagemaker.readthedocs.io/en/stable/amazon_sagemaker_model_building_pipeline.html#model-step)`. ]
O Model Monitor pode usar essas linhas de base para verificar a oscilação dos endpoints do modelo, para que você não precise fazer uma sugestão de linha de base separadamente. A etapa `QualityCheck` também pode extrair linhas de base para verificação de oscilação do registro do modelo. A `QualityCheck` etapa aproveita o contêiner pré-construído Amazon SageMaker AI Model Monitor. O contêiner tem uma variedade de recursos de monitoramento de modelos, incluindo sugestão de restrições, geração de estatísticas e validação de restrições em relação a uma linha de base. Para obter mais informações, consulte [Contêiner pré-construído Amazon SageMaker Model Monitor](model-monitor-pre-built-container.md).
### Configurando a etapa QualityCheck
Você pode configurar a etapa `QualityCheck` para realizar somente um dos seguintes tipos de verificação sempre que ela for usada em um pipeline:
+ Verificação de qualidade de dados
+ Verificação de qualidade do modelo
Para fazer isso, defina o parâmetro `quality_check_config` com um dos seguintes valores de tipo de verificação:
+ `DataQualityCheckConfig`
+ `ModelQualityCheckConfig`
A etapa `QualityCheck` inicia um trabalho de processamento que executa o contêiner pré-construído do Model Monitor e requer configurações dedicadas para a verificação e o trabalho de processamento. `QualityCheckConfig` e `CheckJobConfig` são funções auxiliares para essas configurações. Essas funções auxiliares estão alinhadas com a forma como o Model Monitor cria uma linha de base para a qualidade do modelo ou o monitoramento da qualidade dos dados. Para obter mais informações sobre as sugestões de linha de base do Model Monitor, consulte [Criar uma linha de base](model-monitor-create-baseline.md) e [Criar uma linha de base da qualidade de modelo](model-monitor-model-quality-baseline.md).
### Controlar os comportamentos das etapas para verificação de oscilação
A etapa `QualityCheck` requer os dois sinalizadores booleanos a seguir para controlar seu comportamento:
+ `skip_check`: esse parâmetro indica se a verificação de oscilação em relação à linha de base anterior foi ignorada ou não. Se estiver definido como `False`, a linha de base anterior do tipo de verificação configurado deverá estar disponível.
+ `register_new_baseline`: esse parâmetro indica se uma linha de base recém-calculada pode ser acessada por meio das propriedades da etapa `BaselineUsedForDriftCheckConstraints` e `BaselineUsedForDriftCheckStatistics`. Se estiver definido como `False`, a linha de base anterior do tipo de verificação configurado também deve estar disponível. Eles podem ser acessados por meio das propriedades `BaselineUsedForDriftCheckConstraints` e `BaselineUsedForDriftCheckStatistics`.
Para obter mais informações, consulte [Cálculo básico, detecção de desvios, ciclo de vida e ClarifyCheck etapas QualityCheck no Amazon Pipelines SageMaker](pipelines-quality-clarify-baseline-lifecycle.md).
### Trabalhar com linhas de base
Você pode especificar uma linha de base anterior diretamente por meio dos parâmetros `supplied_baseline_statistics` e `supplied_baseline_constraints`. Você também pode especificar o `model_package_group_name`, e a etapa `QualityCheck` extrai `DriftCheckBaselines` do pacote de modelo aprovado mais recente no grupo de pacotes de modelo.
Quando você especifica o seguinte, a etapa `QualityCheck` usa a linha de base especificada por `supplied_baseline_constraints` e `supplied_baseline_statistics` no tipo de verificação da etapa `QualityCheck`:
+ `model_package_group_name`
+ `supplied_baseline_constraints`
+ `supplied_baseline_statistics`
Para obter mais informações sobre como usar os requisitos das `QualityCheck` etapas, consulte [sagemaker.workflow.steps. QualityCheckStep](https://sagemaker.readthedocs.io/en/stable/workflows/pipelines/sagemaker.workflow.pipelines.html#sagemaker.workflow.quality_check_step.QualityCheckStep)no *Amazon SageMaker AI SageMaker AI SDK para Python*. Para um notebook Amazon SageMaker Studio Classic que mostra como usar o `QualityCheck` step in Pipelines, consulte [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 Crie uma etapa `QualityCheck` para verificação da qualidade dos dados**
```
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}}"
)
```
## Etapa do EMR
Use a etapa [EMR](https://docs.aws.amazon.com/emr/latest/ManagementGuide/emr-overview.html) do Amazon SageMaker Pipelines para:
+ Processar as [etapas do Amazon EMR](https://docs.aws.amazon.com/emr/latest/ManagementGuide/emr-work-with-steps.html) em um cluster do Amazon EMR em execução.
+ Fazer com que o pipeline crie e gerencie um cluster do Amazon EMR para você.
Para obter mais informações sobre o Amazon EMR, consulte o [Conceitos básicos do Amazon EMR](https://docs.aws.amazon.com/emr/latest/ManagementGuide/emr-gs.html).
A etapa do EMR exige que `EMRStepConfig` inclua a localização do arquivo JAR usado pelo cluster do Amazon EMR e os argumentos a serem passados. Você também fornece o ID do cluster do Amazon EMR se quiser executar a etapa em um cluster do EMR em execução. Você também pode passar a configuração do cluster para executar a etapa do EMR em um cluster que ela cria, gerencia e encerra para você. As seções a seguir incluem exemplos e links para exemplos de cadernos que demonstram os dois métodos.
**nota**
As etapas do EMR exigem que a função passada para seu pipeline tenha permissões adicionais. Anexe a [política gerenciada da AWS : `AmazonSageMakerPipelinesIntegrations`](https://docs.aws.amazon.com/sagemaker/latest/dg/security-iam-awsmanpol-pipelines.html#security-iam-awsmanpol-AmazonSageMakerPipelinesIntegrations) à função de pipeline ou garanta que a função inclua as permissões dessa política.
Se você processar uma etapa do EMR em um cluster em execução, só poderá usar um cluster que esteja em um dos seguintes estados:
`STARTING`
`BOOTSTRAPPING`
`RUNNING`
`WAITING`
Se você processar etapas do EMR em um cluster em execução, poderá ter no máximo 256 etapas do EMR em um estado `PENDING` em um cluster do EMR. As etapas do EMR enviadas além desse limite resultam em falha na execução do pipeline. Você pode considerar usar [Política de repetição para etapas do pipeline](pipelines-retry-policy.md).
Você pode especificar o ID ou a configuração do cluster, mas não ambos.
A etapa do EMR depende da Amazon EventBridge para monitorar as mudanças na etapa do EMR ou no estado do cluster. Se você processa seu trabalho do Amazon EMR em um cluster em execução, a etapa do EMR usa a regra `SageMakerPipelineExecutionEMRStepStatusUpdateRule` para monitorar o estado da etapa do EMR. Se você processar seu trabalho em um cluster criado pela etapa do EMR, a etapa usa a regra `SageMakerPipelineExecutionEMRClusterStatusRule` para monitorar as alterações no estado do cluster. Se você encontrar alguma dessas EventBridge regras em sua AWS conta, não as exclua, caso contrário, sua etapa do EMR poderá não ser concluída.
**Adicione uma etapa do Amazon EMR ao seu pipeline**
Para adicionar uma etapa do EMR ao seu pipeline, faça o seguinte:
+ Abra o console do Studio seguindo as instruções em [Iniciar o Amazon SageMaker Studio](https://docs.aws.amazon.com/sagemaker/latest/dg/studio-updated-launch.html).
+ No painel de navegação à esquerda, selecione **Pipelines**.
+ Escolha **Criar**.
+ Escolha **Em branco**.
+ Na barra lateral esquerda, escolha **Processar dados** e arraste-o para o canvas.
+ No canvas, escolha a etapa **Processar dados** que você adicionou.
+ Na barra lateral direita, em modo, escolha **EMR (**gerenciado).
+ Na barra lateral direita, preencha os formulários nas guias **Configuração e Detalhes**. Para obter informações sobre os campos nessas guias, consulte [SageMaker.Workflow.Fail\_Step.EMRstep](https://sagemaker.readthedocs.io/en/stable/workflows/pipelines/sagemaker.workflow.pipelines.html#sagemaker.workflow.emr_step.EMRStep).
**Inicie um novo trabalho em um cluster do Amazon EMR em execução**
Par iniciar um novo trabalho em um cluster do Amazon EMR em execução, transmita o ID do cluster como uma string para o argumento `cluster_id` de `EMRStep`. O exemplo a seguir demonstra esse procedimento.
```
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"
)
```
Para ver uma amostra de caderno que orienta você com um exemplo completo, consulte [Etapa de EMR do Pipelines com cluster do EMR em execução](https://github.com/aws/amazon-sagemaker-examples/blob/main/sagemaker-pipelines/tabular/emr-step/sagemaker-pipelines-emr-step-with-running-emr-cluster.ipynb).
**Inicie um novo trabalho em um cluster do Amazon EMR em execução**
Para iniciar um novo trabalho em um novo cluster que o `EMRStep` criou para você, forneça a configuração de cluster como um dicionário. O dicionário deve ter a mesma estrutura de uma [RunJobFlow](https://docs.aws.amazon.com/emr/latest/APIReference/API_RunJobFlow.html)solicitação. No entanto, não inclua os seguintes campos na configuração do cluster:
+ [`Name`]
+ [`Steps`]
+ [`AutoTerminationPolicy`]
+ [`Instances`][`KeepJobFlowAliveWhenNoSteps`]
+ [`Instances`][`TerminationProtected`]
Todos os outros argumentos `RunJobFlow` estão disponíveis para uso na configuração do cluster. Para obter detalhes sobre a sintaxe da solicitação, consulte [RunJobFlow](https://docs.aws.amazon.com/emr/latest/APIReference/API_RunJobFlow.html).
O exemplo a seguir passa uma configuração de cluster para uma definição de etapa do EMR. Isso faz com que a etapa inicie um novo trabalho em um novo cluster do EMR. A configuração do cluster EMR neste exemplo inclui especificações para os nós primários e principais do cluster EMR. Para obter mais informações sobre os tipos de nós do Amazon EMR, consulte [Compreender os tipos de nós: nós primários, principais e de tarefas](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
)
```
Para ver uma amostra de caderno que orienta você com um exemplo completo, consulte [Etapa de EMR do Pipelines com gerenciamento de ciclo de vida do cluster](https://github.com/aws/amazon-sagemaker-examples/blob/main/sagemaker-pipelines/tabular/emr-step/sagemaker-pipelines-emr-step-with-cluster-lifecycle-management.ipynb).
## Etapa sem servidor do EMR
Para adicionar uma etapa sem servidor do EMR ao seu pipeline, faça o seguinte:
+ Abra o console do Studio seguindo as instruções em [Iniciar o Amazon SageMaker Studio](https://docs.aws.amazon.com/sagemaker/latest/dg/studio-updated-launch.html).
+ No painel de navegação à esquerda, selecione **Pipelines**.
+ Escolha **Criar**.
+ Escolha **Em branco**.
+ Na barra lateral esquerda, escolha **Processar dados** e arraste-o para o canvas.
+ No canvas, escolha a etapa **Processar dados** que você adicionou.
+ Na barra lateral direita, em modo, escolha **EMR (**sem servidor).
+ Na barra lateral direita, preencha os formulários nas guias **Configuração e Detalhes**.
## Etapa de trabalho de caderno
Use a `NotebookJobStep` para executar seu SageMaker Notebook Job de forma não interativa como uma etapa do pipeline. Se você criar seu pipeline na interface de arrastar e soltar do Pipelines, use [Executar a etapa de código](#step-type-executecode) para executar seu caderno. Para obter mais informações sobre trabalhos do SageMaker Notebook, consulte[SageMaker Empregos em notebooks](notebook-auto-run.md).
O `NotebookJobStep` requer no mínimo um caderno de entrada, URI de imagem e nome do kernel. Para obter mais informações sobre os requisitos da etapa do Notebook Job e outros parâmetros que você pode definir para personalizar sua etapa, consulte [sagemaker.workflow.steps. NotebookJobStep](https://sagemaker.readthedocs.io/en/stable/workflows/pipelines/sagemaker.workflow.pipelines.html#sagemaker.workflow.notebook_job_step.NotebookJobStep).
O exemplo a seguir usa argumentos mínimos para definir um `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}}
)
```
Sua etapa do `NotebookJobStep` pipeline é tratada como uma tarefa de SageMaker notebook. Como resultado, acompanhe o status de execução no painel de trabalhos do caderno na interface do Studio Classic incluindo tags específicas com o argumento `tags`. Para mais detalhes sobre tags a serem incluídas, consulte [Visualizar seus trabalhos de caderno no painel da interface do Studio](create-notebook-auto-run-sdk.md#create-notebook-auto-run-dash).
Além disso, se você agendar o trabalho do notebook usando o SDK do SageMaker Python, só poderá especificar determinadas imagens para executar o trabalho do notebook. Para obter mais informações, consulte [Restrições de imagem para trabalhos de notebook do SageMaker AI Python SDK](notebook-auto-run-constraints.md#notebook-auto-run-constraints-image-sdk).
## Etapa de falha
Use uma etapa de falha para interromper a execução do Amazon SageMaker Pipelines quando a condição ou o estado desejado não for alcançado. A etapa de falha também permite que você insira uma mensagem de erro personalizada, indicando a causa da falha na execução do pipeline.
**nota**
Quando uma etapa de falha e outras etapas de pipeline são executadas simultaneamente, o pipeline não termina até que todas as etapas simultâneas sejam concluídas.
### Limitações do uso da etapa de falha
+ Você não pode adicionar uma etapa de falha à lista `DependsOn` de outras etapas. Para obter mais informações, consulte [Dependência personalizada entre etapas](build-and-manage-steps.md#build-and-manage-custom-dependency).
+ Outras etapas não podem fazer referência à etapa de falha. É *sempre* a última etapa na execução de um pipeline.
+ Você não pode repetir a execução de um pipeline que termine com uma etapa de falha.
Você pode criar a mensagem de erro da etapa de falha na forma de uma sequência de texto estática. Como alternativa, você também pode usar [os parâmetros de pipeline](https://docs.aws.amazon.com/sagemaker/latest/dg/build-and-manage-parameters.html), uma operação de [junção](https://sagemaker.readthedocs.io/en/stable/workflows/pipelines/sagemaker.workflow.pipelines.html?highlight=Join#sagemaker.workflow.functions.Join) ou outras [propriedades de etapa](https://docs.aws.amazon.com/sagemaker/latest/dg/build-and-manage-steps.html#build-and-manage-properties) para criar uma mensagem de erro mais informativa, se usar o SDK.
------
#### [ Pipeline Designer ]
Para adicionar uma etapa de falha ao pipeline, faça o seguinte:
1. Abra o console do Studio seguindo as instruções em [Inicie o Amazon SageMaker Studio](studio-updated-launch.md).
1. No painel de navegação à esquerda, selecione **Pipelines**.
1. Escolha **Criar**.
1. Escolha **Em branco**.
1. Na barra lateral esquerda, selecione **Falha** e arraste-o para o canvas.
1. No canvas, escolha a etapa **Falha** que você adicionou.
1. Na barra lateral direita, preencha os formulários nas guias **Configuração** e **Detalhes**. Para obter informações sobre os campos nessas guias, consulte [sagemaker.workflow.fail\_step. FailStep](https://sagemaker.readthedocs.io/en/stable/workflows/pipelines/sagemaker.workflow.pipelines.html#sagemaker.workflow.fail_step.FailStep).
1. Se o canvas incluir alguma etapa que preceda imediatamente a etapa **Falha** que você adicionou, clique e arraste o cursor da etapa até a etapa **Falha** para criar uma borda.
1. Se canvas incluir alguma etapa que suceda imediatamente a etapa **Falha** que você adicionou, clique e arraste o cursor da etapa **Falha** até a etapa para criar uma borda.
------
#### [ SageMaker Python SDK ]
**Example**
O exemplo de trecho de código a seguir usa um `FailStep` com um `ErrorMessage` configurado com parâmetros de pipeline e uma `Join` operação.
```
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]
),
)
```
------