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á.
# SageMaker Fluxos de trabalho de IA
Ao escalar suas operações de aprendizado de máquina (ML), você pode usar os serviços de fluxo de trabalho totalmente gerenciados da Amazon SageMaker AI para implementar práticas de integração e implantação contínuas (CI/CD) para seu ciclo de vida de ML. Com o Pipelines SDK, é possível escolher e integrar as etapas do pipeline em uma solução unificada que automatiza o processo de criação do modelo, desde a preparação dos dados até a implantação do modelo. Para arquiteturas baseadas em Kubernetes, você pode instalar operadores de IA em seu cluster Kubernetes para criar trabalhos de SageMaker IA de forma nativa usando a SageMaker API Kubernetes e ferramentas de linha de comando do Kubernetes, como. `kubectl` Com componentes de SageMaker IA para pipelines Kubeflow, você pode criar e monitorar trabalhos de SageMaker IA nativos a partir de seus pipelines Kubeflow. Os parâmetros, o status e as saídas do trabalho da SageMaker IA podem ser acessados na interface do usuário do Kubeflow Pipelines. Por fim, se quiser agendar trabalhos em lotes, você pode usar a integração da fila de trabalhos ou o serviço de fluxos de AWS Batch trabalho baseado no notebook Jupyter para iniciar execuções autônomas ou regulares em um cronograma definido por você.
Em resumo, a SageMaker IA oferece as seguintes tecnologias de fluxo de trabalho:
+ [Pipelines](pipelines.md): ferramenta para criar e gerenciar pipelines de ML.
+ [Orquestração do Kubernetes](kubernetes-workflows.md): operadores personalizados de SageMaker IA para seu cluster Kubernetes e componentes para o Kubeflow Pipelines.
+ [SageMaker Empregos em notebooks](notebook-auto-run.md): execuções em lote não interativas sob demanda ou programadas do seu caderno Jupyter.
Você também pode aproveitar outros serviços que se integram à SageMaker IA para criar seu fluxo de trabalho. As opções incluem os seguintes serviços:
+ [Fluxos de trabalho do Airflow](https://sagemaker.readthedocs.io/en/stable/workflows/airflow/index.html): SageMaker APIs para exportar configurações para criar e gerenciar fluxos de trabalho do Airflow.
+ [AWS Step Functions](https://sagemaker.readthedocs.io/en/stable/workflows/step_functions/index.html): fluxos de trabalho de ML em várias etapas em Python que orquestram a infraestrutura de SageMaker IA sem precisar provisionar seus recursos separadamente.
+ [AWS Batch](https://docs.aws.amazon.com/batch/latest/userguide/getting-started-sagemaker.html): envie trabalhos de treinamento de SageMaker IA para uma fila de AWS Batch trabalhos, onde você pode priorizar e programar trabalhos para execução em um ambiente computacional.
Para obter mais informações sobre o gerenciamento de SageMaker treinamento e inferência, consulte Fluxos de trabalho do [Amazon SageMaker Python SDK](https://sagemaker.readthedocs.io/en/stable/workflows/index.html).
**Topics**
+ [Pipelines](pipelines.md)
+ [Orquestração do Kubernetes](kubernetes-workflows.md)
+ [SageMaker Empregos em notebooks](notebook-auto-run.md)
+ [Programe seus fluxos de trabalho de ML](workflow-scheduling.md)
+ [AWS Batch suporte para trabalhos de treinamento em SageMaker IA](training-job-queues.md)
# Pipelines
O Amazon SageMaker Pipelines é um serviço de orquestração de fluxo de trabalho desenvolvido especificamente para automatizar o desenvolvimento de aprendizado de máquina (ML).
Os pipelines oferecem as seguintes vantagens em relação a outras ofertas de AWS fluxo de trabalho:
**Infraestrutura sem servidor com escalabilidade automática Você não precisa gerenciar a infraestrutura** de orquestração subjacente para executar o Pipelines, o que permite que você se concentre nas principais tarefas de ML. SageMaker A IA provisiona, escala e desliga automaticamente os recursos computacionais de orquestração do pipeline conforme sua carga de trabalho de ML exige.
**Experiência intuitiva do usuário** Os pipelines podem ser criados e gerenciados por meio da interface de sua escolha: editor visual, SDK ou APIs JSON. Você pode executar drag-and-drop as várias etapas de ML para criar seus pipelines na interface visual do Amazon SageMaker Studio. A captura de tela a seguir mostra o editor visual do Studio para pipelines.
![\[Captura de tela da drag-and-drop interface visual do Pipelines no Studio.\]](http://docs.aws.amazon.com/pt_br/sagemaker/latest/dg/images/pipelines/pipelines-studio-overview.png)
Se você preferir gerenciar seus fluxos de trabalho de ML programaticamente, o SDK do SageMaker Python oferece recursos avançados de orquestração. Para obter mais informações, consulte [Amazon SageMaker Pipelines](https://sagemaker.readthedocs.io/en/stable/amazon_sagemaker_model_building_pipeline.html) na documentação do SageMaker Python SDK.
**AWS integrações** Os pipelines fornecem integração perfeita com todos os recursos de SageMaker IA e outros AWS serviços para automatizar o processamento de dados, o treinamento de modelos, o ajuste fino, a avaliação, a implantação e os trabalhos de monitoramento. Você pode incorporar os recursos de SageMaker IA em seus pipelines e navegar por eles usando links diretos para criar, monitorar e depurar seus fluxos de trabalho de ML em grande escala.
**Custos reduzidos** Com o Pipelines, você paga apenas pelo ambiente SageMaker Studio e pelas tarefas subjacentes que são orquestradas pelos Pipelines (por exemplo, SageMaker treinamento, SageMaker processamento, inferência de SageMaker IA e armazenamento de dados do Amazon S3).
**Capacidade de auditoria e rastreamento de linhagem**: com o Pipelines, você pode acompanhar o histórico de atualizações e execuções de pipeline usando o versionamento integrado. O Amazon SageMaker ML Lineage Tracking ajuda você a analisar as fontes de dados e os consumidores de dados no ciclo de vida de desenvolvimento do end-to-end ML.
**Topics**
+ [Visão geral do Pipelines](pipelines-overview.md)
+ [Ações de pipelines](pipelines-build.md)
# Visão geral do Pipelines
[Um pipeline de SageMaker IA da Amazon é uma série de etapas interconectadas no gráfico acíclico direcionado (DAG) que são definidas usando a interface do usuário ou o SDK do drag-and-drop Pipelines.](https://sagemaker.readthedocs.io/en/stable/workflows/pipelines/sagemaker.workflow.pipelines.html) Você também pode criar seu pipeline usando o [esquema JSON de definição de pipeline](https://aws-sagemaker-mlops.github.io/sagemaker-model-building-pipeline-definition-JSON-schema/). Esse DAG JSON fornece informações sobre os requisitos e as relações entre cada etapa do seu pipeline. A estrutura do DAG de um pipeline é determinada pelas dependências de dados entre as etapas. Essas dependências de dados são criadas quando as propriedades da saída de uma etapa são passadas como entrada para outra etapa. A imagem a seguir é um exemplo de DAG de pipeline:
![\[\]](http://docs.aws.amazon.com/pt_br/sagemaker/latest/dg/images/pipeline-full.png)
**O exemplo inclui as seguintes etapas:**
1. `AbaloneProcess`, uma instância da etapa de [processamento](https://docs.aws.amazon.com/sagemaker/latest/dg/build-and-manage-steps.html#step-type-processing), executa um script de pré-processamento nos dados usados para treinamento. Por exemplo, o script pode preencher valores ausentes, normalizar dados numéricos ou dividir dados nos conjuntos de dados de treinamento, validação e teste.
1. `AbaloneTrain`, uma instância da etapa de [treinamento](https://docs.aws.amazon.com/sagemaker/latest/dg/build-and-manage-steps.html#step-type-training), configura hiperparâmetros e treina um modelo a partir dos dados de entrada pré-processados.
1. `AbaloneEval`, outra instância da etapa de [processamento](https://docs.aws.amazon.com/sagemaker/latest/dg/build-and-manage-steps.html#step-type-processing), avalia a precisão do modelo. Esta etapa mostra um exemplo de dependência de dados: usa a saída do conjunto de dados de teste do `AbaloneProcess`.
1. `AbaloneMSECond`é uma instância de uma etapa de [condição](https://docs.aws.amazon.com/sagemaker/latest/dg/build-and-manage-steps.html#step-type-condition) que, neste exemplo, verifica se o mean-square-error resultado da avaliação do modelo está abaixo de um determinado limite. Se o modelo não atender aos critérios, o funcionamento do pipeline é interrompido.
1. A execução do pipeline prossegue com as seguintes etapas:
1. `AbaloneRegisterModel`, em que a SageMaker IA exige uma [RegisterModel](https://docs.aws.amazon.com/sagemaker/latest/dg/build-and-manage-steps.html#step-type-register-model)etapa para registrar o modelo como um grupo de pacotes de modelos versionados no Amazon SageMaker Model Registry.
1. `AbaloneCreateModel`, em que a SageMaker IA exige uma [CreateModel](https://docs.aws.amazon.com/sagemaker/latest/dg/build-and-manage-steps.html#step-type-create-model)etapa para criar o modelo em preparação para a transformação em lote. Em`AbaloneTransform`, a SageMaker IA chama uma etapa de [transformação](https://docs.aws.amazon.com/sagemaker/latest/dg/build-and-manage-steps.html#step-type-transform) para gerar previsões de modelo em um conjunto de dados especificado por você.
Os tópicos a seguir descrevem conceitos fundamentais do Pipelines. Para obter um tutorial descrevendo a implementação desses conceitos, consulte [Ações de pipelines](pipelines-build.md).
**Topics**
+ [Estrutura e execução do pipeline](build-and-manage-pipeline.md)
+ [Gerenciamento de acesso do IAM](build-and-manage-access.md)
+ [Configurar a compatibilidade entre contas para o Pipelines](build-and-manage-xaccount.md)
+ [Parâmetros de pipeline](build-and-manage-parameters.md)
+ [Etapas do Pipelines](build-and-manage-steps.md)
+ [Lift-and-shift Código Python com o decorador @step](pipelines-step-decorator.md)
+ [Passe dados entre etapas](build-and-manage-propertyfile.md)
+ [Etapas do pipeline de cache](pipelines-caching.md)
+ [Política de repetição para etapas do pipeline](pipelines-retry-policy.md)
+ [Execução seletiva das etapas do pipeline](pipelines-selective-ex.md)
+ [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)
+ [Programar execuções de pipeline](pipeline-eventbridge.md)
+ [Integração SageMaker com Amazon Experiments](pipelines-experiments.md)
+ [Executar pipelines usando o modo local](pipelines-local-mode.md)
+ [Solução de problemas do Amazon SageMaker Pipelines](pipelines-troubleshooting.md)
# Estrutura e execução do pipeline
**Topics**
+ [Estrutura do pipeline](#build-and-manage-pipeline-structure)
+ [Execução de pipeline usando configuração de paralelismo](#build-and-manage-pipeline-execution)
## Estrutura do pipeline
Uma instância do Amazon SageMaker Pipelines é composta por um `name``parameters`, e. `steps` Os nomes dos pipelines devem ser exclusivos dentro de um par `(account, region)`. Todos os parâmetros usados nas definições de etapas devem ser definidos no pipeline. As etapas do pipeline listadas determinam automaticamente sua ordem de execução de acordo com as dependências de dados de umas com as outras. O serviço do Pipelines resolve as relações entre as etapas no DAG de dependência de dados para criar uma série de etapas que a execução conclui. Veja a seguir um exemplo de uma estrutura de pipeline:
**Atenção**
Ao criar um pipeline por meio do editor visual ou do SageMaker AI Python SDK, não inclua informações confidenciais nos parâmetros do pipeline ou em qualquer campo de definição de etapa (como variáveis de ambiente). Esses campos ficarão visíveis no futuro quando exibidos em uma solicitação `DescribePipeline`.
```
from sagemaker.workflow.pipeline import Pipeline
pipeline_name = f"AbalonePipeline"
pipeline = Pipeline(
name=pipeline_name,
parameters=[
processing_instance_type,
processing_instance_count,
training_instance_type,
model_approval_status,
input_data,
batch_data,
],
steps=[step_process, step_train, step_eval, step_cond],
)
```
## Execução de pipeline usando configuração de paralelismo
Por padrão, um pipeline executa todas as etapas disponíveis para execução paralela. Você pode controlar esse comportamento usando a propriedade `ParallelismConfiguration` ao criar ou atualizar um pipeline, bem como ao iniciar ou tentar a execução de um pipeline novamente.
As configurações de paralelismo são aplicadas por execução. Por exemplo, se duas execuções forem iniciadas, cada uma poderá executar no máximo 50 etapas simultaneamente, totalizando 100 etapas em execução simultânea. Além disso, as `ParallelismConfiguration`s especificadas ao iniciar, tentar novamente ou atualizar uma execução têm precedência sobre as configurações de paralelismo definidas no pipeline.
**Example Criar uma execução de pipeline com `ParallelismConfiguration`**
```
pipeline = Pipeline(
name="myPipeline",
steps=[step_process, step_train]
)
pipeline.create(role, parallelism_config={"MaxParallelExecutionSteps": 50})
```
# Gerenciamento de acesso do IAM
As seções a seguir descrevem os requisitos AWS Identity and Access Management (IAM) do Amazon SageMaker Pipelines. Para obter um exemplo de como você pode implementar essas permissões, consulte [Pré-requisitos](define-pipeline.md#define-pipeline-prereq).
**Topics**
+ [Permissões de perfil de pipeline](#build-and-manage-role-permissions)
+ [Permissões de etapa de pipeline](#build-and-manage-step-permissions)
+ [Configuração do CORS com buckets do Amazon S3](#build-and-manage-cors-s3)
+ [Personalizar o gerenciamento de acesso para trabalhos do Pipelines](#build-and-manage-step-permissions-prefix)
+ [Personalizar o acesso a versões do pipeline](#build-and-manage-step-permissions-version)
+ [Políticas de controle de serviço com pipelines](#build-and-manage-scp)
## Permissões de perfil de pipeline
Seu pipeline exige uma função de execução do pipeline do IAM que é passada para os pipelines quando você cria um pipeline. A função da instância de SageMaker IA que você está usando para criar o pipeline deve ter uma política com a `iam:PassRole` permissão que especifique a função de execução do pipeline. Isso ocorre porque a instância precisa de permissão para passar sua função de execução de pipeline para o serviço Pipelines para uso na criação e execução de pipelines. Para obter mais informações sobre perfis do IAM, consulte [Perfis do IAM](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_roles.html).
Seu perfil de execução de pipeline requer as seguintes permissões:
+ Você pode usar uma função exclusiva ou personalizada para qualquer uma das etapas do trabalho de SageMaker IA em seu pipeline (em vez da função de execução do pipeline, que é usada por padrão). Certifique-se de que sua função de execução de pipeline tenha adicionado uma política com a `iam:PassRole` permissão que especifica cada uma dessas funções.
+ Permissões `Create` e `Describe` para cada um dos tipos de trabalho no pipeline.
+ Permissões do Amazon S3 para usar o perfil `JsonGet`. Você pode controlar o acesso aos recursos do Amazon S3 usando uma política baseada em identidade ou em recursos. Uma política baseada em recursos é aplicada ao bucket do Amazon S3 para que o Pipelines possa ter acesso a ele. Uma política baseada em identidade dá ao seu pipeline a capacidade de fazer chamadas para o Amazon S3 a partir da sua conta. Para obter mais informações sobre as políticas baseadas em identidades e em recursos, consulte [Políticas baseadas em identidade e em recursos](https://docs.aws.amazon.com/IAM/latest/UserGuide/access_policies_identity-vs-resource.html).
```
{
"Action": [
"s3:GetObject"
],
"Resource": "arn:aws:s3:::/*",
"Effect": "Allow"
}
```
## Permissões de etapa de pipeline
Os pipelines incluem etapas que executam trabalhos de SageMaker IA. Para que as etapas do pipeline executem esses trabalhos, elas exigem um perfil do IAM em sua conta que forneça acesso ao recurso necessário. Essa função é passada para o diretor do serviço de SageMaker IA pelo seu pipeline. Para obter mais informações sobre perfis do IAM, consulte [Perfis do IAM](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_roles.html).
Por padrão, cada etapa assume o perfil de execução do pipeline. Opcionalmente, você pode transmitir um perfil diferente para qualquer uma das etapas do seu pipeline. Isso garante que o código em cada etapa não tenha a capacidade de impactar os recursos usados em outras etapas, a menos que haja uma relação direta entre as duas etapas especificadas na definição do pipeline. Você transmite esses perfis ao definir o processador ou o estimador para sua etapa. Para ver exemplos de como incluir essas funções nessas definições, consulte a documentação do [SDK para SageMaker AI Python](https://sagemaker.readthedocs.io/en/stable/overview.html#using-estimators).
## Configuração do CORS com buckets do Amazon S3
Para garantir que suas imagens sejam importadas para seus pipelines por meio de um bucket do Amazon S3 de forma previsível, uma configuração do CORS deve ser adicionada aos buckets do Amazon S3 de onde as imagens são importadas. Esta seção apresenta instruções sobre como definir a configuração do CORS necessária para seu bucket do Amazon S3. O XML `CORSConfiguration` necessário para o Pipelines é diferente daquele em [Requisito do CORS para dados de imagem de entrada](sms-cors-update.md). Do contrário, você pode usar as informações contidas lá para saber mais sobre o requisito do CORS com buckets do Amazon S3.
Use o código de configuração do CORS a seguir para os buckets do Amazon S3 que hospedam as imagens. Para ter instruções sobre como configurar o CORS, consulte [Configurar o compartilhamento de recursos de origem cruzada (CORS)](https://docs.aws.amazon.com/AmazonS3/latest/user-guide/add-cors-configuration.html) no “Guia do usuário do Amazon Simple Storage Service”. Se você usar o console do Amazon S3 para adicionar a política ao bucket, deverá usar o formato JSON.
**JSON**
```
[
{
"AllowedHeaders": [
"*"
],
"AllowedMethods": [
"PUT"
],
"AllowedOrigins": [
"*"
],
"ExposeHeaders": [
"Access-Control-Allow-Origin"
]
}
]
```
**XML**
```
**PUTAccess-Control-Allow-Origin
```
O seguinte GIF demonstra as instruções encontradas na documentação do Amazon S3 para adicionar uma política de cabeçalho CORS usando o console do Amazon S3:
![\[Gif de como adicionar uma política de cabeçalho CORS usando o console do Amazon S3.\]](http://docs.aws.amazon.com/pt_br/sagemaker/latest/dg/images/sms/gifs/cors-config.gif)
## Personalizar o gerenciamento de acesso para trabalhos do Pipelines
Você pode personalizar ainda mais suas políticas do IAM para que membros selecionados em sua organização possam executar qualquer uma ou todas as etapas do pipeline. Por exemplo, você pode dar permissão a determinados usuários para criar trabalhos de treinamento, a outro grupo de usuários permissão para criar trabalhos de processamento e a todos os seus usuários permissão para executar as etapas restantes. Para usar esse atributo, selecione uma string personalizada que prefixa o nome do seu trabalho. Seu administrador acrescenta o prefixo ao permitido ARNs , enquanto seu cientista de dados inclui esse prefixo nas instanciações do pipeline. Como a política do IAM para usuários permitidos contém um ARN do trabalho com o prefixo especificado, os trabalhos subsequentes da etapa do pipeline têm as permissões necessárias para continuar. O prefixo do trabalho está desativado por padrão: você deve ativar essa opção em sua classe `Pipeline` para usá-la.
Para trabalhos com prefixo desativado, o nome do trabalho é formatado conforme mostrado e é uma concatenação de campos descritos na tabela a seguir:
`pipelines----`
| Campo | Definição |
| --- | --- |
| pipelines | Uma string estática sempre prefixada. Essa string identifica o serviço de orquestração do pipeline como a origem do trabalho. |
| executionId | Um buffer aleatório para a instância em execução do pipeline. |
| stepNamePrefix | O nome da etapa especificada pelo usuário (fornecido no argumento `name` da etapa do pipeline), limitado aos primeiros 20 caracteres. |
| entityToken | Um token aleatório para garantir a idempotência da entidade da etapa. |
| failureCount | O número atual de novas tentativas para concluir o trabalho. |
Nesse caso, nenhum prefixo personalizado é anexado ao nome do trabalho e a política do IAM correspondente deve corresponder a essa string.
Para usuários que ativam o prefixo do trabalho, o nome do trabalho subjacente assume o seguinte formato, com o prefixo personalizado especificado como `MyBaseJobName`:
**-**-**-**
O prefixo personalizado substitui a `pipelines` string estática para ajudar você a restringir a seleção de usuários que podem executar o trabalho de SageMaker IA como parte de um pipeline.
**Restrições de comprimento de prefixo**
Os nomes dos trabalhos têm restrições internas de comprimento específicas para etapas individuais do pipeline. Essa restrição também limita o comprimento do prefixo permitido. Os requisitos de comprimento do prefixo são os seguintes:
| Etapa de pipeline | Comprimento do prefixo |
| --- | --- |
| `[TrainingStep](https://sagemaker.readthedocs.io/en/stable/amazon_sagemaker_model_building_pipeline.html#trainingstep)`, `[ModelStep](https://sagemaker.readthedocs.io/en/stable/workflows/pipelines/sagemaker.workflow.pipelines.html#step-collections)`, `[TransformStep](https://sagemaker.readthedocs.io/en/stable/amazon_sagemaker_model_building_pipeline.html#transformstep)`, `[ProcessingStep](https://sagemaker.readthedocs.io/en/stable/amazon_sagemaker_model_building_pipeline.html#processingstep)`, `[ClarifyCheckStep](https://sagemaker.readthedocs.io/en/stable/amazon_sagemaker_model_building_pipeline.html#clarifycheckstep)`, `[QualityCheckStep](https://sagemaker.readthedocs.io/en/stable/amazon_sagemaker_model_building_pipeline.html#qualitycheckstep)`, `[RegisterModelStep](https://sagemaker.readthedocs.io/en/stable/workflows/pipelines/sagemaker.workflow.pipelines.html#step-collections)` | 38 |
| `[TuningStep](https://sagemaker.readthedocs.io/en/stable/amazon_sagemaker_model_building_pipeline.html#tuningstep)`, `[AutoML](https://sagemaker.readthedocs.io/en/stable/amazon_sagemaker_model_building_pipeline.html#automlstep)` | 6 |
### Aplique prefixos de trabalho a uma política do IAM
Seu administrador cria políticas do IAM, permitindo que usuários de prefixos específicos criem trabalhos. O exemplo de política a seguir permite que cientistas de dados criem trabalhos de treinamento se usarem o prefixo `MyBaseJobName`.
```
{
"Action": "sagemaker:CreateTrainingJob",
"Effect": "Allow",
"Resource": [
"arn:aws:sagemaker:region:account-id:*/MyBaseJobName-*"
]
}
```
### Aplicar prefixos de trabalho às instanciações do pipeline
Especifique seu prefixo com o argumento `*base_job_name` da classe da instância de trabalho.
**nota**
Transmita o prefixo do trabalho com o argumento `*base_job_name` para a instância do trabalho antes de criar uma etapa do pipeline. Essa instância de trabalho contém as informações necessárias para que o trabalho seja executado como uma etapa em um pipeline. Esse argumento varia de acordo com a instância de trabalho usada. A seguinte lista mostra qual argumento usar para cada tipo de etapa do pipeline:
`base_job_name` para as classes `[Estimator](https://sagemaker.readthedocs.io/en/stable/api/training/estimators.html)` (`[TrainingStep](https://sagemaker.readthedocs.io/en/stable/amazon_sagemaker_model_building_pipeline.html#trainingstep)`), `[Processor](https://sagemaker.readthedocs.io/en/stable/api/training/processing.html)` (`[ProcessingStep](https://sagemaker.readthedocs.io/en/stable/amazon_sagemaker_model_building_pipeline.html#processingstep)`) e `[AutoML](https://sagemaker.readthedocs.io/en/stable/api/training/automl.html)` (`[AutoMLStep](https://sagemaker.readthedocs.io/en/stable/amazon_sagemaker_model_building_pipeline.html#automlstep)`)
`tuning_base_job_name` para a classe `[Tuner](https://sagemaker.readthedocs.io/en/stable/api/training/tuner.html)` (`[TuningStep](https://sagemaker.readthedocs.io/en/stable/amazon_sagemaker_model_building_pipeline.html#tuningstep)`)
`transform_base_job_name` para a classe `[Transformer](https://sagemaker.readthedocs.io/en/stable/api/inference/transformer.html)` (`[TransformStep](https://sagemaker.readthedocs.io/en/stable/amazon_sagemaker_model_building_pipeline.html#transformstep)`)
`base_job_name` de `[CheckJobConfig](https://sagemaker.readthedocs.io/en/stable/workflows/pipelines/sagemaker.workflow.pipelines.html#checkjobconfig)` para as classes `[QualityCheckStep](https://sagemaker.readthedocs.io/en/stable/amazon_sagemaker_model_building_pipeline.html#qualitycheckstep)` (Quality Check) e `[ClarifyCheckstep](https://sagemaker.readthedocs.io/en/stable/amazon_sagemaker_model_building_pipeline.html#clarifycheckstep)` (Clarify Check)
Para a classe `[Model](https://sagemaker.readthedocs.io/en/stable/api/inference/model.html)`, o argumento usado depende de você executar `create` ou `register` no seu modelo antes de transmitir o resultado para `[ModelStep](https://sagemaker.readthedocs.io/en/stable/workflows/pipelines/sagemaker.workflow.pipelines.html#step-collections)`
Se você chamar `create`, o prefixo personalizado virá do argumento `name` quando você construir seu modelo (ou seja, `Model(name=)`)
Se você chamar `register`, o prefixo personalizado virá do argumento `model_package_name` da sua chamada para `register` (ou seja, `my_model.register(model_package_name=)`)
O exemplo a seguir mostra como especificar um prefixo para uma nova instância do trabalho de treinamento.
```
# Create a job instance
xgb_train = Estimator(
image_uri=image_uri,
instance_type="ml.m5.xlarge",
instance_count=1,
output_path=model_path,
role=role,
subnets=["subnet-0ab12c34567de89f0"],
base_job_name="MyBaseJobName"
security_group_ids=["sg-1a2bbcc3bd4444e55"],
tags = [ ... ]
encrypt_inter_container_traffic=True,
)
# Attach your job instance to a pipeline step
step_train = TrainingStep(
name="TestTrainingJob",
estimator=xgb_train,
inputs={
"train": TrainingInput(...),
"validation": TrainingInput(...)
}
)
```
O prefixo do trabalho está desativado por padrão. Para optar por esse atributo, use a opção `use_custom_job_prefix` de `PipelineDefinitionConfig` conforme mostrado no trecho a seguir:
```
from sagemaker.workflow.pipeline_definition_config import PipelineDefinitionConfig
# Create a definition configuration and toggle on custom prefixing
definition_config = PipelineDefinitionConfig(use_custom_job_prefix=True);
# Create a pipeline with a custom prefix
pipeline = Pipeline(
name="MyJobPrefixedPipeline",
parameters=[...]
steps=[...]
pipeline_definition_config=definition_config
)
```
Criar e executar seu pipeline. O exemplo a seguir cria e executa um pipeline e também demonstra como você pode desativar o prefixo de trabalhos e executá-lo novamente.
```
pipeline.create(role_arn=sagemaker.get_execution_role())
# Optionally, call definition() to confirm your prefixed job names are in the built JSON
pipeline.definition()
pipeline.start()
# To run a pipeline without custom-prefixes, toggle off use_custom_job_prefix, update the pipeline
# via upsert() or update(), and start a new run
definition_config = PipelineDefinitionConfig(use_custom_job_prefix=False)
pipeline.pipeline_definition_config = definition_config
pipeline.update()
execution = pipeline.start()
```
Da mesma forma, você pode ativar o atributo para pipelines existentes e iniciar uma nova execução que usa prefixos de trabalho.
```
definition_config = PipelineDefinitionConfig(use_custom_job_prefix=True)
pipeline.pipeline_definition_config = definition_config
pipeline.update()
execution = pipeline.start()
```
Por fim, você pode visualizar seu trabalho com prefixo personalizado chamando a execução do pipeline `list_steps`.
```
steps = execution.list_steps()
prefixed_training_job_name = steps['PipelineExecutionSteps'][0]['Metadata']['TrainingJob']['Arn']
```
## Personalizar o acesso a versões do pipeline
Você pode conceder acesso personalizado a versões específicas do Amazon SageMaker Pipelines usando a chave de `sagemaker:PipelineVersionId` condição. Por exemplo, a política abaixo concede acesso para iniciar execuções ou atualizar a versão do pipeline somente para a versão ID 6 e posterior.
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": {
"Sid": "AllowStartPipelineExecution",
"Effect": "Allow",
"Action": [
"sagemaker:StartPipelineExecution",
"sagemaker:UpdatePipelineVersion"
],
"Resource": "*",
"Condition": {
"NumericGreaterThanEquals": {
"sagemaker:PipelineVersionId": 6
}
}
}
}
```
------
Para obter mais informações sobre as chaves de condição suportadas, consulte [Chaves de condição para Amazon SageMaker AI](https://docs.aws.amazon.com//service-authorization/latest/reference/list_amazonsagemaker.html#amazonsagemaker-policy-keys).
## Políticas de controle de serviço com pipelines
As políticas de controle de serviço (SCPs) são um tipo de política organizacional que você pode usar para gerenciar permissões em sua organização. SCPs ofereça controle central sobre o máximo de permissões disponíveis para todas as contas em sua organização. Ao usar Pipelines em sua organização, você pode garantir que os cientistas de dados gerenciem suas execuções de pipeline sem precisar interagir com o AWS console.
Se você estiver usando uma VPC com seu SCP que restringe o acesso ao Amazon S3, você precisa tomar medidas para permitir que seu pipeline acesse outros recursos do Amazon S3.
Para permitir que o Pipelines acesse o Amazon S3 fora da sua VPC com a função `JsonGet`, atualize o SCP da sua organização para garantir que a função que está usando o Pipelines possa acessar o Amazon S3. Para fazer isso, crie uma exceção para os perfis que estão sendo usados pelo executor do Pipelines por meio do perfil de execução de pipeline usando uma tag de entidade principal e uma chave de condição.
**Para permitir que o Pipelines acesse o Amazon S3 fora da sua VPC**
1. Crie uma tag exclusiva para sua função de execução do pipeline seguindo as etapas em [Como marcar usuários e funções do IAM](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_tags.html).
1. Conceda uma exceção em seu SCP usando a chave de condição `Aws:PrincipalTag IAM` da tag que você criou. Para obter mais informações, consulte [Criar, atualizar e excluir políticas de controle de serviço](https://docs.aws.amazon.com/organizations/latest/userguide/orgs_manage_policies_scps_create.html).
# Configurar a compatibilidade entre contas para o Pipelines
O suporte entre contas para o Amazon SageMaker Pipelines permite que você colabore em pipelines de aprendizado de máquina com outras equipes ou organizações que operam em contas diferentes. AWS Ao configurar o compartilhamento de pipeline entre contas, você pode conceder acesso controlado aos pipelines, permitir que outras contas visualizem os detalhes de pipeline, executem ações e monitorem as execuções. O tópico a seguir aborda como configurar o compartilhamento de pipeline entre contas, as diferentes políticas de permissão disponíveis para recursos compartilhados e como acessar e interagir com entidades de pipeline compartilhadas por meio de chamadas diretas de API para a SageMaker IA.
## Configurar o compartilhamento de pipeline entre contas
SageMaker A IA usa o [AWS Resource Access Manager](https://docs.aws.amazon.com/ram/latest/userguide/what-is.html) (AWS RAM) para ajudar você a compartilhar com segurança suas entidades de funil em todas as contas.
### Criar o compartilhamento de um recurso
1. Selecione **Criar um compartilhamento de recursos** por meio do [console do AWS RAM](https://console.aws.amazon.com/ram/home).
1. Ao especificar detalhes do compartilhamento de recursos, escolha o tipo de recurso do Pipelines e selecione um ou mais pipelines que você deseja compartilhar. Quando você compartilha um pipeline com qualquer outra conta, todas as suas execuções também são compartilhadas implicitamente.
1. Associar permissões a um compartilhamento de recursos. Escolha a política de permissão padrão somente leitura ou a política de permissão de execução estendida do pipeline. Para obter mais informações detalhadas, consulte [Políticas de permissão para recursos do Pipelines](#build-and-manage-xaccount-permissions).
**nota**
Se você selecionar a política de execução estendida do pipeline, observe que todos os comandos de início, interrupção e repetição chamados por contas compartilhadas usam recursos na AWS conta que compartilhou o pipeline.
1. Use IDs a AWS conta para especificar as contas às quais você deseja conceder acesso aos seus recursos compartilhados.
1. Revise sua configuração de compartilhamento de recursos e selecione **Criar compartilhamento de recursos**. Pode levar alguns minutos para que os compartilhamentos de recursos e as associações principais sejam concluídos.
Para obter mais informações, consulte [Compartilhar seus recursos da AWS](https://docs.aws.amazon.com/ram/latest/userguide/getting-started-sharing.html) no *Guia do usuário do Resource Access Manager da AWS *.
### Receba respostas para seu convite de compartilhamento de recursos
Depois que o compartilhamento de recursos e as associações principais são definidas, as contas da AWS especificadas receberão um convite para participar desse compartilhamento. As AWS contas devem aceitar o convite para obter acesso a todos os recursos compartilhados.
Para obter mais informações sobre como aceitar um convite de compartilhamento de recursos por meio de AWS RAM, consulte [Usando AWS recursos compartilhados](https://docs.aws.amazon.com/ram/latest/userguide/getting-started-shared.html) no *Guia do Usuário do AWS Resource Access Manager*.
## Políticas de permissão para recursos do Pipelines
Ao criar seu compartilhamento de recursos, escolha uma das duas políticas de permissão compatíveis para associar ao tipo de recurso do SageMaker AI Pipeline. Ambas as políticas concedem acesso a qualquer pipeline selecionado e a todas as suas execuções.
### Permissões somente leitura padrão
A política `AWSRAMDefaultPermissionSageMakerPipeline` permite as seguintes ações somente leitura:
```
"sagemaker:DescribePipeline"
"sagemaker:DescribePipelineDefinitionForExecution"
"sagemaker:DescribePipelineExecution"
"sagemaker:ListPipelineExecutions"
"sagemaker:ListPipelineExecutionSteps"
"sagemaker:ListPipelineParametersForExecution"
"sagemaker:Search"
```
### Permissões estendidas de execução de pipeline
A política `AWSRAMPermissionSageMakerPipelineAllowExecution` inclui todas as permissões de somente leitura da política padrão e também permite que contas compartilhadas iniciem, parem e tentem novamente as execuções do pipeline.
**nota**
Esteja atento ao uso de AWS recursos ao usar a política estendida de permissão de execução do pipeline. Com essa política, as contas compartilhadas podem iniciar, interromper e repetir as execuções do pipeline. Todos os recursos usados para execuções de funis compartilhados são consumidos pela conta do proprietário.
A política de permissão de execução de pipeline estendida permite as seguintes ações:
```
"sagemaker:DescribePipeline"
"sagemaker:DescribePipelineDefinitionForExecution"
"sagemaker:DescribePipelineExecution"
"sagemaker:ListPipelineExecutions"
"sagemaker:ListPipelineExecutionSteps"
"sagemaker:ListPipelineParametersForExecution"
"sagemaker:StartPipelineExecution"
"sagemaker:StopPipelineExecution"
"sagemaker:RetryPipelineExecution"
"sagemaker:Search"
```
## Acesse entidades de pipeline compartilhadas por meio de chamadas diretas de API
Depois que o compartilhamento de pipeline entre contas estiver configurado, você poderá chamar as seguintes ações de SageMaker API usando um ARN de pipeline:
**nota**
Você só pode chamar comandos da API se eles estiverem incluídos nas permissões associadas ao seu compartilhamento de recursos. Se você selecionar a `AWSRAMPermissionSageMakerPipelineAllowExecution` política, os comandos start, stop e retry usarão recursos na AWS conta que compartilhou o pipeline.
+ [DescribePipeline](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_DescribePipeline.html)
+ [DescribePipelineDefinitionForExecution](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_DescribePipelineDefinitionForExecution.html)
+ [DescribePipelineExecution](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_DescribePipelineExecution.html)
+ [ListPipelineExecutions](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_ListPipelineExecutions.html)
+ [ListPipelineExecutionSteps](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_ListPipelineExecutionSteps.html)
+ [ListPipelineParametersForExecution](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_ListPipelineParametersForExecution.html)
+ [StartPipelineExecution](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_StartPipelineExecution.html)
+ [StopPipelineExecution](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_StopPipelineExecution.html)
+ [RetryPipelineExecution](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_RetryPipelineExecution.html)
# Parâmetros de pipeline
Você pode introduzir variáveis na definição do seu pipeline usando parâmetros. Você pode referenciar os parâmetros que você define em toda a definição do pipeline. Os parâmetros têm um valor padrão, que você pode substituir especificando os valores dos parâmetros ao iniciar a execução de um pipeline. O valor padrão deve ser uma instância que corresponda ao tipo de parâmetro. Todos os parâmetros usados nas definições de etapas devem ser definidos na definição do pipeline. Este tópico descreve os parâmetros que você pode definir e como implementá-los.
O Amazon SageMaker Pipelines oferece suporte aos seguintes tipos de parâmetros:
+ `ParameterString`: representando um parâmetro de string.
+ `ParameterInteger`: representando um parâmetro inteiro.
+ `ParameterFloat`: representando um parâmetro flutuante.
+ `ParameterBoolean`: representando um tipo booleano de Python.
Os grupos e parâmetros têm o seguinte formato:
```
= (
name="",
default_value=
)
```
O exemplo a seguir mostra uma implementação de parâmetros de exemplo.
```
from sagemaker.workflow.parameters import (
ParameterInteger,
ParameterString,
ParameterFloat,
ParameterBoolean
)
processing_instance_count = ParameterInteger(
name="ProcessingInstanceCount",
default_value=1
)
```
Você passa o parâmetro ao criar seu pipeline, conforme mostrado no exemplo a seguir.
```
pipeline = Pipeline(
name=pipeline_name,
parameters=[
processing_instance_count
],
steps=[step_process]
)
```
Também é possível passar um valor de parâmetro diferente do padrão para uma execução de pipeline, conforme mostrado no exemplo a seguir.
```
execution = pipeline.start(
parameters=dict(
ProcessingInstanceCount="2",
ModelApprovalStatus="Approved"
)
)
```
Você pode manipular parâmetros com funções do SDK do SageMaker Python, como. `[ sagemaker.workflow.functions.Join](https://sagemaker.readthedocs.io/en/stable/workflows/pipelines/sagemaker.workflow.pipelines.html#sagemaker.workflow.functions.Join)` Para obter mais informações sobre parâmetros, consulte [Parâmetros de SageMaker pipelines](https://sagemaker.readthedocs.io/en/stable/workflows/pipelines/sagemaker.workflow.pipelines.html#parameters).
Para conhecer as limitações conhecidas dos parâmetros dos pipelines, consulte *[Limitações — Parametrização no SDK](https://sagemaker.readthedocs.io/en/stable/amazon_sagemaker_model_building_pipeline.html#parameterization)* do Amazon [Python SageMaker ](https://sagemaker.readthedocs.io/en/stable).
# Etapas do Pipelines
Os pipelines são compostos por etapas. Essas etapas definem as ações que o pipeline executa e as relações entre as etapas usando propriedades. A página a seguir descreve os tipos de etapas, suas propriedades e as relações entre elas.
**Topics**
+ [Adicionar uma etapa](build-and-manage-steps-types.md)
+ [Adicionar integração](build-and-manage-steps-integration.md)
+ [Propriedades da etapa](#build-and-manage-properties)
+ [Paralelismo de etapas](#build-and-manage-parallelism)
+ [Dependência de dados entre etapas](#build-and-manage-data-dependency)
+ [Dependência personalizada entre etapas](#build-and-manage-custom-dependency)
+ [Imagens personalizadas em uma etapa](#build-and-manage-images)
# 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 do usuário do drag-and-drop Pipelines, 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 drag-and-drop interface do usuário 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 de compartilhamento de recursos entre origens (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 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 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\$1top\$1model\$1s3\$1uri 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.
## Etapa de ajuste fino
O ajuste fino 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. [Ajuste 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 do **modelo de ajuste fino** ao seu pipeline usando o drag-and-drop editor, 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 **Ajustar modelo** e arraste-o até o canvas.
1. No canvas, escolha a etapa **Ajustar modelo** 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 **Ajustar modelo** que você adicionou, clique e arraste o cursor da etapa até a etapa **Ajustar modelo** para criar uma borda.
1. Se o canvas incluir alguma etapa que suceda imediatamente a etapa **Ajustar modelo** que você adicionou, clique e arraste o cursor da etapa **Ajustar 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\$1step. 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\$1collections. 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\$1collections. 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 existente. A inferência em tempo real é ideal para workloads 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[Inferência em tempo real](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 a 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 do modelo ao seu Pipeline no drag-and-drop editor, 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 drag-and-drop visual, 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\$1step. 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\$1step. 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 liga para uma das seguintes opções 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\$1step. 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\$1helper.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\$1step. 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\$1args](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 seus endpoints de 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\$1args](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\$1step. 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 drag-and-drop interface do Pipelines, use o [Executar a etapa de código](#step-type-executecode) para executar seu notebook. 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\$1step. 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]
),
)
```
------
# Adicionar integração
MLflow a integração permite que você use MLflow com pipelines para selecionar um servidor de rastreamento ou aplicativo sem servidor, escolher um experimento e registrar métricas.
## Principais conceitos
**Criação de aplicativo padrão** - Um MLflow aplicativo padrão será criado quando você entrar no editor visual do pipeline.
**Painel de integrações** - Inclui um novo painel de integrações MLflow, que você pode selecionar e configurar.
**Atualizar aplicativo e experimento** - A opção de substituir o aplicativo e o experimento selecionados durante a execução do pipeline.
## Como funciona
+ Acesse o **Pipeline Visual Editor**
+ Escolha **Integração** na barra de ferramentas
+ Escolha **MLflow**
+ Configure o MLflow aplicativo e experimente
## Exemplo de capturas de tela
Painel lateral de integrações
![\[A descrição do que fazer.\]](http://docs.aws.amazon.com/pt_br/sagemaker/latest/dg/images/screenshot-pipeline-1.png)
MLflow configuração
![\[A descrição do que fazer.\]](http://docs.aws.amazon.com/pt_br/sagemaker/latest/dg/images/screenshot-pipeline-2.png)
Como substituir o experimento durante a execução do pipeline
![\[A descrição do que fazer.\]](http://docs.aws.amazon.com/pt_br/sagemaker/latest/dg/images/screenshot-pipeline-3.png)
## Propriedades da etapa
Use o atributo `properties` para adicionar dependências de dados entre as etapas do pipeline. Essas dependências de dados são então usadas pelo Pipelines para criar o DAG a partir da definição de pipeline. Essas propriedades podem ser referenciadas como valores de espaço reservado e são resolvidas em runtime.
O `properties` atributo de uma etapa do Pipelines corresponde ao objeto retornado por uma `Describe` chamada para o tipo de trabalho de SageMaker IA correspondente. Para cada tipo de trabalho, a chamada `Describe` retorna o seguinte objeto de resposta:
+ `ProcessingStep` – [DescribeProcessingJob](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_DescribeProcessingJob.html)
+ `TrainingStep` – [DescribeTrainingJob](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_DescribeTrainingJob.html)
+ `TransformStep` – [DescribeTransformJob](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_DescribeTransformJob.html)
[Para verificar quais propriedades são referenciáveis para cada tipo de etapa durante a criação da dependência de dados, consulte Dependência de *[dados - Referência de propriedades no](https://sagemaker.readthedocs.io/en/stable/amazon_sagemaker_model_building_pipeline.html#data-dependency-property-reference)* SDK do Amazon Python. SageMaker ](https://sagemaker.readthedocs.io/en/stable)
## Paralelismo de etapas
Quando uma etapa não depende de nenhuma outra etapa, ela é executada imediatamente após a execução do pipeline. No entanto, executar muitas etapas do pipeline em paralelo pode esgotar rapidamente os recursos disponíveis. Controle o número de etapas simultâneas para a execução de um pipeline com `ParallelismConfiguration`.
O exemplo a seguir é usado `ParallelismConfiguration` para definir o limite de etapas simultâneas como cinco.
```
pipeline.create(
parallelism_config=ParallelismConfiguration(5),
)
```
## Dependência de dados entre etapas
Você define a estrutura do seu DAG especificando as relações de dados entre as etapas. Para criar dependências de dados entre as etapas, transmita as propriedades de uma etapa como entrada para outra etapa no pipeline. A etapa que recebe a entrada não é iniciada até que a etapa que fornece a entrada termine de ser executada.
Uma dependência de dados usa JsonPath notação no formato a seguir. Esse formato percorre o arquivo de propriedades JSON. Isso significa que você pode acrescentar quantas ** instâncias forem necessárias para alcançar a propriedade aninhada desejada no arquivo. Para obter mais informações sobre JsonPath notação, consulte o [JsonPath repositório](https://github.com/json-path/JsonPath).
```
.properties..
```
O exemplo a seguir mostra como especificar um bucket do Amazon S3 usando a propriedade `ProcessingOutputConfig` de uma etapa de processamento.
```
step_process.properties.ProcessingOutputConfig.Outputs["train_data"].S3Output.S3Uri
```
Para criar a dependência de dados, passe o bucket para uma etapa de treinamento da seguinte forma:
```
from sagemaker.workflow.pipeline_context import PipelineSession
sklearn_train = SKLearn(..., sagemaker_session=PipelineSession())
step_train = TrainingStep(
name="CensusTrain",
step_args=sklearn_train.fit(inputs=TrainingInput(
s3_data=step_process.properties.ProcessingOutputConfig.Outputs[
"train_data"].S3Output.S3Uri
))
)
```
[Para verificar quais propriedades são referenciáveis para cada tipo de etapa durante a criação da dependência de dados, consulte Dependência de *[dados - Referência de propriedades no](https://sagemaker.readthedocs.io/en/stable/amazon_sagemaker_model_building_pipeline.html#data-dependency-property-reference)* SDK do Amazon Python. SageMaker ](https://sagemaker.readthedocs.io/en/stable)
## Dependência personalizada entre etapas
Quando você especifica uma dependência de dados, o Pipelines fornece a conexão de dados entre as etapas. Como alternativa, uma etapa pode acessar os dados de uma etapa anterior sem usar o Pipelines diretamente. Nesse caso, você pode criar uma dependência personalizada que diga ao Pipelines que não inicie uma etapa até que a execução de outra etapa seja concluída. Você cria uma dependência personalizada especificando o atributo de uma etapa `DependsOn`.
Como exemplo, o exemplo a seguir define uma etapa `C` que começa somente após a execução da etapa `A` e `B` da etapa.
```
{
'Steps': [
{'Name':'A', ...},
{'Name':'B', ...},
{'Name':'C', 'DependsOn': ['A', 'B']}
]
}
```
O Pipelines fará uma exceção de validação se a dependência criar uma dependência cíclica.
O exemplo a seguir cria uma etapa de treinamento que começa após a conclusão da execução de uma etapa de processamento.
```
processing_step = ProcessingStep(...)
training_step = TrainingStep(...)
training_step.add_depends_on([processing_step])
```
O exemplo a seguir cria uma etapa de treinamento que não começa até que duas etapas de processamento diferentes terminem de ser executadas.
```
processing_step_1 = ProcessingStep(...)
processing_step_2 = ProcessingStep(...)
training_step = TrainingStep(...)
training_step.add_depends_on([processing_step_1, processing_step_2])
```
O seguinte fornece uma forma alternativa de criar a dependência personalizada:
```
training_step.add_depends_on([processing_step_1])
training_step.add_depends_on([processing_step_2])
```
O exemplo a seguir cria uma etapa de treinamento que recebe informações de uma etapa de processamento e aguarda a conclusão da execução de uma etapa de processamento diferente.
```
processing_step_1 = ProcessingStep(...)
processing_step_2 = ProcessingStep(...)
training_step = TrainingStep(
...,
inputs=TrainingInput(
s3_data=processing_step_1.properties.ProcessingOutputConfig.Outputs[
"train_data"
].S3Output.S3Uri
)
training_step.add_depends_on([processing_step_2])
```
O exemplo a seguir mostra como recuperar uma lista de strings das dependências personalizadas de uma etapa.
```
custom_dependencies = training_step.depends_on
```
## Imagens personalizadas em uma etapa
Você pode usar qualquer uma das [imagens do SageMaker AI Deep Learning Container](https://github.com/aws/deep-learning-containers/blob/master/available_images.md) disponíveis ao criar uma etapa em seu pipeline.
Também é possível usar seu próprio contêiner com etapas do pipeline. Como você não pode criar uma imagem no Studio Classic, você deve criar sua imagem usando outro método antes de usá-la com o Pipelines.
Para usar seu próprio contêiner ao criar as etapas do seu pipeline, inclua o URI da imagem na definição do estimador. Para obter mais informações sobre como usar seu próprio contêiner com SageMaker IA, consulte Como [usar contêineres do Docker com SageMaker IA](https://docs.aws.amazon.com/sagemaker/latest/dg/docker-containers.html).
# Lift-and-shift Código Python com o decorador @step
O decorador `@step` é um atributo que converte seu código local de machine learning (ML) em uma ou mais etapas de pipeline. Você pode escrever sua função de ML da mesma forma que faria em qualquer projeto de ML. Depois de testada localmente ou como um trabalho de treinamento usando o `@remote` decorador, você pode converter a função em uma etapa do pipeline de SageMaker IA adicionando um `@step` decorador. Em seguida, você pode passar o resultado da chamada da função decorada por `@step` como uma etapa para o Pipelines, para criar e executar um pipeline. Você também pode encadear uma série de funções com o decorador `@step` para criar um pipeline de gráfico acíclico direcionado (DAG) de várias etapas.
A configuração para usar o decorador `@step` é a mesma configuração para usar o decorador `@remote`. Você pode consultar a documentação da função remota para obter detalhes sobre como [configurar o ambiente](https://docs.aws.amazon.com/sagemaker/latest/dg/train-remote-decorator.html#train-remote-decorator-env) e [usar um arquivo de configuração](https://docs.aws.amazon.com/sagemaker/latest/dg/train-remote-decorator-config.html) para definir padrões. Para obter mais informações sobre o decorador `@step`, consulte [sagemaker.workflow.function\$1step.step](https://sagemaker.readthedocs.io/en/stable/workflows/pipelines/sagemaker.workflow.pipelines.html#sagemaker.workflow.function_step.step).
Para ver cadernos de exemplo que demonstram o uso do decorador `@step`, consulte [cadernos de exemplo do decorador @step](https://github.com/aws/amazon-sagemaker-examples/tree/main/sagemaker-pipelines/step-decorator).
As seções a seguir explicam como você pode anotar seu código de ML local com um decorador `@step` para criar uma etapa, criar e executar um pipeline usando a etapa e personalizar a experiência para seu caso de uso.
**Topics**
+ [Criar um pipeline com funções decoradas por `@step`](pipelines-step-decorator-create-pipeline.md)
+ [Execute um pipeline](pipelines-step-decorator-run-pipeline.md)
+ [Configure seu pipeline](pipelines-step-decorator-cfg-pipeline.md)
+ [Práticas recomendadas](pipelines-step-decorator-best.md)
+ [Limitações](pipelines-step-decorator-limit.md)
# Criar um pipeline com funções decoradas por `@step`
Você pode criar um pipeline convertendo funções do Python em etapas de pipeline usando o decorador `@step`, criando dependências entre essas funções para criar um gráfico de pipeline (ou gráfico acíclico direcionado (DAG)) e passando os nós da folha desse gráfico como uma lista de etapas para o pipeline. As seções a seguir explicam esse procedimento detalhadamente com exemplos.
**Topics**
+ [Converter uma função em uma etapa](#pipelines-step-decorator-run-pipeline-convert)
+ [Crie dependências entre as etapas](#pipelines-step-decorator-run-pipeline-link)
+ [Use `ConditionStep` com etapas decoradas por `@step`](#pipelines-step-decorator-condition)
+ [Definir um pipeline usando a saída `DelayedReturn` das etapas](#pipelines-step-define-delayed)
+ [Criar um pipeline](#pipelines-step-decorator-pipeline-create)
## Converter uma função em uma etapa
Para criar uma etapa usando o decorador `@step`, anote a função com `@step`. O exemplo a seguir mostra uma função decorada por `@step` que pré-processa os dados.
```
from sagemaker.workflow.function_step import step
@step
def preprocess(raw_data):
df = pandas.read_csv(raw_data)
...
return procesed_dataframe
step_process_result = preprocess(raw_data)
```
Quando você invoca uma função `@step` -decorada, a SageMaker IA retorna uma `DelayedReturn` instância em vez de executar a função. Uma instância `DelayedReturn` é um proxy para o retorno real da função. A instância `DelayedReturn` pode ser passada para outra função como argumento ou diretamente para uma instância do pipeline como uma etapa. Para obter informações sobre a `DelayedReturn` classe, consulte [sagemaker.workflow.function\$1step. DelayedReturn](https://sagemaker.readthedocs.io/en/stable/workflows/pipelines/sagemaker.workflow.pipelines.html#sagemaker.workflow.function_step.DelayedReturn).
## Crie dependências entre as etapas
Ao criar uma dependência entre duas etapas, você cria uma conexão entre as etapas no gráfico do pipeline. As seções a seguir apresentam várias maneiras de criar uma dependência entre as etapas do pipeline.
### Dependências de dados por meio de argumentos de entrada
Passar a saída `DelayedReturn` de uma função como entrada para outra função cria automaticamente uma dependência de dados no DAG do pipeline. No exemplo a seguir, passar a saída `DelayedReturn` da função `preprocess` para a função `train` cria uma dependência entre `preprocess` e `train`.
```
from sagemaker.workflow.function_step import step
@step
def preprocess(raw_data):
df = pandas.read_csv(raw_data)
...
return procesed_dataframe
@step
def train(training_data):
...
return trained_model
step_process_result = preprocess(raw_data)
step_train_result = train(step_process_result)
```
O exemplo anterior define uma função de treinamento que é decorada com`@step`. Quando essa função é invocada, ela recebe a saída `DelayedReturn` da etapa do pipeline de pré-processamento como entrada. A invocação da função de treinamento retorna outra instância `DelayedReturn`. Essa instância contém as informações sobre todas as etapas anteriores definidas nessa função (ou seja, a etapa `preprocess` no exemplo) que formam o DAG do pipeline.
No exemplo anterior, a função `preprocess` retorna um único valor. Para tipos de retorno mais complexos, como listas ou tuplas, consulte [Limitações](pipelines-step-decorator-limit.md).
### Definir dependências personalizadas
No exemplo anterior, a função `train` recebeu a saída `DelayedReturn` de `preprocess` e criou uma dependência. Se você quiser definir a dependência explicitamente sem passar a saída da etapa anterior, use a função `add_depends_on` com a etapa. Você pode usar a função `get_step()` para recuperar a etapa subjacente de sua instância `DelayedReturn` e, em seguida, chamar `add_depends_on`\$1on com a dependência como entrada. Para ver a definição da função `get_step()`, consulte [sagemaker.workflow.step\$1outputs.get\$1step](https://sagemaker.readthedocs.io/en/stable/workflows/pipelines/sagemaker.workflow.pipelines.html#sagemaker.workflow.step_outputs.get_step). O exemplo a seguir mostra como criar uma dependência entre `preprocess` e `train` usando `get_step()` e `add_depends_on()`.
```
from sagemaker.workflow.step_outputs import get_step
@step
def preprocess(raw_data):
df = pandas.read_csv(raw_data)
...
processed_data = ..
return s3.upload(processed_data)
@step
def train():
training_data = s3.download(....)
...
return trained_model
step_process_result = preprocess(raw_data)
step_train_result = train()
get_step(step_train_result).add_depends_on([step_process_result])
```
### Transmita dados de e para uma função decorada por `@step` para uma etapa tradicional de pipeline
Você pode criar um pipeline que inclua uma etapa decorada por `@step` e uma etapa tradicional de pipeline para transmitir dados entre elas. Por exemplo, você pode usar `ProcessingStep` para processar os dados e passar o resultado para a função de treinamento decorada por `@step`. No exemplo a seguir, uma etapa de treinamento decorada por `@step` faz referência à saída de uma etapa de processamento.
```
# Define processing step
from sagemaker.sklearn.processing import SKLearnProcessor
from sagemaker.processing import ProcessingInput, ProcessingOutput
from sagemaker.workflow.steps import ProcessingStep
sklearn_processor = SKLearnProcessor(
framework_version='1.2-1',
role='arn:aws:iam::123456789012:role/SagemakerExecutionRole',
instance_type='ml.m5.large',
instance_count='1',
)
inputs = [
ProcessingInput(source=input_data, destination="/opt/ml/processing/input"),
]
outputs = [
ProcessingOutput(output_name="train", source="/opt/ml/processing/train"),
ProcessingOutput(output_name="validation", source="/opt/ml/processing/validation"),
ProcessingOutput(output_name="test", source="/opt/ml/processing/test")
]
process_step = ProcessingStep(
name="MyProcessStep",
step_args=sklearn_processor.run(inputs=inputs, outputs=outputs,code='preprocessing.py'),
)
```
```
# Define a @step-decorated train step which references the
# output of a processing step
@step
def train(train_data_path, test_data_path):
...
return trained_model
step_train_result = train(
process_step.properties.ProcessingOutputConfig.Outputs["train"].S3Output.S3Uri,
process_step.properties.ProcessingOutputConfig.Outputs["test"].S3Output.S3Uri,
)
```
## Use `ConditionStep` com etapas decoradas por `@step`
Os pipelines oferecem apoio a uma classe `ConditionStep` que avalia os resultados das etapas anteriores para decidir qual ação tomar no pipeline. Você também pode usar `ConditionStep` com uma etapa decorada por `@step`. Para usar a saída de qualquer etapa decorada por `@step` com `ConditionStep`, insira a saída dessa etapa como argumento para `ConditionStep`. No exemplo a seguir, a etapa de condição recebe a saída da etapa de avaliação de modelo decorada por `@step`.
```
# Define steps
@step(name="evaluate")
def evaluate_model():
# code to evaluate the model
return {
"rmse":rmse_value
}
@step(name="register")
def register_model():
# code to register the model
...
```
```
# Define ConditionStep
from sagemaker.workflow.condition_step import ConditionStep
from sagemaker.workflow.conditions import ConditionGreaterThanOrEqualTo
from sagemaker.workflow.fail_step import FailStep
conditionally_register = ConditionStep(
name="conditional_register",
conditions=[
ConditionGreaterThanOrEqualTo(
# Output of the evaluate step must be json serializable
left=evaluate_model()["rmse"], #
right=5,
)
],
if_steps=[FailStep(name="Fail", error_message="Model performance is not good enough")],
else_steps=[register_model()],
)
```
## Definir um pipeline usando a saída `DelayedReturn` das etapas
Você define um pipeline da mesma forma, independentemente de usar ou não um decorador `@step`. Ao passar uma instância `DelayedReturn` para seu pipeline, você não precisa passar uma lista completa de etapas para criar o pipeline. O SDK infere automaticamente as etapas anteriores com base nas dependências que você define. Todas as etapas anteriores dos objetos `Step` que você passou para o pipeline ou objetos `DelayedReturn` são incluídas no gráfico do pipeline. No exemplo a seguir, o pipeline recebe o objeto `DelayedReturn` da função `train`. SageMaker A IA adiciona a `preprocess` etapa, como etapa anterior`train`, ao gráfico do pipeline.
```
from sagemaker.workflow.pipeline import Pipeline
pipeline = Pipeline(
name="",
steps=[step_train_result],
sagemaker_session=,
)
```
Se não houver dados ou dependências personalizadas entre as etapas e você executar várias etapas em paralelo, o gráfico do pipeline terá mais de um nó de folha. Passe todos esses nós de folha em uma lista para o argumento `steps` em sua definição de pipeline, conforme mostrado no seguinte exemplo:
```
@step
def process1():
...
return data
@step
def process2():
...
return data
step_process1_result = process1()
step_process2_result = process2()
pipeline = Pipeline(
name="",
steps=[step_process1_result, step_process2_result],
sagemaker_session=sagemaker-session,
)
```
Quando o pipeline é executado, as duas etapas são executadas paralelamente.
Você só passa os nós de folha do gráfico para o pipeline porque os nós de folha contêm informações sobre todas as etapas anteriores definidas por meio de dados ou dependências personalizadas. Ao compilar o pipeline, a SageMaker IA também infere todas as etapas subsequentes que formam o gráfico do pipeline e adiciona cada uma delas como uma etapa separada ao pipeline.
## Criar um pipeline
Crie um pipeline chamando `pipeline.create()`, como mostrado no trecho a seguir. Para obter detalhes sobre `create()`, consulte [sagemaker.workflow.pipeline.Pipeline.create](https://sagemaker.readthedocs.io/en/stable/workflows/pipelines/sagemaker.workflow.pipelines.html#sagemaker.workflow.pipeline.Pipeline.create).
```
role = "pipeline-role"
pipeline.create(role)
```
Quando você liga`pipeline.create()`, a SageMaker IA compila todas as etapas definidas como parte da instância do pipeline. SageMaker A IA carrega a função serializada, os argumentos e todos os outros artefatos relacionados à etapa para o Amazon S3.
Os dados residem no bucket do S3 de acordo com a seguinte estrutura:
```
s3_root_uri/
pipeline_name/
sm_rf_user_ws/
workspace.zip # archive of the current working directory (workdir)
step_name/
timestamp/
arguments/ # serialized function arguments
function/ # serialized function
pre_train_dependencies/ # any dependencies and pre_execution scripts provided for the step
execution_id/
step_name/
results # returned output from the serialized function including the model
```
`s3_root_uri`é definido no arquivo de configuração do SageMaker AI e se aplica a todo o pipeline. Se indefinido, o bucket de SageMaker IA padrão será usado.
**nota**
Toda vez que a SageMaker IA compila um pipeline, a SageMaker IA salva as funções, argumentos e dependências serializados das etapas em uma pasta com a data e hora atual. Isso ocorre toda vez que você executa `pipeline.create()`, `pipeline.update()`, `pipeline.upsert()` ou `pipeline.definition()`.
# Execute um pipeline
A página a seguir descreve como executar um pipeline com o Amazon SageMaker Pipelines, com recursos de SageMaker IA ou localmente.
Inicie uma nova execução de pipeline com a `pipeline.start()` função, como você faria com uma execução de pipeline de SageMaker IA tradicional. Para obter informações sobre a função `start()`, consulte [sagemaker.workflow.pipeline.Pipeline.start](https://sagemaker.readthedocs.io/en/stable/workflows/pipelines/sagemaker.workflow.pipelines.html#sagemaker.workflow.pipeline.Pipeline.start).
**nota**
Uma etapa definida usando o decorador `@step` é executada como um trabalho de treinamento. Portanto, esteja ciente das seguintes limitações:
Limites de instância e limites de tarefas de treinamento em suas contas. Atualize seus limites adequadamente para evitar problemas de limitação de recursos ou controle de utilização.
Os custos monetários associados a cada execução de uma etapa de treinamento no pipeline. Para obter mais detalhes, consulte [Amazon SageMaker Pricing](https://aws.amazon.com/sagemaker/pricing/).
## Recupere resultados de uma execução de pipeline localmente
Para ver o resultado de qualquer etapa da execução de um pipeline, use [execution.result()](https://sagemaker.readthedocs.io/en/stable/workflows/pipelines/sagemaker.workflow.pipelines.html#sagemaker.workflow.pipeline._PipelineExecution.result ), conforme mostrado no trecho a seguir:
```
execution = pipeline.start()
execution.result(step_name="train")
```
**nota**
O Pipelines não oferece apoio ao `execution.result()` no modo local.
Você só poderá recuperar resultados de uma etapa de cada vez. Se o nome da etapa foi gerado pela SageMaker IA, você pode recuperar o nome da etapa chamando da `list_steps` seguinte forma:
```
execution.list_step()
```
## Execute um pipeline localmente
Você pode executar um pipeline com etapas decoradas por `@step` localmente, como faria com as etapas tradicionais do pipeline. Para obter detalhes sobre a execução de pipeline no modo local, consulte [Executar pipelines usando o modo local](pipelines-local-mode.md). Para usar o modo local, forneça um `LocalPipelineSession` em vez de `SageMakerSession` para sua definição de pipeline, conforme mostrado no seguinte exemplo:
```
from sagemaker.workflow.function_step import step
from sagemaker.workflow.pipeline import Pipeline
from sagemaker.workflow.pipeline_context import LocalPipelineSession
@step
def train():
training_data = s3.download(....)
...
return trained_model
step_train_result = train()
local_pipeline_session = LocalPipelineSession()
local_pipeline = Pipeline(
name="",
steps=[step_train_result],
sagemaker_session=local_pipeline_session # needed for local mode
)
local_pipeline.create(role_arn="role_arn")
# pipeline runs locally
execution = local_pipeline.start()
```
# Configure seu pipeline
É recomendável usar o arquivo de configuração do SageMaker AI para definir os padrões do pipeline. Para obter informações sobre o arquivo de configuração do SageMaker AI, consulte [Como configurar e usar padrões com o SDK do Python SageMaker ](https://sagemaker.readthedocs.io/en/stable/overview.html#configuring-and-using-defaults-with-the-sagemaker-python-sdk). Qualquer configuração adicionada ao arquivo de configuração se aplica a todas as etapas do pipeline. Se você quiser substituir as opções de alguma etapa, forneça novos valores nos argumentos do decorador `@step`. O tópico a seguir descreve como configurar um arquivo de configuração.
A configuração do decorador `@step` no arquivo de configuração é idêntica à configuração do decorador `@remote`. Para configurar o ARN da função do pipeline e as tags do pipeline no arquivo de configuração, use a seção `Pipeline` mostrada no seguinte trecho:
```
SchemaVersion: '1.0'
SageMaker:
Pipeline:
RoleArn: 'arn:aws:iam::555555555555:role/IMRole'
Tags:
- Key: 'tag_key'
Value: 'tag_value'
```
Para a maioria dos padrões que você pode definir no arquivo de configuração, você também pode substituir passando novos valores para o decorador `@step`. Por exemplo, é possível substituir o tipo de instância definido no arquivo de configuração da etapa de pré-processamento, conforme mostrado no seguinte exemplo:
```
@step(instance_type="ml.m5.large")
def preprocess(raw_data):
df = pandas.read_csv(raw_data)
...
return procesed_dataframe
```
Alguns argumentos não fazem parte da lista de parâmetros do `@step` decorador. Eles só podem ser configurados para todo o pipeline por meio do arquivo de configuração do SageMaker AI. Eles estão listados a seguir:
+ `sagemaker_session`(`sagemaker.session.Session`): A sessão de SageMaker IA subjacente à qual a SageMaker IA delega chamadas de serviço. Se não for especificado, uma sessão será criada usando a seguinte configuração padrão:
```
SageMaker:
PythonSDK:
Modules:
Session:
DefaultS3Bucket: 'default_s3_bucket'
DefaultS3ObjectKeyPrefix: 'key_prefix'
```
+ `custom_file_filter` (`CustomFileFilter)`: um objeto `CustomFileFilter` que especifica os diretórios e arquivos locais a serem incluídos na etapa do pipeline. Se não for especificado, esse valor terá o padrão `None`. Para `custom_file_filter` entrar em vigor, você deve definir `IncludeLocalWorkdir` como `True`. O exemplo a seguir mostra uma configuração que ignora todos os arquivos do caderno e os arquivos e diretórios chamados `data`.
```
SchemaVersion: '1.0'
SageMaker:
PythonSDK:
Modules:
RemoteFunction:
IncludeLocalWorkDir: true
CustomFileFilter:
IgnoreNamePatterns: # files or directories to ignore
- "*.ipynb" # all notebook files
- "data" # folder or file named "data"
```
Para obter mais detalhes sobre como usar `IncludeLocalWorkdir` com `CustomFileFilter`, consulte [Como usar o código modular com o decorador @remote](train-remote-decorator-modular.md).
+ `s3_root_uri (str)`: a pasta raiz do Amazon S3 para a qual a SageMaker IA carrega os arquivos de código e os dados. Se não for especificado, o bucket de SageMaker IA padrão será usado.
+ `s3_kms_key (str)`: a chave usada para criptografar os dados de entrada e saída. Você só pode configurar esse argumento no arquivo de configuração do SageMaker AI e o argumento se aplica a todas as etapas definidas no pipeline. Se não especificado, o valor padrão é `None`. Veja o seguinte trecho para ver um exemplo de configuração de chave do KMS do S3:
```
SchemaVersion: '1.0'
SageMaker:
PythonSDK:
Modules:
RemoteFunction:
S3KmsKeyId: 's3kmskeyid'
S3RootUri: 's3://amzn-s3-demo-bucket/my-project
```
# Práticas recomendadas
As seções a seguir sugerem as práticas recomendadas a serem seguidas ao usar o decorador `@step` nas etapas do pipeline.
## Use grupos de aquecimento
Para uma execução mais rápida das etapas de pipeline, use a funcionalidade de grupos de aquecimento fornecida para trabalhos de treinamento. Você pode ativar a funcionalidade de grupos de aquecimento fornecendo o argumento `keep_alive_period_in_seconds` ao decorador `@step`, conforme demonstrado no seguinte trecho:
```
@step(
keep_alive_period_in_seconds=900
)
```
Para obter mais informações sobre grupos quentes, consulte [SageMaker Piscinas aquecidas gerenciadas por IA](train-warm-pools.md).
## Proteja seu diretório
É recomendável usar módulos de código ao usar o decorador `@step`. Coloque o módulo `pipeline.py`, no qual você invoca as funções de etapa e define o pipeline, na raiz do espaço de trabalho. A estrutura recomendada é mostrada a seguir:
```
.
├── config.yaml # the configuration file that define the infra settings
├── requirements.txt # dependencies
├── pipeline.py # invoke @step-decorated functions and define the pipeline here
├── steps/
| ├── processing.py
| ├── train.py
├── data/
├── test/
```
# Limitações
As seções a seguir descrevem as limitações que você deve conhecer ao usar o decorador `@step` nas etapas do pipeline.
## Limitações de argumentos de função
Quando você passa um argumento de entrada para a função decorada por `@step`, as seguintes limitações se aplicam:
+ Você pode passar `DelayedReturn`, `Properties` (de etapas de outros tipos), `Parameter` e objetos `ExecutionVariable` para funções decoradas por `@step` como argumentos. Mas as funções decoradas por `@step` não oferecem apoio a `JsonGet` e objetos `Join` como argumentos.
+ Você não pode acessar diretamente uma variável de pipeline a partir de uma função `@step`. O seguinte exemplo produz um erro:
```
param = ParameterInteger(name="", default_value=10)
@step
def func():
print(param)
func() # this raises a SerializationError
```
+ Você não pode aninhar uma variável de pipeline em outro objeto e passá-la para uma função `@step`. O seguinte exemplo produz um erro:
```
param = ParameterInteger(name="", default_value=10)
@step
def func(arg):
print(arg)
func(arg=(param,)) # this raises a SerializationError because param is nested in a tuple
```
+ Como as entradas e saídas de uma função são serializadas, há restrições quanto ao tipo de dados que pode ser passado como entrada ou saída de uma função. Consulte a seção *Serialização e desserialização de dados* de [Invocar uma função remota](train-remote-decorator-invocation.md) para obter mais detalhes. As mesmas restrições se aplicam às funções decoradas por `@step`.
+ Qualquer objeto que tenha um cliente boto não pode ser serializado, portanto, você não pode passar esses objetos como entrada ou saída de uma função decorada por `@step`. Por exemplo, classes de cliente do SDK do SageMaker Python`Estimator`, como, e`Predictor`, não `Processor` podem ser serializadas.
## Importações de funções
Você deve importar as bibliotecas exigidas pela etapa dentro da função, ao invés de fora. Se você importá-las em âmbito global, corre o risco de uma colisão de importação ao serializar a função. Por exemplo, `sklearn.pipeline.Pipeline` pode ser substituído por `sagemaker.workflow.pipeline.Pipeline`.
## Como referenciar membros filhos do valor de retorno da função
Se você fizer referência a membros filhos do valor de retorno de uma função decorada por `@step`, as seguintes limitações se aplicam:
+ Você pode referenciar os membros secundários com `[]` se o objeto `DelayedReturn` representar uma tupla, lista ou dicionário, conforme mostrado no seguinte exemplo:
```
delayed_return[0]
delayed_return["a_key"]
delayed_return[1]["a_key"]
```
+ Você não pode descompactar uma saída de tupla ou lista porque não é possível saber o comprimento exato da tupla ou lista subjacente quando você invoca a função. O seguinte exemplo produz um erro:
```
a, b, c = func() # this raises ValueError
```
+ Você não pode repetir um objeto `DelayedReturn`. Veja a seguir um exemplo com erro:
```
for item in func(): # this raises a NotImplementedError
```
+ Você não pode referenciar membros secundários arbitrários com “`.`”. O seguinte exemplo produz um erro:
```
delayed_return.a_child # raises AttributeError
```
## Atributos de pipeline existentes que não são compatíveis
Você não pode usar o decorador `@step` com os seguintes atributos de pipeline:
+ [Cache de etapas de pipeline](https://docs.aws.amazon.com/sagemaker/latest/dg/pipelines-caching.html)
+ [Arquivo de propriedades](https://docs.aws.amazon.com/sagemaker/latest/dg/build-and-manage-propertyfile.html#build-and-manage-propertyfile-property)
# Passe dados entre etapas
Ao criar pipelines com o Amazon SageMaker Pipelines, talvez seja necessário passar dados de uma etapa para a outra. Por exemplo, talvez você queira usar os artefatos do modelo gerados por uma etapa de treinamento como entrada para uma etapa de avaliação ou implantação de modelo. Você pode usar essa funcionalidade para criar etapas de pipeline interdependentes e construir seus fluxos de trabalho de ML.
Quando precisar recuperar informações da saída de uma etapa de pipeline, você pode usar `JsonGet`. `JsonGet` ajuda você a extrair informações do Amazon S3 ou de arquivos de propriedades. As seções a seguir explicam os métodos que você pode usar para extrair as saídas das etapas `JsonGet`.
## Transmita dados entre etapas com o Amazon S3
Você pode usar `JsonGet` em um `ConditionStep` para obter a saída JSON diretamente do Amazon S3. O URI do Amazon S3 pode ser uma função `Std:Join` contendo strings primitivas, variáveis de execução de pipeline ou parâmetros de pipeline. O exemplo a seguir mostra como você pode usar `JsonGet` em um `ConditionStep`.
```
# Example json file in s3 bucket generated by a processing_step
{
"Output": [5, 10]
}
cond_lte = ConditionLessThanOrEqualTo(
left=JsonGet(
step_name="",
s3_uri="",
json_path="Output[1]"
),
right=6.0
)
```
Se você estiver usando `JsonGet` com um caminho do Amazon S3 na etapa de condição, deverá adicionar explicitamente uma dependência entre a etapa de condição e a etapa que gera a saída JSON. No seguinte exemplo, a etapa de condição é criada com uma dependência da etapa de processamento:
```
cond_step = ConditionStep(
name="",
conditions=[cond_lte],
if_steps=[fail_step],
else_steps=[register_model_step],
depends_on=[processing_step],
)
```
## Passe dados entre etapas com arquivos de propriedades
Use arquivos de propriedades para armazenar informações da saída de uma etapa de processamento. Isso é particularmente útil ao analisar os resultados de uma etapa de processamento para decidir como uma etapa condicional deve ser executada. A `JsonGet` função processa um arquivo de propriedades e permite que você use a JsonPath notação para consultar o arquivo JSON da propriedade. Para obter mais informações sobre JsonPath notação, consulte o [JsonPath repositório](https://github.com/json-path/JsonPath).
Para armazenar um arquivo de propriedades para uso posterior, primeiro você deve criar uma instância `PropertyFile` com o formato a seguir. O parâmetro `path` é o nome do arquivo JSON no qual o arquivo de propriedades é salvo. Qualquer um `output_name` deve corresponder ao `output_name` do `ProcessingOutput` que você define em sua etapa de processamento. Isso permite que o arquivo de propriedades capture o `ProcessingOutput` na etapa.
```
from sagemaker.workflow.properties import PropertyFile
= PropertyFile(
name="",
output_name="",
path=""
)
```
Ao criar sua `ProcessingStep` instância, adicione o `property_files` parâmetro para listar todos os arquivos de parâmetros que o serviço Amazon SageMaker Pipelines deve indexar. Isso salva o arquivo de propriedades para uso posterior.
```
property_files=[]
```
Para usar seu arquivo de propriedade em uma etapa de condição, adicione a `property_file` à condição que você passa para sua etapa de condição, conforme mostrado no exemplo a seguir, para consultar o arquivo JSON da propriedade desejada usando o parâmetro `json_path`.
```
cond_lte = ConditionLessThanOrEqualTo(
left=JsonGet(
step_name=step_eval.name,
property_file=,
json_path="mse"
),
right=6.0
)
```
Para obter exemplos mais detalhados, consulte *[Arquivo de propriedades](https://sagemaker.readthedocs.io/en/stable/amazon_sagemaker_model_building_pipeline.html#property-file)* no SDK do [Amazon SageMaker Python](https://sagemaker.readthedocs.io/en/stable).
# Etapas do pipeline de cache
No Amazon SageMaker Pipelines, você pode usar o cache de etapas para economizar tempo e recursos ao executar novamente os pipelines. O cache de etapas reutiliza a saída de uma execução anterior bem-sucedida de uma etapa (em vez de computar novamente) quando a etapa tem a mesma configuração e entradas. Isso ajuda você a obter resultados consistentes em reexecuções de pipeline com parâmetros idênticos. O tópico a seguir mostra como configurar e ativar o armazenamento em cache de etapas para seus pipelines.
Quando você usa o cache de assinatura de etapas, o Pipelines tenta encontrar uma execução anterior da etapa atual do pipeline com os mesmos valores para determinados atributos. Se encontrada, o Pipelines propaga as saídas da execução anterior em vez de computar a etapa novamente. Os atributos verificados são específicos do tipo de etapa e estão listados em [Atributos de chave de cache padrão por tipo de etapa do pipeline](pipelines-default-keys.md).
Você deve optar pelo armazenamento em cache por etapas: ele está desativado por padrão. Ao ativar o cache de etapas, você também deve definir um tempo limite. Esse tempo limite define quantos anos uma corrida anterior pode ter para permanecer candidata à reutilização.
O cache de etapas considera apenas execuções bem-sucedidas: ele nunca reutiliza execuções com falha. Quando existem várias execuções bem-sucedidas dentro do período de tempo limite, o Pipelines usa o resultado para a execução bem-sucedida mais recente. Se nenhuma execução bem-sucedida coincidir no período de tempo limite, o Pipelines executa novamente a etapa. Se o executor encontrar uma execução anterior que atenda aos critérios, mas ainda esteja em andamento, as duas etapas continuarão em execução e atualizarão o cache se forem bem-sucedidas.
O cache de etapas tem como escopo apenas pipelines individuais, portanto, você não pode reutilizar uma etapa de outro pipeline, mesmo que haja uma correspondência na assinatura da etapa.
O cache de etapas está disponível para os seguintes tipos de etapas:
+ [Processamento](build-and-manage-steps-types.md#step-type-processing)
+ [Treinamento](build-and-manage-steps-types.md#step-type-training)
+ [Ajustar](build-and-manage-steps-types.md#step-type-tuning)
+ [AutoML](build-and-manage-steps-types.md#step-type-automl)
+ [Transformação](build-and-manage-steps-types.md#step-type-transform)
+ [`ClarifyCheck`](build-and-manage-steps-types.md#step-type-clarify-check)
+ [`QualityCheck`](build-and-manage-steps-types.md#step-type-quality-check)
+ [EMR](build-and-manage-steps-types.md#step-type-emr)
**Topics**
+ [Ativar o cache de etapas](pipelines-caching-enabling.md)
+ [Desativar o cache de etapas](pipelines-caching-disabling.md)
+ [Atributos de chave de cache padrão por tipo de etapa do pipeline](pipelines-default-keys.md)
+ [Controle de acesso a dados em cache](pipelines-access-control.md)
# Ativar o cache de etapas
Para ativar o cache de etapas, você deve adicionar a propriedade `CacheConfig` à definição da etapa. As propriedades `CacheConfig` usam o seguinte formato no arquivo de definição do pipeline:
```
{
"CacheConfig": {
"Enabled": false,
"ExpireAfter": "