

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

# Como a Amazon SageMaker AI executa sua imagem de treinamento
<a name="your-algorithms-training-algo-dockerfile"></a>

Você pode usar um script de ponto de entrada personalizado para automatizar a infraestrutura para treinar em um ambiente de produção. Se você passar seu script de ponto de entrada para o contêiner do Docker, também poderá executá-lo como um script independente sem reconstruir suas imagens. SageMaker A IA processa sua imagem de treinamento usando um script de ponto de entrada do contêiner Docker. 

Esta seção mostra como usar um ponto de entrada personalizado sem o uso do kit de ferramentas de treinamento. Se você quiser usar um ponto de entrada personalizado, mas não estiver familiarizado com a configuração manual de um contêiner do Docker, recomendamos que você use a biblioteca do kit de ferramentas de [SageMaker treinamento](https://github.com/aws/sagemaker-training-toolkit). Para mais informações sobre como utilizar o kit de ferramentas de treino, consulte [Como adaptar o próprio contêiner de treinamento](adapt-training-container.md). 

Por padrão, a SageMaker IA procura um script chamado `train` dentro do seu contêiner. Você também pode fornecer manualmente seu próprio ponto de entrada personalizado usando os `ContainerEntrypoint` parâmetros `ContainerArguments` e da [AlgorithmSpecification](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_AlgorithmSpecification.html)API. 

Você tem as duas opções a seguir para configurar manualmente o contêiner do Docker para executar sua imagem.
+ Use a [CreateTrainingJob](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_CreateTrainingJob.html)API e um contêiner do Docker com uma instrução de ponto de entrada contida nele.
+ Use a API `CreateTrainingJob` e aprove o script de treinamento de fora do contêiner do Docker.

Se você aprovar o script de treinamento de fora do contêiner do Docker, não precisará reconstruir o contêiner do Docker ao atualizar o script. Você também pode usar vários scripts diferentes para serem executados no mesmo contêiner.

Seu script de ponto de entrada deve conter o código de treinamento para sua imagem. Se você usar o parâmetro opcional `source_dir` dentro de um [estimador](https://sagemaker.readthedocs.io/en/stable/api/training/estimators.html), ele deverá referenciar o caminho relativo do Amazon S3 para a pasta que contém o script de ponto de entrada. Você pode referenciar vários arquivos usando o parâmetro `source_dir`. Se você não usar o `source_dir`, poderá especificar o ponto de entrada usando o parâmetro `entry_point`. Para ver um exemplo de um script de ponto de entrada personalizado que contém um estimador, consulte [Traga seu próprio modelo com SageMaker ](https://sagemaker-examples.readthedocs.io/en/latest/sagemaker-script-mode/sagemaker-script-mode.html) o modo de script AI.

SageMaker O treinamento do modelo de IA oferece suporte a buckets de diretório S3 Express One Zone de alto desempenho como um local de entrada de dados para o modo de arquivo, modo de arquivo rápido e modo pipe. Você também pode usar buckets de diretório da classe S3 Express One Zone para armazenar os resultados do treinamento. Para usar o S3 Express One Zone, forneça o URI de um bucket de diretório do S3 Express One Zone em vez de um bucket de uso geral do Amazon S3. Você só pode criptografar seus dados de saída de SageMaker IA em buckets de diretório com criptografia do lado do servidor com chaves gerenciadas do Amazon S3 (SSE-S3). Atualmente, a criptografia do lado do servidor com AWS KMS chaves (SSE-KMS) não é suportada para armazenar dados de saída de SageMaker IA em buckets de diretório. Para obter mais informações, consulte [S3 Express One Zone](https://docs.aws.amazon.com/AmazonS3/latest/userguide/s3-express-one-zone.html).

## Execute um trabalho de treinamento com um script de ponto de entrada incluído no contêiner do Docker
<a name="your-algorithms-training-algo-dockerfile-api-ep-in"></a>

SageMaker A IA pode executar um script de ponto de entrada incluído em seu contêiner Docker. 
+ Por padrão, o Amazon SageMaker AI executa o seguinte contêiner.

  ```
  docker run {{image}} train
  ```
+ SageMaker A IA substitui todas as instruções [CMD](https://docs.docker.com/engine/reference/builder/#cmd) padrão em um contêiner especificando o `train` argumento após o nome da imagem. No arquivo do contêiner do Docker, use o formulário `exec` da instrução `ENTRYPOINT`.

  ```
  ENTRYPOINT ["{{executable}}", "{{param1}}", "{{param2}}", ...]
  ```

  O exemplo a seguir mostra como especificar uma instrução de ponto de entrada do python chamada `k-means-algorithm.py`.

  ```
  ENTRYPOINT ["python", "k-means-algorithm.py"]
  ```

  A forma `exec` da instrução `ENTRYPOINT` inicia o executável diretamente, não como elemento filho de `/bin/sh`. Isso permite que ele receba sinais `SIGKILL` de `SIGTERM` e para SageMaker APIs. As condições a seguir se aplicam ao usar SageMaker APIs o. 
  + A [https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_CreateTrainingJob.html](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_CreateTrainingJob.html)API tem uma condição de parada que faz com que a SageMaker IA interrompa o treinamento do modelo após um tempo específico. 
  + A seguir, a API do [https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_StopTrainingJob.html](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_StopTrainingJob.html). Esta API emite o equivalente do `docker stop`, com um comando de tempo limite de 2 minutos, para interromper tranquilamente o contêiner especificado.

    ```
    docker stop -t 120
    ```

    Para tentar interromper o contêiner em execução, o comando envia um sinal `SIGTERM`. Após o tempo limite de 2 minutos, a API envia `SIGKILL` e interrompe os contêineres à força. Se o contêiner manipula o sinal `SIGTERM` com tranquilidade e sai dentro de 120 segundos após recebê-lo, nenhum sinal `SIGKILL` é enviado. 

  Se você quiser acessar os artefatos do modelo intermediário depois que a SageMaker IA interromper o treinamento, adicione código para lidar com o salvamento de artefatos em seu `SIGTERM` manipulador.
+ Se você planeja usar dispositivos de GPU para treinamento de modelos, os contêineres devem ser compatíveis com `nvidia-docker`. Somente o kit de ferramentas CUDA deve ser incluído em 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).
+ Você não pode usar o `tini` inicializador como seu script de ponto de entrada em contêineres de SageMaker IA porque ele fica confuso com os argumentos e. `train` `serve`
+ `/opt/ml`e todos os subdiretórios são reservados por SageMaker treinamento. Ao criar a imagem do Docker do seu algoritmo, certifique-se de não colocar nenhum dado exigido pelo seu algoritmo nesse diretório. Porque se você fizer isso, os dados podem não estar mais visíveis durante o treinamento.

Para agrupar seus scripts de shell ou Python em sua imagem do Docker, ou para fornecer o script em um bucket do Amazon S3 ou usando a AWS Command Line Interface (CLI), continue na seção a seguir.

### Agrupe o script de shell em um contêiner do Docker
<a name="your-algorithms-training-algo-dockerfile-script-sh"></a>

 Se você quiser agrupar um script de shell personalizado em sua imagem do Docker, use as etapas a seguir. 

1. Copie o script de shell do diretório de trabalho para dentro do contêiner do Docker. O trecho de código a seguir copia um script de ponto de entrada personalizado `custom_entrypoint.sh` do diretório de trabalho atual para um contêiner do Docker localizado em `mydir`. O exemplo a seguir pressupõe que a imagem do Docker de base tem o Python instalado.

   ```
   FROM {{<base-docker-image>}}:{{<tag>}}
   
   # Copy custom entrypoint from current dir to /mydir on container
   COPY {{./custom_entrypoint.sh /mydir/ }}
   ```

1. Crie e envie um contêiner do Docker para o Amazon Elastic Container Registry ([Amazon ECR](https://docs.aws.amazon.com/AmazonECR/latest/userguide/what-is-ecr.html)) seguindo as instruções em [Enviar uma imagem do Docker](https://docs.aws.amazon.com/AmazonECR/latest/userguide/docker-push-ecr-image.html) no *Guia do usuário do Amazon ECR*.

1. Inicie o trabalho de treinamento executando o AWS CLI comando a seguir.

   ```
   aws --region {{<your-region>}} sagemaker create-training-job \
   --training-job-name {{<your-training-job-name>}} \
   --role-arn {{<your-execution-role-arn>}} \
   --algorithm-specification '{ \ 
       "TrainingInputMode": "File", \
       "TrainingImage": "{{<your-ecr-image>}}", \
       "ContainerEntrypoint": ["{{/bin/sh}}"], \
       "ContainerArguments": ["{{/mydir/custom_entrypoint.sh}}"]}' \
   --output-data-config '{"S3OutputPath": "{{s3://custom-entrypoint-output-bucket/}}"}' \
   --resource-config '{"VolumeSizeInGB":{{10}},"InstanceCount":{{1}},"InstanceType":"{{ml.m5.2xlarge}}"}' \
   --stopping-condition '{"MaxRuntimeInSeconds": {{180}}}'
   ```

### Agrupe o script do Python em um contêiner do Docker
<a name="your-algorithms-training-algo-dockerfile-script-py"></a>

Para agrupar um script Python personalizado na imagem do Docker, use as etapas a seguir. 

1. Copie o script do Python do diretório de trabalho para dentro do contêiner do Docker. O trecho de código a seguir copia um script de ponto de entrada personalizado `custom_entrypoint.py` do diretório de trabalho atual para um contêiner do Docker localizado em `mydir`.

   ```
   FROM {{<base-docker-image>}}:{{<tag>}}
   # Copy custom entrypoint from current dir to /mydir on container
   COPY {{./custom_entrypoint.py /mydir/}}
   ```

1. Inicie o trabalho de treinamento executando o AWS CLI comando a seguir.

   ```
   --algorithm-specification '{ \ 
       "TrainingInputMode": "File", \
       "TrainingImage": "{{<your-ecr-image>}}", \
       "ContainerEntrypoint": ["{{python}}"], \
       "ContainerArguments": ["{{/mydir/custom_entrypoint.py}}"]}' \
   ```

## Execute um trabalho de treinamento com um script de ponto de entrada fora do contêiner do Docker
<a name="your-algorithms-training-algo-dockerfile-api-pass-ep"></a>

Você pode usar seu próprio contêiner do Docker para treinamento e transmitir um script de ponto de entrada de fora do contêiner do Docker. Há alguns benefícios em estruturar seu script de ponto de entrada fora do contêiner. Se você atualizar o script do ponto de entrada, você não precisará reconstruir o contêiner do Docker. Você também pode usar vários scripts diferentes para serem executados no mesmo contêiner. 

Especifique a localização do seu script de treinamento usando os `ContainerArguments` parâmetros `ContainerEntrypoint` e da [AlgorithmSpecification](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_AlgorithmSpecification.html)API. Esses pontos de entrada e argumentos se comportam da mesma maneira que os pontos de entrada e argumentos do Docker. Os valores nesses parâmetros substituem os correspondentes `ENTRYPOINT` ou `CMD` fornecidos como parte do contêiner do Docker. 

Quando você passa o script de ponto de entrada personalizado para o contêiner de treinamento do Docker, as entradas que você fornece determinam o comportamento do contêiner.
+ Por exemplo, se você fornecer somente`ContainerEntrypoint`, a sintaxe da solicitação usando a CreateTrainingJob API será a seguinte.

  ```
  {
      "AlgorithmSpecification": {
          "ContainerEntrypoint": ["{{string}}"],   
          ...     
          }       
  }
  ```

  Em seguida, o back-end de SageMaker treinamento executa seu ponto de entrada personalizado da seguinte maneira.

  ```
  docker run --entrypoint {{<ContainerEntrypoint>}} image
  ```
**nota**  
Se `ContainerEntrypoint` for fornecido, o back-end de SageMaker treinamento executa a imagem com o ponto de entrada fornecido e substitui o padrão na imagem. `ENTRYPOINT`
+ Se você fornecer apenas`ContainerArguments`, a SageMaker IA presume que o contêiner do Docker contém um script de ponto de entrada. A sintaxe da solicitação usando a API `CreateTrainingJob` é a seguinte:

  ```
  {
      "AlgorithmSpecification": {
          "ContainerArguments": ["{{arg1}}", "{{arg2}}"],
          ...
      }
  }
  ```

  O back-end de SageMaker treinamento executa seu ponto de entrada personalizado da seguinte maneira.

  ```
  docker run image {{<ContainerArguments>}}
  ```
+ Se você fornecer o `ContainerEntrypoint` e `ContainerArguments`, a sintaxe da solicitação usando a API `CreateTrainingJob` será a seguinte:

  ```
  {
      "AlgorithmSpecification": {
          "ContainerEntrypoint": ["{{string}}"],
          "ContainerArguments": ["{{arg1}}", "{{arg2}}"],
          ...
      }
  }
  ```

   O back-end de SageMaker treinamento executa seu ponto de entrada personalizado da seguinte maneira.

  ```
  docker run --entrypoint {{<ContainerEntrypoint>}} image {{<ContainerArguments>}}
  ```

Você pode usar qualquer fonte `InputDataConfig` compatível na API `CreateTrainingJob` para fornecer um script de ponto de entrada para executar a imagem de treinamento. 

### Forneça o script de ponto de entrada em um bucket do Amazon S3
<a name="your-algorithms-training-algo-dockerfile-script-s3"></a>

 Para fornecer um script de ponto de entrada personalizado usando um bucket do S3, use o `S3DataSource` parâmetro da [DataSource](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_DataSource.html#sagemaker-Type-DataSource-S3DataSource)API para especificar a localização do script. Se você usar o parâmetro `S3DataSource`, os itens a seguir serão obrigatórios:
+ [InputMode](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_Channel.html#sagemaker-Type-Channel-InputMode)Deve ser do tipo`File`.
+ O [S3 DataDistributionType](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_DataSource.html#sagemaker-Type-DataSource-S3DataSource) deve ser`FullyReplicated`.

O exemplo a seguir tem um script chamado custom\_entrypoint.sh colocado em um caminho para um bucket `s3://<bucket-name>/<bucket prefix>/custom_entrypoint.sh` do S3.

```
#!/bin/bash
echo "Running custom_entrypoint.sh"
echo "Hello you have provided the following arguments: " "$@"
```

Em seguida, você deve definir a configuração do canal de dados de entrada para executar um trabalho de treinamento. Faça isso usando o AWS CLI diretamente ou com um arquivo JSON.

#### Configure o canal de dados de entrada usando AWS CLI um arquivo JSON
<a name="your-algorithms-training-algo-dockerfile-script-s3-json"></a>

Para configurar seu canal de dados de entrada com um arquivo JSON, use AWS CLI conforme mostrado na estrutura de código a seguir. Certifique-se de que todos os campos a seguir usem a sintaxe de solicitação definida na [CreateTrainingJob](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_CreateTrainingJob.html#API_CreateTrainingJob_RequestSyntax)API.

```
// run-my-training-job.json
{
 "[AlgorithmSpecification](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_CreateTrainingJob.html#sagemaker-CreateTrainingJob-request-AlgorithmSpecification)": { 
        "ContainerEntrypoint": ["{{/bin/sh}}"],
        "ContainerArguments": ["/opt/ml/input/data/{{<your_channel_name>}}/{{custom_entrypoint.sh}}"],
         ...
   },
  "[InputDataConfig](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_CreateTrainingJob.html#sagemaker-CreateTrainingJob-request-InputDataConfig)": [ 
    { 
        "[ChannelName](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_Channel.html#sagemaker-Type-Channel-ChannelName)": "{{<your_channel_name>}}",
        "[DataSource](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_Channel.html#sagemaker-Type-Channel-DataSource)": { 
            "[S3DataSource](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_DataSource.html#sagemaker-Type-DataSource-S3DataSource)": { 
                "[S3DataDistributionType](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_S3DataSource.html#sagemaker-Type-S3DataSource-S3DataDistributionType)": "FullyReplicated",
                "[S3DataType](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_S3DataSource.html#sagemaker-Type-S3DataSource-S3DataType)": "S3Prefix",
                "[S3Uri](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_S3DataSource.html#sagemaker-Type-S3DataSource-S3Uri)": "s3://{{<bucket-name>}}/{{<bucket_prefix>}}"
            }
        },
        "[InputMode](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_Channel.html#sagemaker-Type-Channel-InputMode)": "File",
    },
    ...]
}
```

Em seguida, execute o AWS CLI comando para iniciar o trabalho de treinamento a partir do arquivo JSON da seguinte maneira.

```
aws sagemaker create-training-job --cli-input-json file:{{//run-my-training-job.json}}
```

#### Configure o canal de dados de entrada usando AWS CLI diretamente
<a name="your-algorithms-training-algo-dockerfile-script-s3-directly"></a>

Para configurar seu canal de dados de entrada sem um arquivo JSON, use a estrutura de AWS CLI código a seguir.

```
aws --region {{<your-region>}} sagemaker create-training-job \
--training-job-name {{<your-training-job-name>}} \
--role-arn {{<your-execution-role-arn>}} \
--algorithm-specification '{ \
    "TrainingInputMode": "File", \
    "TrainingImage": "{{<your-ecr-image>}}", \
    "ContainerEntrypoint": ["{{/bin/sh}}"], \
    "ContainerArguments": ["{{/opt/ml/input/data/<your_channel_name>/custom_entrypoint.sh"]}}}' \
--input-data-config '[{ \
    "ChannelName":"{{<your_channel_name>}}", \
    "DataSource":{ \
        "S3DataSource":{ \
            "S3DataType":"S3Prefix", \
            "S3Uri":"s3://{{<bucket-name>}}/{{<bucket_prefix>}}", \
            "S3DataDistributionType":"FullyReplicated"}}}]' \
--output-data-config '{"S3OutputPath": "{{s3://custom-entrypoint-output-bucket/}}"}' \
--resource-config '{"VolumeSizeInGB":{{10}},"InstanceCount":{{1}},"InstanceType":"{{ml.m5.2xlarge}}"}' \
--stopping-condition '{"MaxRuntimeInSeconds": {{180}}}'
```