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á. # Cargas de trabalho de transformação de dados com processamento SageMaker SageMaker O processamento se refere aos recursos da SageMaker IA para executar tarefas de pré e pós-processamento de dados, engenharia de recursos e avaliação de modelos na infraestrutura totalmente gerenciada da SageMaker IA. Essas tarefas são executadas como [trabalhos de processamento](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_ProcessingJob.html). A seguir, são apresentadas informações e recursos para aprender sobre o SageMaker processamento. Usando a API SageMaker de processamento, os cientistas de dados podem executar scripts e notebooks para processar, transformar e analisar conjuntos de dados a fim de prepará-los para o aprendizado de máquina. Quando combinado com outras tarefas críticas de aprendizado de máquina fornecidas pela SageMaker IA, como treinamento e hospedagem, o Processing oferece os benefícios de um ambiente de aprendizado de máquina totalmente gerenciado, incluindo todo o suporte de segurança e conformidade incorporado à SageMaker IA. Você tem a flexibilidade de usar os contêineres de processamento de dados integrados ou de trazer seus próprios contêineres para uma lógica de processamento personalizada e, em seguida, enviar trabalhos para execução na infraestrutura gerenciada por SageMaker IA. **nota** Você pode criar um trabalho de processamento programaticamente chamando a ação da [CreateProcessingJob](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_CreateProcessingJob.html)API em qualquer linguagem suportada pela SageMaker IA ou usando o. AWS CLI Para obter informações sobre como essa ação da API se traduz em uma função no idioma de sua escolha, consulte a seção [Consulte também](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_CreateProcessingJob.html#API_CreateProcessingJob_SeeAlso) CreateProcessingJob e escolha um SDK. Como exemplo, para usuários de Python, consulte a seção [Amazon SageMaker Processing](https://sagemaker.readthedocs.io/en/stable/amazon_sagemaker_processing.html) do Python SageMaker SDK. Como alternativa, consulte a sintaxe completa de solicitação de [create\$1processing\$1job](https://boto3.amazonaws.com/v1/documentation/api/latest/reference/services/sagemaker/client/create_processing_job.html) no AWS SDK para Python (Boto3). O diagrama a seguir mostra como a Amazon SageMaker AI executa uma tarefa de processamento. O Amazon SageMaker AI pega seu script, copia seus dados do Amazon Simple Storage Service (Amazon S3) e, em seguida, extrai um contêiner de processamento. A infraestrutura subjacente para um trabalho de processamento é totalmente gerenciada pela Amazon SageMaker AI. Depois de enviar um trabalho de processamento, a SageMaker IA inicia as instâncias de computação, processa e analisa os dados de entrada e libera os recursos após a conclusão. A saída do trabalho de processamento é armazenada no bucket do Amazon S3 que você especificar. **nota** Seus dados de entrada devem ser armazenados em um bucket do Amazon S3. Se preferir, você também pode usar Amazon Athena ou Amazon Redshift. ![\[Execução de um trabalho de processamento.\]](http://docs.aws.amazon.com/pt_br/sagemaker/latest/dg/images/Processing-1.png) **dica** Para conhecer as melhores práticas para computação distribuída em treinamento e processamento de trabalhos de machine learning (ML) em geral, consulte [Computação distribuída com as melhores práticas de SageMaker IA](distributed-training-options.md). ## Use cadernos SageMaker de amostra de processamento da Amazon Fornecemos dois exemplos de cadernos Jupyter que mostram como realizar o pré-processamento de dados, a avaliação de modelos ou ambos. [Para ver um exemplo de caderno que mostra como executar scripts do scikit-learn para realizar o pré-processamento de dados e o treinamento e a avaliação de modelos com o SDK do SageMaker Python para processamento, consulte scikit-learn Processing.](https://github.com/awslabs/amazon-sagemaker-examples/tree/master/sagemaker_processing/scikit_learn_data_processing_and_model_evaluation) Esse caderno também mostra como usar um contêiner personalizado para executar workloads de processamento com bibliotecas Python e outras dependências específicas. Para ver um exemplo de caderno que mostra como usar o Amazon SageMaker Processing para realizar o pré-processamento distribuído de dados com o Spark, consulte [Processamento distribuído (Spark](https://github.com/aws/amazon-sagemaker-examples/blob/main/sagemaker_processing/spark_distributed_data_processing/sagemaker-spark-processing.ipynb)). Este caderno também mostra como treinar um modelo de regressão usando o conjunto XGBoost de dados pré-processado. Para obter instruções sobre como criar e acessar instâncias do notebook Jupyter que você pode usar para executar essas amostras na SageMaker IA, consulte. [Instâncias de SageMaker notebook da Amazon](nbi.md) Depois de criar uma instância do notebook e abri-la, escolha a guia **Exemplos de SageMaker IA** para ver uma lista de todas as amostras de SageMaker IA. Para abrir um caderno, escolha a guia **Uso** e depois escolha **Criar cópia**. ## Monitore trabalhos SageMaker de processamento da Amazon com CloudWatch registros e métricas O Amazon SageMaker Processing fornece CloudWatch registros e métricas da Amazon para monitorar trabalhos de processamento. CloudWatch fornece CPU, GPU, memória, memória de GPU, métricas de disco e registro de eventos. Para obter mais informações, consulte [Métricas de SageMaker IA da Amazon na Amazon CloudWatch](monitoring-cloudwatch.md) e [CloudWatch Registros para Amazon SageMaker AI](logging-cloudwatch.md). # Executar um Trabalho de Processamento com o Apache Spark O Apache Spark é um mecanismo de analytics unificado para processamento de dados em grande escala. O Amazon SageMaker AI fornece imagens do Docker predefinidas que incluem o Apache Spark e outras dependências necessárias para executar trabalhos de processamento de dados distribuídos. Veja a seguir um exemplo de como executar um trabalho do Amazon SageMaker Processing usando o Apache Spark. Com o [Amazon SageMaker Python SDK](https://github.com/aws/sagemaker-python-sdk#installing-the-sagemaker-python-sdk), você pode aplicar facilmente transformações de dados e extrair atributos (engenharia de atributos) usando a estrutura do Spark. Para obter informações sobre como usar o SDK do SageMaker para Python para executar trabalhos de processamento do Spark, [consulte Processamento de dados com o Spark](https://sagemaker.readthedocs.io/en/stable/amazon_sagemaker_processing.html#data-processing-with-spark) no [Amazon SageMaker Python SDK](https://sagemaker.readthedocs.io/en/stable/). [Um repositório de código que contém o código-fonte e os Dockerfiles das imagens do Spark está disponível no GitHub.](https://github.com/aws/sagemaker-spark-container) Você pode usar a [https://sagemaker.readthedocs.io/en/stable/api/training/processing.html#sagemaker.spark.processing.PySparkProcessor](https://sagemaker.readthedocs.io/en/stable/api/training/processing.html#sagemaker.spark.processing.PySparkProcessor) ou a classe [https://sagemaker.readthedocs.io/en/stable/api/training/processing.html#sagemaker.spark.processing.SparkJarProcessor](https://sagemaker.readthedocs.io/en/stable/api/training/processing.html#sagemaker.spark.processing.SparkJarProcessor) para executar sua aplicação Spark dentro de um trabalho de processamento. Observe que você pode definir maxRuntimeInSeconds para um limite máximo de runtime de 5 dias. Com relação ao runtime e ao número de instâncias usadas, workloads simples do Spark apresentam uma relação quase linear entre o número de instâncias e o tempo até a conclusão. Os exemplos de código a seguir mostram como executar um trabalho de processamento que chama o script do PySpark `preprocess.py`. ``` from sagemaker.spark.processing import PySparkProcessor spark_processor = PySparkProcessor( base_job_name="spark-preprocessor", framework_version="2.4", role=role, instance_count=2, instance_type="ml.m5.xlarge", max_runtime_in_seconds=1200, ) spark_processor.run( submit_app="preprocess.py", arguments=['s3_input_bucket', bucket, 's3_input_key_prefix', input_prefix, 's3_output_bucket', bucket, 's3_output_key_prefix', output_prefix] ) ``` [Para uma análise mais aprofundada, consulte o caderno de exemplo de Processamento de Dados Distribuído com Apache Spark e SageMaker Processing.](https://sagemaker-examples.readthedocs.io/en/latest/sagemaker_processing/spark_distributed_data_processing/sagemaker-spark-processing.html) Se não estiver usando o [Amazon SageMaker AI Python SDK](https://sagemaker.readthedocs.io/) e uma de suas classes de processador para recuperar as imagens predefinidas, você poderá recuperá-las por conta própria. As imagens do Docker pré-compiladas do SageMaker são armazenadas no Amazon Elastic Container Registry (Amazon ECR). Para obter uma lista completa das imagens do Docker pré-criadas disponíveis, consulte o documento de [imagens disponíveis](https://github.com/aws/sagemaker-spark-container/blob/master/available_images.md). Para saber mais sobre como usar o SageMaker AI Python SDK com contêineres de processamento, consulte [Amazon SageMaker AI Python SDK](https://sagemaker.readthedocs.io/en/stable/). # Executar um trabalho de processamento com scikit-learn Você pode usar o Amazon SageMaker Processing para processar dados e avaliar modelos com scripts scikit-learn em uma imagem do Docker fornecida pelo Amazon SageMaker AI. Veja a seguir um exemplo de como executar um trabalho no Amazon SageMaker Processing usando o scikit-learn. Para ver um caderno de exemplo que mostra como executar scripts scikit-learn usando uma imagem do Docker fornecida e mantida pelo SageMaker AI para pré-processar dados e avaliar modelos, consulte [Scikit-Learn Data Processing and Model Evaluation](https://github.com/awslabs/amazon-sagemaker-examples/tree/master/sagemaker_processing/scikit_learn_data_processing_and_model_evaluation). Para usar esse caderno, é necessário instalar o SageMaker AI Python SDK para o Processing. O caderno executa um trabalho de processamento usando a classe `SKLearnProcessor` do Python SDK do SageMaker para executar um script scikit-learn que você fornece. O script pré-processa dados, treina um modelo usando um trabalho de treinamento do SageMaker e executa um trabalho de processamento para avaliar o modelo treinado. O trabalho de processamento estima o desempenho esperado do modelo na produção. Para saber mais sobre como usar o Python SDK do SageMaker com contêineres de processamento, consulte [SageMaker Python SDK](https://sagemaker.readthedocs.io/en/stable/). Para obter uma lista completa das imagens pré-criadas do Docker disponíveis para tarefas de processamento, consulte [Caminhos de registro e código de exemplo do Docker](https://docs.aws.amazon.com/sagemaker/latest/dg-ecr-paths/sagemaker-algo-docker-registry-paths). O exemplo de código a seguir mostra como o caderno usa `SKLearnProcessor` para executar seu script scikit-learn usando uma imagem do Docker fornecida e mantida pelo SageMaker AI, em vez de sua própria imagem do Docker. ``` from sagemaker.sklearn.processing import SKLearnProcessor from sagemaker.processing import ProcessingInput, ProcessingOutput sklearn_processor = SKLearnProcessor(framework_version='0.20.0', role=role, instance_type='ml.m5.xlarge', instance_count=1) sklearn_processor.run(code='preprocessing.py', inputs=[ProcessingInput( source='s3://path/to/my/input-data.csv', destination='/opt/ml/processing/input')], outputs=[ProcessingOutput(source='/opt/ml/processing/output/train'), ProcessingOutput(source='/opt/ml/processing/output/validation'), ProcessingOutput(source='/opt/ml/processing/output/test')] ) ``` Para processar dados em paralelo usando Scikit-Learn no Amazon SageMaker Processing, você pode fragmentar objetos de entrada com a chave do S3 definindo `s3_data_distribution_type='ShardedByS3Key'` dentro de um `ProcessingInput` para que cada instância receba aproximadamente a mesma quantidade de objetos de entrada. # Processamento de dados com processadores de framework A `FrameworkProcessor` pode executar trabalhos de processamento com uma estrutura de aprendizado de máquina especificada, fornecendo a você um contêiner SageMaker gerenciado pela Amazon AI para qualquer estrutura de aprendizado de máquina que você escolher. `FrameworkProcessor`fornece contêineres pré-fabricados para as seguintes estruturas de aprendizado de máquina: Hugging Face,,, MXNet e. PyTorch TensorFlow XGBoost A classe de `FrameworkProcessor` também fornece personalização na configuração do contêiner. A classe de `FrameworkProcessor` classe é compatível com a especificação de um diretório `source_dir` de origem para seus scripts de processamento e dependências. Com esse recurso, você pode dar ao processador acesso a vários scripts em um diretório em vez de especificar apenas um script. O `FrameworkProcessor` também é compatível com a inclusão de um arquivo `requirements.txt` no `source_dir` para personalizar as bibliotecas Python para instalação no contêiner. Para obter mais informações sobre a `FrameworkProcessor` classe e seus métodos e parâmetros, consulte [FrameworkProcessor](https://sagemaker.readthedocs.io/en/stable/api/training/processing.html#sagemaker.processing.FrameworkProcessor)o *Amazon SageMaker AI Python* SDK. Para ver exemplos de uso de um `FrameworkProcessor` para cada um dos frameworks de machine learning compatíveis, consulte os tópicos a seguir. **Topics** + [Exemplo de código usando HuggingFaceProcessor o Amazon SageMaker Python SDK](processing-job-frameworks-hugging-face.md) + [MXNet Processador de estrutura](processing-job-frameworks-mxnet.md) + [PyTorch Processador de estrutura](processing-job-frameworks-pytorch.md) + [TensorFlow Processador de estrutura](processing-job-frameworks-tensorflow.md) + [XGBoost Processador de estrutura](processing-job-frameworks-xgboost.md) # Exemplo de código usando HuggingFaceProcessor o Amazon SageMaker Python SDK Hugging Face é um provedor de código aberto de modelos de processamento de linguagem natural (PLN). O `HuggingFaceProcessor` SDK do Amazon SageMaker Python oferece a capacidade de executar trabalhos de processamento com scripts do Hugging Face. Ao usar o `HuggingFaceProcessor`, você pode aproveitar um contêiner do Docker integrado na Amazon com um ambiente gerenciado pelo Hugging Face para não precisar trazer seu próprio contêiner. O exemplo de código a seguir mostra como você pode usar o `HuggingFaceProcessor` para executar sua tarefa de processamento usando uma imagem do Docker fornecida e mantida pela SageMaker IA. Observe que, ao executar o trabalho, você pode especificar um diretório contendo seus scripts e dependências no `source_dir` argumento e pode ter um `requirements.txt` arquivo localizado dentro do seu `source_dir` diretório que especifica as dependências dos seus scripts de processamento. SageMaker O processamento instala as dependências `requirements.txt` no contêiner para você. ``` from sagemaker.huggingface import HuggingFaceProcessor from sagemaker.processing import ProcessingInput, ProcessingOutput from sagemaker import get_execution_role #Initialize the HuggingFaceProcessor hfp = HuggingFaceProcessor( role=get_execution_role(), instance_count=1, instance_type='ml.g4dn.xlarge', transformers_version='4.4.2', pytorch_version='1.6.0', base_job_name='frameworkprocessor-hf' ) #Run the processing job hfp.run( code='processing-script.py', source_dir='scripts', inputs=[ ProcessingInput( input_name='data', source=f's3://{BUCKET}/{S3_INPUT_PATH}', destination='/opt/ml/processing/input/data/' ) ], outputs=[ ProcessingOutput(output_name='train', source='/opt/ml/processing/output/train/', destination=f's3://{BUCKET}/{S3_OUTPUT_PATH}'), ProcessingOutput(output_name='test', source='/opt/ml/processing/output/test/', destination=f's3://{BUCKET}/{S3_OUTPUT_PATH}'), ProcessingOutput(output_name='val', source='/opt/ml/processing/output/val/', destination=f's3://{BUCKET}/{S3_OUTPUT_PATH}') ] ) ``` Se você tiver um arquivo `requirements.txt`, ele deverá ser uma lista das bibliotecas que você deseja instalar no contêiner. O caminho para `source_dir` pode ser um caminho de URI relativo, absoluto ou do Amazon S3. No entanto, se você usar um URI do Amazon S3, ele deverá apontar para um arquivo tar.gz. Você pode ter vários scripts no diretório que você especificar para `source_dir`. *Para saber mais sobre a `HuggingFaceProcessor` aula, consulte [Hugging Face Estimator](https://sagemaker.readthedocs.io/en/stable/frameworks/huggingface/sagemaker.huggingface.html) no Amazon AI Python SDK. SageMaker * # MXNet Processador de estrutura O Apache MXNet é uma estrutura de aprendizado profundo de código aberto comumente usada para treinar e implantar redes neurais. O `MXNetProcessor` SDK do Amazon SageMaker Python oferece a capacidade de executar trabalhos de processamento com scripts. MXNet Ao usar o`MXNetProcessor`, você pode aproveitar um contêiner Docker criado pela Amazon com um MXNet ambiente gerenciado para não precisar trazer seu próprio contêiner. O exemplo de código a seguir mostra como você pode usar o `MXNetProcessor` para executar sua tarefa de processamento usando uma imagem do Docker fornecida e mantida pela SageMaker IA. Observe que, ao executar o trabalho, você pode especificar um diretório contendo seus scripts e dependências no `source_dir` argumento e pode ter um `requirements.txt` arquivo localizado dentro do seu `source_dir` diretório que especifica as dependências dos seus scripts de processamento. SageMaker O processamento instala as dependências `requirements.txt` no contêiner para você. ``` from sagemaker.mxnet import MXNetProcessor from sagemaker.processing import ProcessingInput, ProcessingOutput from sagemaker import get_execution_role #Initialize the MXNetProcessor mxp = MXNetProcessor( framework_version='1.8.0', py_version='py37', role=get_execution_role(), instance_count=1, instance_type='ml.c5.xlarge', base_job_name='frameworkprocessor-mxnet' ) #Run the processing job mxp.run( code='processing-script.py', source_dir='scripts', inputs=[ ProcessingInput( input_name='data', source=f's3://{BUCKET}/{S3_INPUT_PATH}', destination='/opt/ml/processing/input/data/' ) ], outputs=[ ProcessingOutput( output_name='processed_data', source='/opt/ml/processing/output/', destination=f's3://{BUCKET}/{S3_OUTPUT_PATH}' ) ] ) ``` Se você tiver um arquivo `requirements.txt`, ele deverá ser uma lista das bibliotecas que você deseja instalar no contêiner. O caminho para `source_dir` pode ser um caminho de URI relativo, absoluto ou do Amazon S3. No entanto, se você usar um URI do Amazon S3, ele deverá apontar para um arquivo tar.gz. Você pode ter vários scripts no diretório que você especificar para `source_dir`. Para saber mais sobre a `MXNetProcessor` classe, consulte [MXNet Estimator](https://sagemaker.readthedocs.io/en/stable/frameworks/mxnet/sagemaker.mxnet.html#mxnet-estimator) no SDK do Amazon *Python SageMaker *. # PyTorch Processador de estrutura PyTorch é uma estrutura de aprendizado de máquina de código aberto. O `PyTorchProcessor` SDK do Amazon SageMaker Python oferece a capacidade de executar trabalhos de processamento com scripts. PyTorch Ao usar o`PyTorchProcessor`, você pode aproveitar um contêiner Docker criado pela Amazon com um PyTorch ambiente gerenciado para não precisar trazer seu próprio contêiner. O exemplo de código a seguir mostra como você pode usar o `PyTorchProcessor` para executar sua tarefa de processamento usando uma imagem do Docker fornecida e mantida pela SageMaker IA. Observe que, ao executar o trabalho, você pode especificar um diretório contendo seus scripts e dependências no `source_dir` argumento e pode ter um `requirements.txt` arquivo localizado dentro do seu `source_dir` diretório que especifica as dependências dos seus scripts de processamento. SageMaker O processamento instala as dependências `requirements.txt` no contêiner para você. Para as PyTorch versões suportadas pela SageMaker IA, consulte as [imagens disponíveis do Deep Learning Container](https://github.com/aws/deep-learning-containers/blob/master/available_images.md). ``` from sagemaker.pytorch.processing import PyTorchProcessor from sagemaker.processing import ProcessingInput, ProcessingOutput from sagemaker import get_execution_role #Initialize the PyTorchProcessor pytorch_processor = PyTorchProcessor( framework_version='1.8', role=get_execution_role(), instance_type='ml.m5.xlarge', instance_count=1, base_job_name='frameworkprocessor-PT' ) #Run the processing job pytorch_processor.run( code='processing-script.py', source_dir='scripts', inputs=[ ProcessingInput( input_name='data', source=f's3://{BUCKET}/{S3_INPUT_PATH}', destination='/opt/ml/processing/input' ) ], outputs=[ ProcessingOutput(output_name='data_structured', source='/opt/ml/processing/tmp/data_structured', destination=f's3://{BUCKET}/{S3_OUTPUT_PATH}'), ProcessingOutput(output_name='train', source='/opt/ml/processing/output/train', destination=f's3://{BUCKET}/{S3_OUTPUT_PATH}'), ProcessingOutput(output_name='validation', source='/opt/ml/processing/output/val', destination=f's3://{BUCKET}/{S3_OUTPUT_PATH}'), ProcessingOutput(output_name='test', source='/opt/ml/processing/output/test', destination=f's3://{BUCKET}/{S3_OUTPUT_PATH}'), ProcessingOutput(output_name='logs', source='/opt/ml/processing/logs', destination=f's3://{BUCKET}/{S3_OUTPUT_PATH}') ] ) ``` Se você tiver um arquivo `requirements.txt`, ele deverá ser uma lista das bibliotecas que você deseja instalar no contêiner. O caminho para `source_dir` pode ser um caminho de URI relativo, absoluto ou do Amazon S3. No entanto, se você usar um URI do Amazon S3, ele deverá apontar para um arquivo tar.gz. Você pode ter vários scripts no diretório que você especificar para `source_dir`. Para saber mais sobre a `PyTorchProcessor` classe, consulte [PyTorch Estimator](https://sagemaker.readthedocs.io/en/stable/frameworks/pytorch/sagemaker.pytorch.html) no SDK do Amazon *Python SageMaker *. # TensorFlow Processador de estrutura TensorFlow é uma biblioteca de aprendizado de máquina e inteligência artificial de código aberto. O `TensorFlowProcessor` SDK do Amazon SageMaker Python oferece a capacidade de executar trabalhos de processamento com scripts. TensorFlow Ao usar o`TensorFlowProcessor`, você pode aproveitar um contêiner Docker criado pela Amazon com um TensorFlow ambiente gerenciado para não precisar trazer seu próprio contêiner. O exemplo de código a seguir mostra como você pode usar o `TensorFlowProcessor` para executar sua tarefa de processamento usando uma imagem do Docker fornecida e mantida pela SageMaker IA. Observe que, ao executar o trabalho, você pode especificar um diretório contendo seus scripts e dependências no `source_dir` argumento e pode ter um `requirements.txt` arquivo localizado dentro do seu `source_dir` diretório que especifica as dependências dos seus scripts de processamento. SageMaker O processamento instala as dependências `requirements.txt` no contêiner para você. ``` from sagemaker.tensorflow import TensorFlowProcessor from sagemaker.processing import ProcessingInput, ProcessingOutput from sagemaker import get_execution_role #Initialize the TensorFlowProcessor tp = TensorFlowProcessor( framework_version='2.3', role=get_execution_role(), instance_type='ml.m5.xlarge', instance_count=1, base_job_name='frameworkprocessor-TF', py_version='py37' ) #Run the processing job tp.run( code='processing-script.py', source_dir='scripts', inputs=[ ProcessingInput( input_name='data', source=f's3://{BUCKET}/{S3_INPUT_PATH}', destination='/opt/ml/processing/input/data' ), ProcessingInput( input_name='model', source=f's3://{BUCKET}/{S3_PATH_TO_MODEL}', destination='/opt/ml/processing/input/model' ) ], outputs=[ ProcessingOutput( output_name='predictions', source='/opt/ml/processing/output', destination=f's3://{BUCKET}/{S3_OUTPUT_PATH}' ) ] ) ``` Se você tiver um arquivo `requirements.txt`, ele deverá ser uma lista das bibliotecas que você deseja instalar no contêiner. O caminho para `source_dir` pode ser um caminho de URI relativo, absoluto ou do Amazon S3. No entanto, se você usar um URI do Amazon S3, ele deverá apontar para um arquivo tar.gz. Você pode ter vários scripts no diretório que você especificar para `source_dir`. Para saber mais sobre a `TensorFlowProcessor` classe, consulte [TensorFlow Estimator](https://sagemaker.readthedocs.io/en/stable/frameworks/tensorflow/sagemaker.tensorflow.html#tensorflow-estimator) no SDK do Amazon *Python SageMaker *. # XGBoost Processador de estrutura XGBoost é uma estrutura de aprendizado de máquina de código aberto. O `XGBoostProcessor` SDK do Amazon SageMaker Python oferece a capacidade de executar trabalhos de processamento com scripts. XGBoost Ao usar o XGBoost processador, você pode aproveitar um contêiner Docker criado pela Amazon com um XGBoost ambiente gerenciado para não precisar trazer seu próprio contêiner. O exemplo de código a seguir mostra como você pode usar o `XGBoostProcessor` para executar sua tarefa de processamento usando uma imagem do Docker fornecida e mantida pela SageMaker IA. Observe que, ao executar o trabalho, você pode especificar um diretório contendo seus scripts e dependências no `source_dir` argumento e pode ter um `requirements.txt` arquivo localizado dentro do seu `source_dir` diretório que especifica as dependências dos seus scripts de processamento. SageMaker O processamento instala as dependências `requirements.txt` no contêiner para você. ``` from sagemaker.xgboost import XGBoostProcessor from sagemaker.processing import ProcessingInput, ProcessingOutput from sagemaker import get_execution_role #Initialize the XGBoostProcessor xgb = XGBoostProcessor( framework_version='1.2-2', role=get_execution_role(), instance_type='ml.m5.xlarge', instance_count=1, base_job_name='frameworkprocessor-XGB', ) #Run the processing job xgb.run( code='processing-script.py', source_dir='scripts', inputs=[ ProcessingInput( input_name='data', source=f's3://{BUCKET}/{S3_INPUT_PATH}', destination='/opt/ml/processing/input/data' ) ], outputs=[ ProcessingOutput( output_name='processed_data', source='/opt/ml/processing/output/', destination=f's3://{BUCKET}/{S3_OUTPUT_PATH}' ) ] ) ``` Se você tiver um arquivo `requirements.txt`, ele deverá ser uma lista das bibliotecas que você deseja instalar no contêiner. O caminho para `source_dir` pode ser um caminho de URI relativo, absoluto ou do Amazon S3. No entanto, se você usar um URI do Amazon S3, ele deverá apontar para um arquivo tar.gz. Você pode ter vários scripts no diretório que você especificar para `source_dir`. Para saber mais sobre a `XGBoostProcessor` classe, consulte [XGBoost Estimator](https://sagemaker.readthedocs.io/en/stable/frameworks/xgboost/xgboost.html) no SDK do Amazon *Python SageMaker *. # Usar seu próprio código de processamento Você pode instalar bibliotecas para executar seus scripts em seu próprio contêiner de processamento ou, em um cenário mais avançado, você pode criar seu próprio contêiner de processamento que satisfaça o contrato para execução na Amazon SageMaker AI. Para obter mais informações sobre contêineres na SageMaker IA, consulte[Contêineres do Docker para treinamento e implantação de modelos](docker-containers.md). Para obter uma especificação formal que define o contrato para um contêiner SageMaker de processamento da Amazon, consulte[Como criar um contêiner de processamento (cenário avançado)](build-your-own-processing-container.md). **Topics** + [Executar scripts com seu próprio contêiner de processamento](processing-container-run-scripts.md) + [Como criar um contêiner de processamento (cenário avançado)](build-your-own-processing-container.md) # Executar scripts com seu próprio contêiner de processamento É possível usar scripts scikit-learn para pré-processar dados e avaliar modelos. Para ver como executar scripts scikit-learn para realizar essas tarefas, consulte o caderno de exemplo [Processamento scikit-learn](https://github.com/awslabs/amazon-sagemaker-examples/tree/master/sagemaker_processing/scikit_learn_data_processing_and_model_evaluation). Esse notebook usa a `ScriptProcessor` classe do Amazon SageMaker Python SDK para processamento. O exemplo a seguir mostra um fluxo de trabalho geral para usar uma classe `ScriptProcessor` com seu próprio contêiner de processamento. O fluxo de trabalho mostra como criar sua própria imagem, criar seu contêiner e usar uma classe `ScriptProcessor` para executar um script de pré-processamento do Python com o contêiner. O trabalho de processamento processa seus dados de entrada e salva os dados processados no Amazon Simple Storage Service (Amazon S3). Antes de usar os exemplos a seguir, você precisa ter seus próprios dados de entrada e um script Python preparado para processar seus dados. Para ver um end-to-end exemplo guiado desse processo, consulte o caderno de amostra de [processamento scikit-learn](https://github.com/awslabs/amazon-sagemaker-examples/tree/master/sagemaker_processing/scikit_learn_data_processing_and_model_evaluation). 1. Crie um diretório do Docker e adicione o Dockerfile usado para criar o contêiner de processamento. Instale pandas e scikit-learn nele. (Também é possível instalar suas próprias dependências com um comando `RUN` semelhante.) ``` mkdir docker %%writefile docker/Dockerfile FROM python:3.7-slim-buster RUN pip3 install pandas==0.25.3 scikit-learn==0.21.3 ENV PYTHONUNBUFFERED=TRUE ENTRYPOINT ["python3"] ``` 1. Crie o contêiner usando o comando do Docker, crie um repositório do Amazon Elastic Container Registry (Amazon ECR) e envie a imagem para o Amazon ECR. ``` import boto3 account_id = boto3.client('sts').get_caller_identity().get('Account') region = boto3.Session().region_name ecr_repository = 'sagemaker-processing-container' tag = ':latest' processing_repository_uri = '{}.dkr.ecr.{}.amazonaws.com/{}'.format(account_id, region, ecr_repository + tag) # Create ECR repository and push docker image !docker build -t $ecr_repository docker !aws ecr get-login-password --region {region} | docker login --username AWS --password-stdin {account_id}.dkr.ecr.{region}.amazonaws.com !aws ecr create-repository --repository-name $ecr_repository !docker tag {ecr_repository + tag} $processing_repository_uri !docker push $processing_repository_uri ``` 1. Configure o a `ScriptProcessor` partir do SDK do SageMaker Python para executar o script. *image\$1uri*Substitua pelo URI da imagem que você criou e *role\$1arn* substitua pelo ARN de uma AWS Identity and Access Management função que tenha acesso ao seu bucket do Amazon S3 de destino. ``` from sagemaker.processing import ScriptProcessor, ProcessingInput, ProcessingOutput script_processor = ScriptProcessor(command=['python3'], image_uri='image_uri', role='role_arn', instance_count=1, instance_type='ml.m5.xlarge') ``` 1. Executar o script. *preprocessing.py*Substitua pelo nome do seu próprio script de processamento do Python e *s3://path/to/my/input-data.csv* substitua pelo caminho do Amazon S3 para seus dados de entrada. ``` script_processor.run(code='preprocessing.py', inputs=[ProcessingInput( source='s3://path/to/my/input-data.csv', destination='/opt/ml/processing/input')], outputs=[ProcessingOutput(source='/opt/ml/processing/output/train'), ProcessingOutput(source='/opt/ml/processing/output/validation'), ProcessingOutput(source='/opt/ml/processing/output/test')]) ``` O mesmo procedimento pode ser usado com qualquer outra biblioteca ou dependências do sistema. Você também pode usar imagens do Docker existentes. Isso inclui imagens que você executa em outras plataformas, como o [Kubernetes](https://kubernetes.io/). # Como criar um contêiner de processamento (cenário avançado) Você pode fornecer ao Amazon SageMaker Processing uma imagem do Docker que tenha seu próprio código e dependências para executar suas cargas de trabalho de processamento de dados, engenharia de recursos e avaliação de modelos. Veja a seguir informações sobre como criar um contêiner de processamento. O exemplo a seguir de um Dockerfile cria um contêiner com as bibliotecas Python de scikit-learn e pandas que podem ser executados como um trabalho de processamento. ``` FROM python:3.7-slim-buster # Install scikit-learn and pandas RUN pip3 install pandas==0.25.3 scikit-learn==0.21.3 # Add a Python script and configure Docker to run it ADD processing_script.py / ENTRYPOINT ["python3", "/processing_script.py"] ``` Para ver um exemplo de script de processamento, consulte [Introdução ao SageMaker processamento](https://github.com/aws/amazon-sagemaker-examples/blob/main/sagemaker_processing/basic_sagemaker_data_processing/basic_sagemaker_processing.ipynb). Crie e envie essa imagem do Docker para um repositório do Amazon Elastic Container Registry (Amazon ECR) e garanta que sua função de SageMaker IA IAM possa extrair a imagem do Amazon ECR. Em seguida, você pode executar essa imagem no Amazon SageMaker Processing. # Como o Amazon SageMaker Processing executa sua imagem de contêiner de processamento O Amazon SageMaker Processing executa sua imagem de contêiner de processamento de forma semelhante ao comando a seguir, onde `AppSpecification.ImageUri` está o URI da imagem do Amazon ECR que você especifica em uma `CreateProcessingJob` operação. ``` docker run [AppSpecification.ImageUri] ``` Esse comando executa o comando `ENTRYPOINT` configurado na imagem do Docker. Também é possível substituir o comando do ponto de entrada na imagem ou fornecer argumentos da linha de comando ao comando do ponto de entrada usando os parâmetros `AppSpecification.ContainerEntrypoint` e `AppSpecification.ContainerArgument` na solicitação `CreateProcessingJob`. A especificação desses parâmetros configura o Amazon SageMaker Processing para executar o contêiner da mesma forma que o comando a seguir. ``` docker run --entry-point [AppSpecification.ContainerEntrypoint] [AppSpecification.ImageUri] [AppSpecification.ContainerArguments] ``` Por exemplo, se você especificar “`ContainerEntrypoint`estar `[python3, -v, /processing_script.py]` na sua `CreateProcessingJob ` solicitação” e “ser`[data-format, csv]`”, `ContainerArguments` o Amazon SageMaker Processing executará seu contêiner com o seguinte comando. ``` python3 -v /processing_script.py data-format csv ``` Considere os seguintes detalhes ao criar o contêiner de processamento: + O Amazon SageMaker Processing decide se o trabalho é concluído ou falhado, dependendo do código de saída da execução do comando. Um trabalho de processamento será concluído se todos os contêineres de processamento forem encerrados com êxito, com um código de saída de 0 e apresentará falha se algum dos contêineres for encerrado com um código de saída diferente de zero. + O Amazon SageMaker Processing permite que você substitua o ponto de entrada do contêiner de processamento e defina argumentos de linha de comando da mesma forma que você pode fazer com a API do Docker. As imagens do Docker também podem configurar os argumentos do ponto de entrada e da linha de comando usando as instruções da CMD e de `ENTRYPOINT`. A maneira como os parâmetros de `CreateProcessingJob`, `ContainerEntrypoint` e do `ContainerArgument` configuram o ponto de entrada e os argumentos de uma imagem do Docker espelha como o Docker substitui o ponto de entrada e os argumentos usando a API do Docker: + Se nem `ContainerEntrypoint` nem `ContainerArguments` forem fornecidos, o Processing usará o padrão `ENTRYPOINT` ou a CMD na imagem. + Se `ContainerEntrypoint` for fornecido, mas `ContainerArguments` não for, o Processing executa a imagem com o ponto de entrada fornecido e ignora o `ENTRYPOINT` e a CMD na imagem. + Se `ContainerArguments` for fornecido, mas `ContainerEntrypoint` não for, o Processing executa a imagem com o padrão `ENTRYPOINT` na imagem e com os argumentos fornecidos. + Se `ContainerEntrypoint` e `ContainerArguments` forem fornecidos, o Processing executa a imagem com o ponto de entrada e os argumentos fornecidos, e ignorará o `ENTRYPOINT` e a CMD na imagem. + Use a forma "exec" da instrução `ENTRYPOINT` no Dockerfile (`ENTRYPOINT` `["executable", "param1", "param2"])` em vez da forma "shell" (`ENTRYPOINT`` command param1 param2`). Isso permite que o contêiner de processamento receba sinais `SIGINT` e `SIGKILL`, que o Processing usa para interromper trabalhos de processamento com a API `StopProcessingJob`. + `/opt/ml`e todos os seus subdiretórios são reservados pela SageMaker IA. Ao criar a imagem de processamento do Docker, não coloque nenhum dado exigido pelo contêiner de processamento nesses diretórios. + Se você planeja usar dispositivos de GPU, verifique se os contêineres são compatíveis com nvidia-docker. Inclua somente o CUDA toolkit nos contêineres. Não empacote drivers NVIDIA com a imagem. Para obter mais informações sobre o nvidia-docker, consulte [NVIDIA/nvidia-docker](https://github.com/NVIDIA/nvidia-docker). # Como o Amazon SageMaker Processing configura a entrada e a saída para seu contêiner de processamento Ao criar um trabalho de processamento usando a operação `CreateProcessingJob`, é possível especificar vários valores de `ProcessingInput` e `ProcessingOutput`. Use o parâmetro `ProcessingInput` para especificar um URI do Amazon Simple Storage Service (Amazon S3) de onde fazer download de dados e um caminho no contêiner de processamento para o qual fazer download dos dados. O parâmetro `ProcessingOutput` configura um caminho no contêiner de processamento a partir do qual fazer upload dos dados e para onde no Amazon S3 fazer upload desses dados. Para `ProcessingInput` e `ProcessingOutput`, o caminho no contêiner de processamento deve começar com `/opt/ml/processing/ `. Por exemplo, é possível criar um trabalho de processamento com um parâmetro `ProcessingInput` que faça download dos dados de `s3://your-data-bucket/path/to/input/csv/data` em um `/opt/ml/processing/csv` no contêiner de processamento e um parâmetro `ProcessingOutput` que faça upload dos dados de `/opt/ml/processing/processed_csv` para `s3://your-data-bucket/path/to/output/csv/data`. Seu trabalho de processamento faria a leitura dos dados de entrada e gravaria os dados de saída em `/opt/ml/processing/processed_csv`. Depois, faz o upload dos dados gravados nesse caminho para o local de saída do Amazon S3 especificado. **Importante** Links simbólicos (links simbólicos) não podem ser usados para carregar dados de saída no Amazon S3. Os links simbólicos não são seguidos ao fazer o upload dos dados de saída. # Como o Amazon SageMaker Processing fornece registros e métricas para seu contêiner de processamento Quando seu contêiner de processamento grava em `stdout` ou`stderr`, o Amazon SageMaker Processing salva a saída de cada contêiner de processamento e a coloca nos CloudWatch registros da Amazon. Para obter informações sobre registro em log, consulte [CloudWatch Registros para Amazon SageMaker AI](logging-cloudwatch.md). O Amazon SageMaker Processing também fornece CloudWatch métricas para cada instância que executa seu contêiner de processamento. Para obter informações sobre métricas, consulte [Métricas de SageMaker IA da Amazon na Amazon CloudWatch](monitoring-cloudwatch.md). ## Como o Amazon SageMaker Processing configura seu contêiner de processamento O Amazon SageMaker Processing fornece informações de configuração para seu contêiner de processamento por meio de variáveis de ambiente e dois arquivos JSON — `/opt/ml/config/processingjobconfig.json` e `/opt/ml/config/resourceconfig.json` — em locais predefinidos no contêiner. Quando um trabalho de processamento é iniciado, ele usa as variáveis de ambiente que você especificou com o mapa de `Environment` na solicitação `CreateProcessingJob`. O arquivo `/opt/ml/config/processingjobconfig.json` contém informações sobre os nomes de host dos contêineres de processamento e também é especificado na solicitação `CreateProcessingJob`. O exemplo a seguir mostra o formato do arquivo `/opt/ml/config/processingjobconfig.json`. ``` { "ProcessingJobArn": "", "ProcessingJobName": "", "AppSpecification": { "ImageUri": "", "ContainerEntrypoint": null, "ContainerArguments": null }, "Environment": { "KEY": "VALUE" }, "ProcessingInputs": [ { "InputName": "input-1", "S3Input": { "LocalPath": "/opt/ml/processing/input/dataset", "S3Uri": "", "S3DataDistributionType": "FullyReplicated", "S3DataType": "S3Prefix", "S3InputMode": "File", "S3CompressionType": "None", "S3DownloadMode": "StartOfJob" } } ], "ProcessingOutputConfig": { "Outputs": [ { "OutputName": "output-1", "S3Output": { "LocalPath": "/opt/ml/processing/output/dataset", "S3Uri": "", "S3UploadMode": "EndOfJob" } } ], "KmsKeyId": null }, "ProcessingResources": { "ClusterConfig": { "InstanceCount": 1, "InstanceType": "ml.m5.xlarge", "VolumeSizeInGB": 30, "VolumeKmsKeyId": null } }, "RoleArn": "", "StoppingCondition": { "MaxRuntimeInSeconds": 86400 } } ``` O arquivo `/opt/ml/config/resourceconfig.json` contém informações sobre os nomes de host dos contêineres de processamento. Use nomes de host a seguir ao criar ou executar código de processamento distribuído. ``` { "current_host": "algo-1", "hosts": ["algo-1","algo-2","algo-3"] } ``` Não use as informações sobre nomes de host contidos no `/etc/hostname` ou no `/etc/hosts` porque elas podem estar incorretas. As informações do nome do host podem não estar imediatamente disponíveis para o contêiner de processamento. Recomendamos adicionar uma política de nova tentativa em operações de resolução de nomes de host à medida que os nós se tornarem disponíveis no cluster. # Salvar e acessar informações de metadados sobre seu trabalho de processamento Para salvar metadados do contêiner de processamento depois de sair dele, os contêineres podem gravar texto codificado em UTF-8 no arquivo `/opt/ml/output/message`. Depois que o trabalho de processamento entrar em qualquer status terminal ("`Completed`", "`Stopped`" ou "`Failed`"), o campo "`ExitMessage`" em [https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_DescribeProcessingJob.html](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_DescribeProcessingJob.html) conterá o primeiro 1 KB desse arquivo. Acesse essa parte inicial do arquivo com uma chamada para [https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_DescribeProcessingJob.html](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_DescribeProcessingJob.html), que a retornará pelo parâmetro `ExitMessage`. Por exemplo, para trabalhos de processamento com falha, é possível usar esse campo para comunicar por que houve falha no contêiner de processamento. **Importante** Não grave dados confidenciais no arquivo `/opt/ml/output/message`. Se os dados neste arquivo não estiverem codificados em UTF-8, haverá falha no trabalho e um `ClientError` será retornado. Se vários contêineres forem encerrados com uma `ExitMessage,`, o conteúdo da `ExitMessage` de cada contêiner de processamento será concatenado e truncado para 1 KB. # Execute seu contêiner de processamento usando o SageMaker SDK AI Python Você pode usar o SDK do SageMaker Python para executar sua própria imagem de processamento usando a classe. `Processor` O exemplo a seguir mostra como executar seu próprio contêiner de processamento com uma entrada do Amazon Simple Storage Service (Amazon S3) e uma saída para o Amazon S3. ``` from sagemaker.processing import Processor, ProcessingInput, ProcessingOutput processor = Processor(image_uri='', role=role, instance_count=1, instance_type="ml.m5.xlarge") processor.run(inputs=[ProcessingInput( source='', destination='/opt/ml/processing/input_data')], outputs=[ProcessingOutput( source='/opt/ml/processing/processed_data', destination='')], ) ``` Em vez de criar o código de processamento na imagem de processamento, é possível fornecer um `ScriptProcessor` com sua imagem e o comando que deseja executar com o código que deseja executar dentro desse contêiner. Para ver um exemplo, consulte [Executar scripts com seu próprio contêiner de processamento](processing-container-run-scripts.md). Você também pode usar a imagem scikit-learn fornecida pela Amazon SageMaker Processing `SKLearnProcessor` para executar scripts scikit-learn. Para ver um exemplo, consulte [Executar um trabalho de processamento com scikit-learn](use-scikit-learn-processing-container.md).