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 adaptar o próprio contêiner de treinamento
Para executar seu próprio modelo de treinamento, crie um contêiner Docker usando o [Amazon SageMaker Training Toolkit](https://github.com/aws/sagemaker-training-toolkit) por meio de uma instância de SageMaker notebook da Amazon.
## Etapa 1: criar uma instância de SageMaker notebook
1. Abra o console Amazon SageMaker AI em [https://console.aws.amazon.com/sagemaker/](https://console.aws.amazon.com/sagemaker/).
1. No painel de navegação, escolha **Caderno**, e depois **Instâncias do caderno** e selecione **Criar instância de cadernos**.
1. Na página **Create notebook instance (Criar instância de bloco de anotações)**, forneça as seguintes informações:
1. Para **Notebook instance name (Nome da instância de bloco de anotações)**, insira **RunScriptNotebookInstance**.
1. Em **Notebook Instance type (Tipo de instância de bloco de anotações)**, escolha **ml.t2.medium**.
1. Na seção **Permissões e criptografia)** e faça o seguinte:
1. Em **Perfil do IAM**, selecione **Criar uma nova função**. Essa ação abre uma nova janela.
1. Na página **Criar uma função do IAM**, escolha **Buckets do S3 específicos**, especifique um bucket do S3 chamado **sagemaker-run-script** e escolha **Criar função**.
SageMaker A IA cria uma função do IAM chamada`AmazonSageMaker-ExecutionRole-{{YYYYMMDD}}T{{HHmmSS}}`. Por exemplo, .`AmazonSageMaker-ExecutionRole-20190429T110788` Observe que a convenção de nome da função de execução usa a data e hora em que a função foi criada, separada por um `T`.
1. Para **Acesso raiz**, escolha **Habilitar**.
1. Escolha **Create notebook instance (Criar instância de bloco de anotações)**.
1. Na página de **Instâncias de cadernos**, o **status** é **Pendente**. Pode levar alguns minutos para que a Amazon SageMaker AI lance uma instância de computação de aprendizado de máquina — nesse caso, ela lança uma instância de notebook — e anexe um volume de armazenamento de ML a ela. A instância de caderno conta com a pré-configuração de um servidor de cadernos Jupyter e de um conjunto de bibliotecas da Anaconda. Para obter mais informações, consulte [ CreateNotebookInstance](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_CreateNotebookInstance.html).
1. Clique no **Nome** do caderno que você acabou de criar. Essa ação abre uma nova página.
1. Na seção **Permissões e criptografia**, copie **o número ARN da função do IAM** e cole-o em um arquivo dos cadernos para salvá-lo temporariamente. Posteriormente, você usa esse número ARN da função do IAM para configurar um estimador de treinamento local na instância de cadernos. **The IAM role ARN number (O número do ARN da função do IAM) ** é semelhante ao seguinte: `'arn:aws:iam::111122223333:role/service-role/AmazonSageMaker-ExecutionRole-20190429T110788'`
1. Depois que o status da instância do notebook mudar para **InService**, escolha **Abrir JupyterLab**.
## Etapa 2: criar e carregar o Dockerfile e os scripts de treinamento do Python
1. Depois de JupyterLab abrir, crie uma nova pasta no diretório inicial do seu JupyterLab. No canto superior esquerdo, escolha o ícone **Nova pasta** e insira o nome da pasta `docker_test_folder`.
1. Crie um arquivo de texto `Dockerfile` no diretório `docker_test_folder`.
1. Escolha o ícone **Novo inicializador** (\+) no canto superior esquerdo.
1. No painel à direita, na seção **Outro**, selecione **Arquivo de texto**.
1. Cole o código de amostra `Dockerfile` a seguir no seu arquivo de texto.
```
#Download an open source TensorFlow Docker image
FROM tensorflow/tensorflow:latest-gpu-jupyter
# Install sagemaker-training toolkit that contains the common functionality necessary to create a container compatible with SageMaker AI and the Python SDK.
RUN pip3 install sagemaker-training
# Copies the training code inside the container
COPY train.py /opt/ml/code/train.py
# Defines train.py as script entrypoint
ENV SAGEMAKER_PROGRAM train.py
```
O script do Dockerfile executa as seguintes tarefas:
+ `FROM tensorflow/tensorflow:latest-gpu-jupyter`— Faz o download da imagem base mais recente TensorFlow do Docker. Você pode substituí-la por qualquer imagem base do Docker que quiser trazer para criar contêineres, bem como por imagens base de contêineres AWS pré-criadas.
+ `RUN pip install sagemaker-training`— Instala o [kit de ferramentas de treinamento de SageMaker IA](https://github.com/aws/sagemaker-training-toolkit) que contém a funcionalidade comum necessária para criar um contêiner compatível com SageMaker IA.
+ `COPY train.py /opt/ml/code/train.py`— Copia o script para o local dentro do contêiner que é esperado pela SageMaker IA. O script deve estar localizado nessa pasta.
+ `ENV SAGEMAKER_PROGRAM train.py`: toma seu script de treinamento `train.py` como o script do ponto de entrada copiado na pasta do `/opt/ml/code` do contêiner. Essa é a única variável de ambiente que você deve especificar quando está criando o próprio contêiner.
1. Na navegação do diretório à esquerda, o nome do arquivo de texto pode ser definido automaticamente como `untitled.txt`. Para renomear o arquivo, clique com o botão direito do mouse no arquivo, escolha **Renomear**, renomeie o arquivo como `Dockerfile` sem a extensão `.txt` e pressione `Ctrl+s` ou `Command+s` para salvar o arquivo.
1. Carregue um script de treinamento `train.py` para `docker_test_folder`. Você pode usar o script de exemplo a seguir para criar um modelo que lê dígitos manuscritos treinados no [conjunto de dados MNIST](https://en.wikipedia.org/wiki/MNIST_database) para este exercício.
```
import tensorflow as tf
import os
mnist = tf.keras.datasets.mnist
(x_train, y_train), (x_test, y_test) = mnist.load_data()
x_train, x_test = x_train / 255.0, x_test / 255.0
model = tf.keras.models.Sequential([
tf.keras.layers.Flatten(input_shape=(28, 28)),
tf.keras.layers.Dense(128, activation='relu'),
tf.keras.layers.Dropout(0.2),
tf.keras.layers.Dense(10, activation='softmax')
])
model.compile(optimizer='adam',
loss='sparse_categorical_crossentropy',
metrics=['accuracy'])
model.fit(x_train, y_train, epochs=1)
model_save_dir = f"{os.environ.get('SM_MODEL_DIR')}/1"
model.evaluate(x_test, y_test)
tf.saved_model.save(model, model_save_dir)
```
## Etapa 3: construir o contêiner
1. No diretório JupyterLab inicial, abra um notebook Jupyter. Para abrir um novo bloco de anotações, escolha o ícone **Nova execução** e, em seguida, escolha a versão mais recente do **conda\_tensorflow2** na seção **Caderno**.
1. Execute o comando a seguir na primeira célula do bloco de anotações para mudar para o diretório `docker_test_folder`:
```
cd ~/SageMaker/docker_test_folder
```
Isso retorna o diretório atual da seguinte forma:
```
! pwd
```
`output: /home/ec2-user/SageMaker/docker_test_folder`
1. Para criar o contêiner do Docker, execute o seguinte comando de criação do Docker, incluindo o espaço seguido de um ponto final.
```
! docker build -t tf-custom-container-test .
```
O comando de criação do Docker deve ser executado no diretório que você criou, neste caso, o `docker_test_folder`.
**nota**
Se você receber a mensagem de erro a seguir informando que o Docker não consegue encontrar o Dockerfile, verifique se o Dockerfile tem o nome correto e foi salvo no diretório.
```
unable to prepare context: unable to evaluate symlinks in Dockerfile path:
lstat /home/ec2-user/SageMaker/docker/Dockerfile: no such file or directory
```
Lembre-se de que `docker` procura um arquivo chamado especificamente `Dockerfile` sem nenhuma extensão no diretório atual. Se você deu outro nome, poderá transmitir o nome de arquivo manualmente com a bandeira `-f`. Por exemplo, se você nomeou o Dockerfile como `Dockerfile-text.txt`, execute o seguinte comando:
```
! docker build -t tf-custom-container-test -f Dockerfile-text.txt .
```
## Etapa 4: testar o contêiner
1. Para testar o contêiner localmente para a instância de blocos de anotações, abra um bloco de anotações Jupyter. Escolha **Novo inicializador** e escolha a versão mais recente do **conda\_tensorflow2** na seção **Bloco de anotações**.
1. Cole o script de exemplo a seguir na célula de código do notebook para configurar um Estimador de SageMaker IA.
```
import sagemaker
from sagemaker.estimator import Estimator
estimator = Estimator(image_uri='{{tf-custom-container-test}}',
role={{sagemaker.get_execution_role()}},
instance_count={{1}},
instance_type={{'local'}})
estimator.fit()
```
No exemplo de código anterior, `sagemaker.get_execution_role()` é especificado para o `role` argumento recuperar automaticamente a função configurada para a sessão de SageMaker IA. Você também pode substituí-lo pelo valor da string do **número ARN da função do IAM** que você usou ao configurar a instância de bloco de anotações. O Nome de região da Amazon (ARN) deve se parecer com o seguinte: `'arn:aws:iam::111122223333:role/service-role/AmazonSageMaker-ExecutionRole-20190429T110788'`.
1. Execute a célula de código. Esse teste mostra a configuração do ambiente de treinamento, os valores usados para as variáveis de ambiente, a fonte dos dados e a perda e precisão obtidas durante o treinamento.
## Etapa 5: enviar o contêiner para o Amazon Elastic Container Registry (Amazon ECR)
1. Depois de executar com êxito este teste de modo local, você pode enviar a imagem para o [Amazon ECR](https://docs.aws.amazon.com/AmazonECR/latest/userguide/what-is-ecr.html) e usá-la para executar trabalhos de treinamento. Se você quiser usar um registro privado do Docker em vez do Amazon ECR, consulte [Enviar seu contêiner de treinamento para um registro privado](https://docs.aws.amazon.com/sagemaker/latest/dg/docker-containers-adapt-your-own-private-registry.html).
Execute as linhas de comandos a seguir em uma célula do bloco de anotações.
```
%%sh
# Specify an algorithm name
algorithm_name=tf-custom-container-test
account=$(aws sts get-caller-identity --query Account --output text)
# Get the region defined in the current configuration (default to us-west-2 if none defined)
region=$(aws configure get region)
region=${region:-us-west-2}
fullname="${account}.dkr.ecr.${region}.amazonaws.com/${algorithm_name}:latest"
# If the repository doesn't exist in ECR, create it.
aws ecr describe-repositories --repository-names "${algorithm_name}" > /dev/null 2>&1
if [ $? -ne 0 ]
then
aws ecr create-repository --repository-name "${algorithm_name}" > /dev/null
fi
# Get the login command from ECR and execute it directly
aws ecr get-login-password --region ${region}|docker login --username AWS --password-stdin ${fullname}
# Build the docker image locally with the image name and then push it to ECR
# with the full name.
docker build -t ${algorithm_name} .
docker tag ${algorithm_name} ${fullname}
docker push ${fullname}
```
**nota**
Esse script de shell pode gerar um problema de permissão semelhante à seguinte mensagem de erro:
```
"denied: User: [ARN] is not authorized to perform: ecr:InitiateLayerUpload on resource:
arn:aws:ecr:us-east-1:[id]:repository/tf-custom-container-test"
```
Se esse erro ocorrer, você precisará anexar a EC2 ContainerRegistryFullAccess política da **Amazon** à sua função do IAM. Acesse o [console do IAM](https://console.aws.amazon.com/iam/home), escolha **Roles** no painel de navegação esquerdo e procure o IAMrole que você usou para a instância do Notebook. Na guia **Permissão**, escolha o botão **Anexar políticas** e pesquise a EC2 ContainerRegistryFullAccess política da **Amazon**. Marque a caixa de seleção da política e escolha **Adicionar permissões** para concluir.
1. Execute o código a seguir em uma célula do bloco de anotações do Studio para chamar a imagem do Amazon ECR do seu contêiner de treinamento.
```
import boto3
account_id = boto3.client('sts').get_caller_identity().get('Account')
ecr_repository = 'tf-custom-container-test'
tag = ':latest'
region = boto3.session.Session().region_name
uri_suffix = 'amazonaws.com'
if region in ['cn-north-1', 'cn-northwest-1']:
uri_suffix = 'amazonaws.com.cn'
byoc_image_uri = '{}.dkr.ecr.{}.{}/{}'.format(account_id, region, uri_suffix, ecr_repository + tag)
byoc_image_uri
# This should return something like
# 111122223333.dkr.ecr.us-east-2.amazonaws.com/sagemaker-byoc-test:latest
```
1. Use o `ecr_image` recuperado da etapa anterior para configurar um objeto estimador de SageMaker IA. O exemplo de código a seguir configura um estimador de SageMaker IA com o `byoc_image_uri` e inicia um trabalho de treinamento em uma instância do Amazon EC2.
------
#### [ SageMaker Python SDK v1 ]
```
import sagemaker
from sagemaker import get_execution_role
from sagemaker.estimator import Estimator
estimator = Estimator(image_uri=byoc_image_uri,
role=get_execution_role(),
base_job_name='tf-custom-container-test-job',
instance_count=1,
instance_type='ml.g4dn.xlarge')
#train your model
estimator.fit()
```
------
#### [ SageMaker Python SDK v2 ]
```
import sagemaker
from sagemaker import get_execution_role
from sagemaker.estimator import Estimator
estimator = Estimator(image_uri=byoc_image_uri,
role=get_execution_role(),
base_job_name='tf-custom-container-test-job',
instance_count=1,
instance_type='ml.g4dn.xlarge')
#train your model
estimator.fit()
```
------
1. Se quiser implantar seu modelo usando seu próprio contêiner, consulte [Como adaptar o próprio contêiner de inferência](https://docs.aws.amazon.com/sagemaker/latest/dg/adapt-inference-container.html). Você também pode usar um contêiner de AWS estrutura que pode implantar um TensorFlow modelo. Para implantar o modelo de exemplo para ler dígitos manuscritos, insira o script de exemplo a seguir no mesmo caderno que você usou para treinar seu modelo na subetapa anterior para obter a imagem URIs (identificadores de recursos universais) necessária para a implantação e implantar o modelo.
```
import boto3
import sagemaker
#obtain image uris
from sagemaker import image_uris
container = image_uris.retrieve(framework='tensorflow',region='us-west-2',version='2.11.0',
image_scope='inference',instance_type='ml.g4dn.xlarge')
#create the model entity, endpoint configuration and endpoint
predictor = estimator.deploy(1,instance_type='ml.g4dn.xlarge',image_uri=container)
```
Teste o modelo usando um exemplo de dígito manuscrito do conjunto de dados MNIST usando o exemplo de código a seguir.
```
#Retrieve an example test dataset to test
import numpy as np
import matplotlib.pyplot as plt
from keras.datasets import mnist
# Load the MNIST dataset and split it into training and testing sets
(x_train, y_train), (x_test, y_test) = mnist.load_data()
# Select a random example from the training set
example_index = np.random.randint(0, x_train.shape[0])
example_image = x_train[example_index]
example_label = y_train[example_index]
# Print the label and show the image
print(f"Label: {example_label}")
plt.imshow(example_image, cmap='gray')
plt.show()
```
Converta o dígito manuscrito do teste em um formulário que TensorFlow possa ser ingerido e fazer uma previsão do teste.
```
from sagemaker.serializers import JSONSerializer
data = {"instances": example_image.tolist()}
predictor.serializer=JSONSerializer() #update the predictor to use the JSONSerializer
predictor.predict(data) #make the prediction
```
Para ver um exemplo completo que mostra como testar um contêiner personalizado localmente e enviá-lo para uma imagem do Amazon ECR, consulte o exemplo de caderno [Building Your Own TensorFlow Container](https://sagemaker-examples.readthedocs.io/en/latest/advanced_functionality/tensorflow_bring_your_own/tensorflow_bring_your_own.html).
**dica**
Para traçar o perfil e depurar trabalhos de treinamento para monitorar problemas de utilização do sistema (como gargalos da CPU e subutilização da GPU) e identificar problemas de treinamento (como sobreajuste, excesso de treinamento, explosão de tensores e gradientes que diminuem), use o Amazon Debugger. SageMaker Para obter mais informações, consulte [Use o Depurador com contêineres de treinamento personalizados](debugger-bring-your-own-container.md).
## Etapa 6: limpar os recursos
**Para limpar recursos quando terminar com o exemplo de introdução**
1. Abra o [console de SageMaker IA](https://console.aws.amazon.com/sagemaker/), escolha a instância do notebook **RunScriptNotebookInstance**, escolha **Ações** e escolha **Parar**. Pode demorar alguns minutos para que a instância pare.
1. Depois que o **status** da instância mudar para **Interrompido**, escolha **Ações**, escolha **Excluir** e, em seguida, escolha **Excluir** na caixa de diálogo. Pode demorar alguns minutos para a exclusão da instância. A instância dos blocos de anotações desaparece da tabela quando é excluída.
1. Abra o [console do Amazon S3](https://console.aws.amazon.com/s3/) e exclua o bucket criado para armazenar artefatos do modelo e o conjunto de dados de treinamento.
1. Abra o [console do IAM](https://console.aws.amazon.com/iam/) e exclua a função do IAM. Se você criou políticas de permissões, poderá excluí-las também.
**nota**
O contêiner do Docker é desligado automaticamente depois de ser executado. Você não precisa excluí-lo.
## Blogs e estudos de caso
Os blogs a seguir discutem estudos de caso sobre o uso de contêineres de treinamento personalizados na Amazon SageMaker AI.
+ [Por que trazer seu próprio contêiner para a Amazon SageMaker AI e como fazer isso da maneira certa](https://medium.com/@pandey.vikesh/why-bring-your-own-container-to-amazon-sagemaker-and-how-to-do-it-right-bc158fe41ed1), *Medium* (20 de janeiro de 2023)