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

# Executar scripts com seu próprio contêiner de processamento
<a name="processing-container-run-scripts"></a>

É 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/).