Como adaptar o próprio contêiner de treinamento - Amazon SageMaker
Etapa 1: criar uma instância de cadernosEtapa 2: criar e carregar scripts de treinamentoEtapa 3: Definir o contêinerEtapa 4: testar o contêinerEtapa 5: enviar o contêiner para o Amazon ECREtapa 6: limpar os recursosBlogs e estudos de caso

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 por meio de uma instância de SageMaker notebook da Amazon.

Etapa 1: criar uma instância de SageMaker notebook

  1. Abra o SageMaker console da Amazon em https://console.aws.amazon.com/sagemaker/.

  2. No painel de navegação, escolha Caderno, e depois Instâncias do caderno e selecione Criar instância de cadernos.

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

    2. Em Notebook Instance type (Tipo de instância de bloco de anotações), escolha ml.t2.medium.

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

      2. 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 cria uma função do IAM chamadaAmazonSageMaker-ExecutionRole-YYYYMMDDTHHmmSS. 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.

    4. Para Acesso raiz, escolha Habilitar.

    5. Escolha Create notebook instance (Criar instância de bloco de anotações).

  4. Na página de Instâncias de cadernos, o status é Pendente. Pode levar alguns minutos para SageMaker a Amazon lançar uma instância computacional de aprendizado de máquina — nesse caso, ela lança uma instância de notebook — e anexa 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.

  5. Clique no Nome do caderno que você acabou de criar. Essa ação abre uma nova página.

  6. 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'

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

  2. Crie um arquivo de texto Dockerfile no diretório docker_test_folder.

    1. Escolha o ícone Novo inicializador (+) no canto superior esquerdo.

    2. No painel à direita, na seção Outro, selecione Arquivo de texto.

    3. 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 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 você queira 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 SageMaker treinamento que contém a funcionalidade comum necessária para criar um contêiner compatível com o. SageMaker

      • COPY train.py /opt/ml/code/train.py— Copia o script para o local dentro do contêiner que é esperado pelo SageMaker. 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.

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

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

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

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

  2. Cole o script de exemplo a seguir na célula de código do notebook para configurar um SageMaker Estimador.

    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 SageMaker sessão. 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'.

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

    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 ContainerRegistryFullAccess política do AmazonEC2 à sua função do IAM. Acesse o console do IAM, escolha Funções no painel de navegação esquerdo e procure a função do IAM que você usou para a instância de blocos de anotações. Na guia Permissão, escolha o botão Anexar políticas e pesquise a política do AmazonEC2 ContainerRegistryFullAccess. Marque a caixa de seleção da política e escolha Adicionar permissões para concluir.

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

  3. Use o ecr_image recuperado da etapa anterior para configurar um objeto SageMaker estimador. O exemplo de código a seguir configura um SageMaker estimador 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()

  4. Se quiser implantar seu modelo usando seu próprio contêiner, consulte Como adaptar o próprio contêiner de inferência. 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 bloco de anotações que você usou para treinar seu modelo na subetapa anterior para obter os URIs da imagem (identificadores de recursos universais) necessários 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.

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 ter mais informações, consulte Use o Depurador com contêineres de treinamento personalizados.

Etapa 6: limpar os recursos

Para limpar recursos quando terminar com o exemplo de introdução

  1. Abra o SageMaker console, escolha a instância do notebook RunScriptNotebookInstance, escolha Ações e escolha Parar. Pode demorar alguns minutos para que a instância pare.

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

  3. Abra o console do Amazon S3 e exclua o bucket criado para armazenar artefatos do modelo e o conjunto de dados de treinamento.

  4. Abra o console do 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.