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á. # 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).