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á. # Definir um pipeline Para orquestrar seus fluxos de trabalho com o Amazon SageMaker Pipelines, você deve gerar um gráfico acíclico direcionado (DAG) na forma de uma definição de pipeline JSON. O DAG especifica as diferentes etapas envolvidas em seu processo de ML, como pré-processamento de dados, treinamento de modelos, avaliação de modelos e implantação de modelos, bem como as dependências e o fluxo de dados entre essas etapas. O tópico a seguir mostra como gerar uma definição de pipeline. Você pode gerar sua definição de pipeline JSON usando o SDK do SageMaker Python ou o recurso visual de arrastar e soltar Pipeline Designer no Amazon Studio. SageMaker A imagem a seguir é uma representação do DAG de pipeline que você cria neste tutorial: ![Captura de tela da interface visual de arrastar e soltar para o Pipelines no Studio.](http://docs.aws.amazon.com/pt_br/sagemaker/latest/dg/images/pipelines/pipelines-studio-overview.png) O pipeline que você define nas seções a seguir resolve um problema de regressão para determinar a idade de um abalone com base em suas medidas físicas. Para um notebook Jupyter executável que inclui o conteúdo deste tutorial, consulte [ Orquestração de trabalhos com o Amazon Model Building Pipelines. SageMaker ](https://sagemaker-examples.readthedocs.io/en/latest/sagemaker-pipelines/tabular/abalone_build_train_deploy/sagemaker-pipelines-preprocess-train-evaluate-batch-transform.html) **nota** Você pode referenciar a localização do modelo como uma propriedade da etapa de treinamento, conforme mostrado no exemplo de [ CustomerChurn pipeline de ponta a ponta ](https://github.com/aws-samples/customer-churn-sagemaker-pipelines-sample/blob/main/pipelines/customerchurn/pipeline.py) no Github. **Topics** ## Definir um pipeline (Pipeline Designer) O passo a passo a seguir orienta você com as etapas para criar um pipeline básico usando o Pipeline Designer de arrastar e soltar. Se você precisar pausar ou encerrar sua sessão de edição do Pipeline no designer visual a qualquer momento, clique na opção **Exportar**. Isso permite que você baixe a definição atual do seu Pipeline para o seu ambiente local. Posteriormente, quando quiser retomar o processo de edição do Pipeline, você pode importar o mesmo arquivo de definição JSON para o designer visual. ### Criar uma etapa de processamento Para criar uma etapa do trabalho de processamento de dados, 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 **Processar dados** e arraste-o para o canvas. 1. No canvas, escolha a etapa **Processar dados** que você adicionou. 1. Para adicionar um conjunto de dados de entrada, escolha **Adicionar** em **Dados (entrada)** na barra lateral direita e selecione um conjunto de dados. 1. Para adicionar um local para salvar conjuntos de dados de saída, escolha **Adicionar** em **Dados (saída)** na barra lateral direita e navegue até o destino. 1. Preencha os campos restantes na barra lateral direita. 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). ### Criar uma etapa de treinamento Para configurar uma etapa de treinamento de modelo, faça o seguinte: 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. Para adicionar um conjunto de dados de entrada, escolha **Adicionar** em **Dados (entrada)** na barra lateral direita e selecione um conjunto de dados. 1. Para escolher um local para salvar seus artefatos de modelo, insira um URI do Amazon S3 no campo **Localização (URI do S3**) ou escolha **Procurar no S3** para navegar até o local de destino. 1. Preencha os campos restantes na barra lateral direita. 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. Clique e arraste o cursor da etapa **Processar dados** que você adicionou na seção anterior à etapa **Treinar modelo** para criar uma borda conectando as duas etapas. ### Criar um pacote de modelo com a etapa de registro de modelo Para criar um pacote de modelo com uma etapa de registro de modelo, faça o seguinte: 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. Para selecionar um modelo para registrar, escolha **Adicionar** em **Modelo (entrada)**. 1. Escolha **Criar um grupo de modelos** para adicionar seu modelo a um novo grupo de modelos. 1. Preencha os campos restantes na barra lateral direita. Para obter informações sobre os campos nessas guias, consulte [ sagemaker.workflow.step\_collections. RegisterModel](https://sagemaker.readthedocs.io/en/stable/workflows/pipelines/sagemaker.workflow.pipelines.html#sagemaker.workflow.step_collections.RegisterModel). 1. Clique e arraste o cursor da etapa **Treinar modelo** que você adicionou na seção anterior à etapa **Registrar modelo** para criar uma borda conectando as duas etapas. ### Implante o modelo em um endpoint com uma etapa de implantação de modelo (endpoint) Para implantar seu modelo usando uma etapa de implantação de modelo, faça o seguinte: 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. Para escolher um modelo para implantar, escolha **Adicionar** em **Modelo (entrada)**. 1. Escolha o botão de opção **Criar endpoint** para criar um novo endpoint. 1. Insira um **Nome** e uma **Descrição** para o endpoint. 1. Clique e arraste o cursor da etapa **Registrar modelo** que você adicionou na seção anterior à etapa **Implantar modelo (endpoint)** para criar uma borda conectando as duas etapas. 1. Preencha os campos restantes na barra lateral direita. ### Definir os parâmetros do Pipeline Você pode configurar um conjunto de parâmetros do Pipeline cujos valores podem ser atualizados para cada execução. Para definir os parâmetros de pipeline e configurar os valores padrão, clique no ícone de engrenagem na parte inferior do designer visual. ### Salvar pipeline Depois de inserir todas as informações necessárias para criar seu pipeline, clique em **Salvar** na parte inferior do designer visual. Isso valida seu pipeline quanto a possíveis erros em runtime e notifica você. A operação **Salvar** não será bem-sucedida até que você resolva todos os erros sinalizados pelas verificações de validação automatizadas. Se quiser continuar a edição posteriormente, você pode salvar seu pipeline em andamento como uma definição JSON em seu ambiente local. Você pode exportar seu Pipeline como um arquivo de definição JSON clicando no botão **Exportar** na parte inferior do designer visual. Posteriormente, para continuar a atualização do Pipeline, faça o upload desse arquivo de definição JSON clicando no botão **Importar**. ## Definir um pipeline (SDK do SageMaker Python) ### Pré-requisitos Para executar o tutorial a seguir, faça o seguinte: + Configure sua instância de caderno conforme descrito em [Criar uma instância de caderno](https://docs.aws.amazon.com/sagemaker/latest/dg/howitworks-create-ws.html). Isso dá à sua função permissões para ler e gravar no Amazon S3 e criar tarefas de treinamento, transformação em lote e processamento em SageMaker IA. + Conceda ao seu caderno permissões para obter e transmitir seu próprio perfil, conforme mostrado em [Modificar uma política de permissões de perfil](https://docs.aws.amazon.com/IAM/latest/UserGuide/roles-managingrole-editing-console.html#roles-modify_permissions-policy). Adicione o seguinte trecho de código do JSON para anexar essa política ao seu perfil: ``Substitua pelo ARN usado para criar sua instância de notebook. ------ #### [ JSON ] **** ``` { "Version":"2012-10-17", "Statement": [ { "Effect": "Allow", "Action": [ "iam:GetRole", "iam:PassRole" ], "Resource": "arn:aws:iam::{{111122223333}}:role/{{role-name}}" } ] } ``` ------ + Confie no diretor do serviço de SageMaker IA seguindo as etapas em [ Modificar uma política ](https://docs.aws.amazon.com/IAM/latest/UserGuide/roles-managingrole-editing-cli.html#roles-managingrole_edit-trust-policy-cli) de confiança de função. Adicione o seguinte fragmento de declaração à relação de confiança do seu perfil: ``` { "Sid": "", "Effect": "Allow", "Principal": { "Service": "sagemaker.amazonaws.com" }, "Action": "sts:AssumeRole" } ``` #### Configure o ambiente. Crie uma nova sessão de SageMaker IA usando o bloco de código a seguir. Isso retorna o ARN da função para a sessão. Esse ARN da função deve ser o ARN da função de execução que você configurou como pré-requisito. ``` import boto3 import sagemaker from sagemaker.core.workflow.pipeline_context import PipelineSession from sagemaker.core.helper.session_helper import Session, get_execution_role region = boto3.Session().region_name sagemaker_session = Session() role = get_execution_role() default_bucket = sagemaker_session.default_bucket() pipeline_session = PipelineSession() model_package_group_name = f"AbaloneModelPackageGroupName" ``` ### Criar um pipeline **Importante** As políticas personalizadas do IAM que permitem que o Amazon SageMaker Studio ou o Amazon SageMaker Studio Classic criem SageMaker recursos da Amazon também devem conceder permissões para adicionar tags a esses recursos. A permissão para adicionar tags aos recursos é necessária porque o Studio e o Studio Classic marcam automaticamente todos os recursos que eles criam. Se uma política do IAM permite que o Studio e o Studio Classic criem recursos, mas não permitem a marcação, erros AccessDenied "" podem ocorrer ao tentar criar recursos. Para obter mais informações, consulte [Forneça permissões para marcar recursos de SageMaker IA](security_iam_id-based-policy-examples.md#grant-tagging-permissions). [AWS políticas gerenciadas para Amazon SageMaker AI](security-iam-awsmanpol.md)que dão permissões para criar SageMaker recursos já incluem permissões para adicionar tags ao criar esses recursos. Execute as etapas a seguir em sua instância de notebook de SageMaker IA para criar um pipeline que inclua etapas de pré-processamento, treinamento, avaliação, avaliação condicional e registro do modelo. **nota** Você pode usar [ ExecutionVariables ](https://sagemaker.readthedocs.io/en/stable/workflows/pipelines/sagemaker.workflow.pipelines.html#execution-variables) a [ função ](https://sagemaker.readthedocs.io/en/stable/workflows/pipelines/sagemaker.workflow.pipelines.html#execution-variables) Join para especificar seu local de saída. #### Etapa 1: baixe o conjunto de dados Este caderno usa o conjunto de dados do UCI Machine Learning Abalone. O conjunto de dados contém os seguintes atributos: + `length`: A medida de concha mais longa do abalone. + `diameter`: O diâmetro do abalone perpendicular ao seu comprimento. + `height`: A altura do abalone com carne na concha. + `whole_weight`: O peso do abalone inteiro. + `shucked_weight`: O peso da carne retirada do abalone. + `viscera_weight`: O peso das vísceras do abalone após o sangramento. + `shell_weight`: O peso da concha do abalone após a remoção e secagem da carne. + `sex`: O gênero do abalone. Entre 'M', 'F' ou 'I', em que 'I' é um abalone infantil. + `rings`: O número de anéis na concha do abalone. O número de anéis na concha do abalone é uma boa aproximação de sua idade usando a fórmula `age=rings + 1.5`. No entanto, obter esse número é uma tarefa demorada. Você deve cortar a concha pelo cone, marcar a seção e contar o número de anéis com um microscópio. No entanto, as outras medidas físicas são mais fáceis de conseguir. Este caderno usa o conjunto de dados para criar um modelo preditivo dos anéis variáveis usando as outras medidas físicas. **Para fazer download do conjunto de dados** 1. Faça o download do conjunto de dados no bucket do Amazon S3 padrão da sua conta. ``` !mkdir -p data local_path = "data/abalone-dataset.csv" s3 = boto3.resource("s3") s3.Bucket(f"sagemaker-servicecatalog-seedcode-{region}").download_file( "dataset/abalone-dataset.csv", local_path ) base_uri = f"s3://{default_bucket}/abalone" input_data_uri = sagemaker.s3.S3Uploader.upload( local_path=local_path, desired_s3_uri=base_uri, ) print(input_data_uri) ``` 1. Faça o download de um segundo conjunto de dados para transformação em lote após a criação do modelo. ``` local_path = "data/abalone-dataset-batch.csv" s3 = boto3.resource("s3") s3.Bucket(f"sagemaker-servicecatalog-seedcode-{region}").download_file( "dataset/abalone-dataset-batch", local_path ) base_uri = f"s3://{default_bucket}/abalone" batch_data_uri = sagemaker.s3.S3Uploader.upload( local_path=local_path, desired_s3_uri=base_uri, ) print(batch_data_uri) ``` #### Etapa 2: definir parâmetros do pipeline ``` from sagemaker.core.workflow.parameters import ( ParameterInteger, ParameterString, ) processing_instance_count = ParameterInteger(name="ProcessingInstanceCount", default_value=1) model_approval_status = ParameterString(name="ModelApprovalStatus", default_value="PendingManualApproval") input_data = ParameterString(name="InputData", default_value=input_data_uri) batch_data = ParameterString(name="BatchData", default_value=batch_data_uri) ``` #### Etapa 3: defina uma etapa de processamento para engenharia de atributos Esta seção mostra como criar uma etapa de processamento para preparar os dados do conjunto de dados para treinamento. **Para criar uma etapa de processamento** 1. Crie uma instância de um processador para passar para a etapa de processamento. ``` from sagemaker.core.processing import Processor from sagemaker.core import image_uris framework_version = "0.23-1" sklearn_image_uri = image_uris.retrieve( framework="sklearn", region=region, version=framework_version, instance_type="ml.m5.xlarge" ) sklearn_processor = Processor( image_uri=sklearn_image_uri, instance_type="ml.m5.xlarge", instance_count=processing_instance_count, base_job_name="sklearn-abalone-process", sagemaker_session=pipeline_session, role=role, ) ``` 1. Crie uma etapa de processamento. ``` from sagemaker.core.processing import ProcessingInput, ProcessingOutput from sagemaker.mlops.workflow.steps import ProcessingStep processor_args = sklearn_processor.run( inputs=[ ProcessingInput(source=input_data, destination="/opt/ml/processing/input"), ], outputs=[ ProcessingOutput(output_name="train", source="/opt/ml/processing/train"), ProcessingOutput(output_name="validation", source="/opt/ml/processing/validation"), ProcessingOutput(output_name="test", source="/opt/ml/processing/test") ], code="abalone/preprocessing.py", ) step_process = ProcessingStep(name="AbaloneProcess", step_args=processor_args) ``` #### Etapa 4: defina uma etapa de treinamento Esta seção mostra como usar o algoritmo SageMaker AI XGBoost para treinar um modelo na saída de dados de treinamento das etapas de processamento. **Para definir uma etapa de treinamento** 1. Especifique o caminho do modelo em que você deseja salvar os modelos do treinamento. ``` model_path = f"s3://{default_bucket}/AbaloneTrain" ``` 1. Configure um estimador de treinamento para o algoritmo XGBoost e o conjunto de dados de entrada. ``` from sagemaker.train import ModelTrainer from sagemaker.train.configs import Compute, OutputDataConfig from sagemaker.core import image_uris image_uri = image_uris.retrieve( framework="xgboost", region=region, version="1.0-1", py_version="py3", instance_type="ml.m5.xlarge" ) xgb_train = ModelTrainer( training_image=image_uri, compute=Compute(instance_type="ml.m5.xlarge", instance_count=1), output_data_config=OutputDataConfig(s3_output_path=model_path), hyperparameters={ "objective": "reg:linear", "num_round": "50", "max_depth": "5", "eta": "0.2", "gamma": "4", "min_child_weight": "6", "subsample": "0.7", "silent": "0" }, sagemaker_session=pipeline_session, role=role, ) ``` 1. Crie um `TrainingStep` usando a instância de treinamento e as propriedades do`ProcessingStep`. ``` from sagemaker.train.configs import InputData from sagemaker.mlops.workflow.steps import TrainingStep train_args = xgb_train.train( input_data_config=[ InputData( channel_name="train", data_source=step_process.properties.ProcessingOutputConfig.Outputs[ "train" ].S3Output.S3Uri, content_type="text/csv" ), InputData( channel_name="validation", data_source=step_process.properties.ProcessingOutputConfig.Outputs[ "validation" ].S3Output.S3Uri, content_type="text/csv" ) ], ) step_train = TrainingStep(name="AbaloneTrain", step_args=train_args) ``` #### Etapa 5: defina uma etapa de processamento para avaliação do modelo Esta seção mostra como criar uma etapa de processamento para avaliar a precisão do modelo. **Para definir uma etapa de processamento para avaliação do modelo** 1. Crie uma instância de a `Processor` para avaliação. ``` from sagemaker.core.processing import Processor script_eval = Processor( image_uri=image_uri, command=["python3"], instance_type="ml.m5.xlarge", instance_count=1, base_job_name="script-abalone-eval", sagemaker_session=pipeline_session, role=role, ) ``` 1. Crie um `ProcessingStep` usando a instância do processador, os canais de entrada e saída e o `evaluation.py` script. ``` from sagemaker.core.workflow.properties import PropertyFile evaluation_report = PropertyFile( name="EvaluationReport", output_name="evaluation", path="evaluation.json" ) eval_args = script_eval.run( inputs=[ ProcessingInput( source=step_train.properties.ModelArtifacts.S3ModelArtifacts, destination="/opt/ml/processing/model" ), ProcessingInput( source=step_process.properties.ProcessingOutputConfig.Outputs[ "test" ].S3Output.S3Uri, destination="/opt/ml/processing/test" ) ], outputs=[ ProcessingOutput(output_name="evaluation", source="/opt/ml/processing/evaluation"), ], code="abalone/evaluation.py", ) step_eval = ProcessingStep( name="AbaloneEval", step_args=eval_args, property_files=[evaluation_report], ) ``` #### Etapa 6: Definir uma CreateModelStep para transformação em lote Esta seção mostra como criar um modelo de SageMaker IA a partir da saída da etapa de treinamento. **Para definir uma CreateModelStep transformação em lote** + Crie um modelo de SageMaker IA e uma etapa do modelo. ``` from sagemaker.serve import ModelBuilder from sagemaker.mlops.workflow.model_step import ModelStep model_builder = ModelBuilder( image_uri=image_uri, s3_model_data_url=step_train.properties.ModelArtifacts.S3ModelArtifacts, role_arn=role, sagemaker_session=pipeline_session, ) step_create_model = ModelStep( name="AbaloneCreateModel", step_args=model_builder.build(), ) ``` #### Etapa 7: Definir um TransformStep para realizar a transformação em lote Esta seção mostra como criar uma `TransformStep` para realizar a transformação em lote em um conjunto de dados após o treinamento do modelo. **Para definir um TransformStep para realizar a transformação em lote** + Crie uma instância de transformador e uma`TransformStep`. ``` from sagemaker.core.transformer import Transformer from sagemaker.mlops.workflow.steps import TransformStep transformer = Transformer( model_name=step_create_model.properties.ModelName, instance_type="ml.m5.xlarge", instance_count=1, output_path=f"s3://{default_bucket}/AbaloneTransform", sagemaker_session=pipeline_session, ) transform_args = transformer.transform(data=batch_data) step_transform = TransformStep( name="AbaloneTransform", step_args=transform_args, ) ``` #### Etapa 8: Definir uma RegisterModel etapa para criar um pacote modelo Esta seção mostra como registrar um modelo. O resultado é um pacote de modelo para inferência. **Para definir uma etapa de registro de modelo para criar um pacote de modelo** + Construa uma etapa de registro do modelo. ``` from sagemaker.core.model_metrics import MetricsSource, ModelMetrics from sagemaker.mlops.workflow.model_step import ModelStep from sagemaker.serve import ModelBuilder model_metrics = ModelMetrics( model_statistics=MetricsSource( s3_uri="{{{}/evaluation.json}}".format( step_eval.arguments["ProcessingOutputConfig"]["Outputs"][0]["S3Output"]["S3Uri"] ), content_type="application/json" ) ) model_builder = ModelBuilder( image_uri=image_uri, s3_model_data_url=step_train.properties.ModelArtifacts.S3ModelArtifacts, role_arn=role, sagemaker_session=pipeline_session, ) register_args = model_builder.register( content_types=["text/csv"], response_types=["text/csv"], inference_instances=["{{ml.t2.medium", "ml.m5.xlarge}}"], transform_instances=["{{ml.m5.xlarge}}"], model_package_group_name=model_package_group_name, approval_status=model_approval_status, model_metrics=model_metrics ) step_register = ModelStep( name="{{AbaloneRegisterModel}}", step_args=register_args, ) ``` #### Etapa 9: defina uma etapa de condição para verificar a precisão do modelo O `ConditionStep` permite que o Pipelines ofereça compatibilidade com a execução condicional em seu DAG de pipeline com base na condição das propriedades da etapa. **Para definir uma etapa de condição para verificar a precisão do modelo** + Defina uma condição e construa uma`ConditionStep`. ``` from sagemaker.core.workflow.conditions import ConditionLessThanOrEqualTo from sagemaker.mlops.workflow.condition_step import ConditionStep from sagemaker.core.workflow.functions import JsonGet cond_lte = ConditionLessThanOrEqualTo( left=JsonGet( step_name=step_eval.name, property_file=evaluation_report, json_path="regression_metrics.mse.value" ), right=6.0 ) step_cond = ConditionStep( name="AbaloneMSECond", conditions=[cond_lte], if_steps=[step_register, step_create_model, step_transform], else_steps=[], ) ``` #### Etapa 10: criar um pipeline Agora que você criou todas as etapas, combine-as em um funil. **Para criar um pipeline** 1. Defina o seguinte para seu pipeline: `name`, `parameters` e `steps`. ``` from sagemaker.mlops.workflow.pipeline import Pipeline pipeline_name = f"AbalonePipeline" pipeline = Pipeline( name=pipeline_name, parameters=[ processing_instance_count, model_approval_status, input_data, batch_data, ], steps=[step_process, step_train, step_eval, step_cond], ) ``` 1. (Opcional) Examine a definição do pipeline JSON para garantir que ela esteja bem formada. ``` import json json.loads(pipeline.definition()) ``` Essa definição de pipeline está pronta para ser enviada à SageMaker IA. No próximo tutorial, você envia esse pipeline para a SageMaker IA e inicia uma execução. ## Definir um pipeline (JSON) Você também pode usar o [boto3](https://boto3.amazonaws.com/v1/documentation/api/latest/reference/services/sagemaker.html#SageMaker.Client.create_pipeline) ou [CloudFormation](https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-sagemaker-pipeline.html) para criar um pipeline. A criação de um pipeline requer uma definição de pipeline, que é um objeto JSON que define cada etapa do pipeline. O SageMaker SDK oferece uma maneira simples de criar a definição do pipeline, que você pode usar com qualquer uma das APIs mencionadas anteriormente para criar o próprio pipeline. Sem usar o SDK, os usuários precisam escrever a definição JSON bruta para criar o pipeline sem nenhuma das verificações de erro fornecidas pelo SDK do SageMaker Python. Para ver o esquema da definição JSON do pipeline, consulte Esquema JSON de definição de pipeline do [ SageMaker AI. ](https://aws-sagemaker-mlops.github.io/sagemaker-model-building-pipeline-definition-JSON-schema/) O exemplo de código a seguir mostra um exemplo de um objeto JSON de definição de pipeline de SageMaker IA: ``` {'Version': '2020-12-01', 'Metadata': {}, 'Parameters': [{'Name': 'ProcessingInstanceType', 'Type': 'String', 'DefaultValue': 'ml.m5.xlarge'}, {'Name': 'ProcessingInstanceCount', 'Type': 'Integer', 'DefaultValue': 1}, {'Name': 'TrainingInstanceType', 'Type': 'String', 'DefaultValue': 'ml.m5.xlarge'}, {'Name': 'ModelApprovalStatus', 'Type': 'String', 'DefaultValue': 'PendingManualApproval'}, {'Name': 'ProcessedData', 'Type': 'String', 'DefaultValue': '{{S3_URL}}', {'Name': 'InputDataUrl', 'Type': 'String', 'DefaultValue': '{{S3_URL}}', 'PipelineExperimentConfig': {'ExperimentName': {'Get': 'Execution.PipelineName'}, 'TrialName': {'Get': 'Execution.PipelineExecutionId'}}, 'Steps': [{'Name': 'ReadTrainDataFromFS', 'Type': 'Processing', 'Arguments': {'ProcessingResources': {'ClusterConfig': {'InstanceType': 'ml.m5.4xlarge', 'InstanceCount': 2, 'VolumeSizeInGB': 30}}, 'AppSpecification': {'ImageUri': '{{IMAGE_URI}}', 'ContainerArguments': [....]}, 'RoleArn': '{{ROLE}}', 'ProcessingInputs': [...], 'ProcessingOutputConfig': {'Outputs': [.....]}, 'StoppingCondition': {'MaxRuntimeInSeconds': 86400}}, 'CacheConfig': {'Enabled': True, 'ExpireAfter': '30d'}}, ... ... ... } ``` **Próxima etapa:** [Execute um pipeline](run-pipeline.md)