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á. # Contêineres Docker personalizados com IA SageMaker Você pode adaptar uma imagem existente do Docker para trabalhar com SageMaker IA. Talvez seja necessário usar uma imagem externa existente do Docker com SageMaker IA quando tiver um contêiner que atenda aos requisitos de recursos ou de segurança que atualmente não são suportados por uma imagem de IA pré-criada SageMaker . Há dois kits de ferramentas que permitem que você traga seu próprio contêiner e o adapte para funcionar com SageMaker IA: + [SageMaker Kit de ferramentas de treinamento](https://github.com/aws/sagemaker-training-toolkit) — Use esse kit de ferramentas para treinar modelos com SageMaker IA. + [SageMaker Kit de ferramentas de inferência de IA](https://github.com/aws/sagemaker-inference-toolkit) — Use esse kit de ferramentas para implantar modelos com IA. SageMaker Os tópicos a seguir mostram como adaptar sua imagem existente usando os kits de ferramentas SageMaker de treinamento e inferência: **Topics** + [Bibliotecas de estrutura individuais](#docker-containers-adapt-your-own-frameworks) + [SageMaker Kits de ferramentas de treinamento e inferência](amazon-sagemaker-toolkits.md) + [Como adaptar o próprio contêiner de treinamento](adapt-training-container.md) + [Adapte seu próprio contêiner de inferência para a Amazon AI SageMaker](adapt-inference-container.md) ## Bibliotecas de estrutura individuais Além do kit de ferramentas de SageMaker treinamento e do kit de ferramentas de inferência de SageMaker IA, a SageMaker IA também fornece kits de ferramentas especializados para TensorFlow, MXNet, PyTorch e Chainer. A tabela a seguir fornece links para os GitHub repositórios que contêm o código-fonte de cada estrutura e seus respectivos kits de ferramentas de serviço. As instruções vinculadas são para usar o SDK do Python para executar algoritmos de treinamento e hospedar modelos na IA. SageMaker A funcionalidade dessas bibliotecas individuais está incluída no SageMaker AI Training Toolkit e no SageMaker AI Inference Toolkit. | Framework | Código-fonte do kit de ferramentas | | --- | --- | | TensorFlow | [SageMaker TensorFlow Treinamento de IA](https://github.com/aws/sagemaker-tensorflow-training-toolkit) [SageMaker TensorFlow Servidor de IA](https://github.com/aws/sagemaker-tensorflow-serving-container) | | MXNet | [SageMaker MXNet Treinamento de IA](https://github.com/aws/sagemaker-mxnet-training-toolkit) [SageMaker MXNet Inferência de IA](https://github.com/aws/sagemaker-mxnet-inference-toolkit) | | PyTorch | [SageMaker PyTorch Treinamento de IA](https://github.com/aws/sagemaker-pytorch-training-toolkit) [SageMaker PyTorch Inferência de IA](https://github.com/aws/sagemaker-pytorch-inference-toolkit) | | Chainer | [SageMaker Contêineres AI Chainer SageMaker ](https://github.com/aws/sagemaker-chainer-container) | # SageMaker Kits de ferramentas de treinamento e inferência Os kits de ferramentas de [SageMaker treinamento](https://github.com/aws/sagemaker-training-toolkit) e [inferência de SageMaker IA](https://github.com/aws/sagemaker-inference-toolkit) implementam a funcionalidade de que você precisa para adaptar seus contêineres para executar scripts, treinar algoritmos e implantar modelos em SageMaker IA. Quando instalada, a biblioteca define o seguinte para os usuários: + Os locais para armazenar código e outros recursos. + O ponto de entrada que contém o código a ser executado quando o contêiner é iniciado. Seu Dockerfile deve copiar o código que precisa ser executado no local esperado por um contêiner compatível com SageMaker IA. + Outras informações que um contêiner precisa a fim de gerenciar implantações para treinamento e inferência. ## SageMaker Estrutura de contêineres de kits de ferramentas AI Quando a SageMaker IA treina um modelo, ela cria a seguinte estrutura de pastas de arquivos no `/opt/ml` diretório do contêiner. ``` /opt/ml ├── input │ ├── config │ │ ├── hyperparameters.json │ │ └── resourceConfig.json │ └── data │ └── │ └── ├── model │ ├── code │ ├── output │ └── failure ``` Quando você executa um trabalho de *treinamento* de modelo, o contêiner de SageMaker IA usa o `/opt/ml/input/` diretório, que contém os arquivos JSON que configuram os hiperparâmetros do algoritmo e o layout de rede usado para treinamento distribuído. O `/opt/ml/input/` diretório também contém arquivos que especificam os canais pelos quais a SageMaker IA acessa os dados, que são armazenados no Amazon Simple Storage Service (Amazon S3). A biblioteca de contêineres de SageMaker IA coloca os scripts que o contêiner executará no `/opt/ml/code/` diretório. O script deve gravar o modelo gerado pelo algoritmo no diretório `/opt/ml/model/`. Para obter mais informações, consulte [Contêineres com algoritmos de treinamento personalizados](your-algorithms-training-algo.md). Quando você *hospeda* um modelo treinado em SageMaker IA para fazer inferências, você implanta o modelo em um endpoint HTTP. O modelo faz previsões em tempo real como resposta às solicitações de inferência. O contêiner deve conter uma pilha de serviços para processar essas solicitações. Em um contêiner de hospedagem ou de transformação em lote, os arquivos do modelo estão localizados na mesma pasta em que estavam gravados durante o treinamento. ``` /opt/ml/model │ └── ``` Para obter mais informações, consulte [Contêineres com código de inferência personalizado](your-algorithms-inference-main.md). ## Contêineres únicos versus múltiplos É possível fornecer imagens do Docker separadas para o algoritmo de treinamento e código de inferência ou usá-las em uma única imagem do Docker para ambas. Ao criar imagens do Docker para uso com SageMaker IA, considere o seguinte: + Fornecer duas imagens do Docker pode aumentar os requisitos de armazenamento e o custo, pois bibliotecas comuns podem ser duplicadas. + Em geral, os contêineres menores são iniciados mais rapidamente para treinamento e hospedagem. Os modelos são treinados mais rapidamente, e o serviço de hospedagem pode reagir a aumentos no tráfego expandindo automaticamente com mais agilidade. + Talvez seja possível gravar um contêiner de inferência significativamente menor que o contêiner de treinamento. Isso é especialmente comum quando você usa GPUs para treinamento, mas seu código de inferência é otimizado para CPUs. + SageMaker A IA exige que os contêineres do Docker sejam executados sem acesso privilegiado. + Tanto os contêineres do Docker que você cria quanto os fornecidos pela SageMaker IA podem enviar mensagens para os `Stderr` arquivos `Stdout` e. SageMaker A IA envia essas mensagens para CloudWatch os registros da Amazon em sua AWS conta. Para obter mais informações sobre como criar contêineres de SageMaker IA e como os scripts são executados dentro deles, consulte os repositórios do [SageMaker AI Training Toolkit](https://github.com/aws/sagemaker-training-toolkit) e do [SageMaker AI Inference Toolkit](https://github.com/aws/sagemaker-inference-toolkit) em. GitHub Eles também fornecem listas de variáveis ambientais importantes e as variáveis ambientais fornecidas pelos contêineres de SageMaker IA. # 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-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`. 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** (\$1) 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\$1tensorflow2** 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\$1tensorflow2** 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) # Adapte o trabalho de treinamento para acessar as imagens em um registro privado do Docker Você pode usar um [registro privado do Docker](https://docs.docker.com/registry/) em vez de um Amazon Elastic Container Registry (Amazon ECR) para hospedar suas imagens para treinamento de IA. SageMaker As instruções a seguir mostram como criar um registro do Docker, configurar sua nuvem privada virtual (VPC) e seu trabalho de treinamento, armazenar imagens e SageMaker dar à IA acesso à imagem de treinamento no registro privado do docker. Essas instruções também mostram como usar um registro do Docker que requer autenticação para um trabalho de SageMaker treinamento. ## Criar e armazenar as imagens em um registro Docker privado Criar um registro Docker privado para armazenar as imagens. Seu registro deve: + usar o protocolo [API HTTP de registro do Docker](https://docs.docker.com/registry/spec/api/) + ser acessível a partir da mesma VPC especificada no [VpcConfig](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_CreateTrainingJob.html#API_CreateTrainingJob_RequestSyntax)parâmetro na `CreateTrainingJob` API. Insira `VpcConfig` ao criar o trabalho de treinamento. + protegido com um [certificado TLS](https://aws.amazon.com/what-is/ssl-certificate/) de uma autoridade de certificação pública conhecida. Para obter mais informações sobre como criar um registro do Docker, consulte [Como implantar um servidor de registro](https://docs.docker.com/registry/deploying/). ## Configure sua VPC e SageMaker seu trabalho de treinamento SageMaker A IA usa uma conexão de rede em sua VPC para acessar imagens em seu registro do Docker. Para usar as imagens no registro do Docker para treinamento, o registro deve estar acessível em uma Amazon VPC na sua conta. Para obter mais informações, consulte [Use um registro do Docker que exija autenticação para treinamento](docker-containers-adapt-your-own-private-registry-authentication.md). Você também deve configurar o trabalho de treinamento para se conectar à mesma VPC à qual seu registro do Docker tem acesso. Para obter mais informações, consulte [Configurar um trabalho de treinamento para acesso ao Amazon VPC ](https://docs.aws.amazon.com/sagemaker/latest/dg/train-vpc.html#train-vpc-configure). ## Crie um trabalho de treinamento usando uma imagem do seu registro privado do Docker Para usar uma imagem do seu registro privado do Docker para treinamento, use o guia a seguir para configurar a imagem, configurar e criar um trabalho de treinamento. Os exemplos de código a seguir usam o AWS SDK para Python (Boto3) cliente. 1. Crie um objeto de configuração de imagem de treinamento e insira `Vpc`, o campo `TrainingRepositoryAccessMode` da seguinte forma. ``` training_image_config = { 'TrainingRepositoryAccessMode': 'Vpc' } ``` **nota** Se seu registro privado do Docker exigir autenticação, você deverá adicionar um objeto `TrainingRepositoryAuthConfig` ao objeto de configuração da imagem de treinamento. Você também deve especificar o Amazon Resource Name (ARN) de uma AWS Lambda função que fornece credenciais de acesso à SageMaker IA usando o `TrainingRepositoryCredentialsProviderArn` campo do objeto. `TrainingRepositoryAuthConfig` Para obter mais informações, consulte a estrutura de código de exemplo a seguir. ``` training_image_config = { 'TrainingRepositoryAccessMode': 'Vpc', 'TrainingRepositoryAuthConfig': { 'TrainingRepositoryCredentialsProviderArn': 'arn:aws:lambda:Region:Acct:function:FunctionName' } } ``` Para obter informações sobre como criar a função do Lambda para fornecer autenticação, consulte [Use um registro do Docker que exija autenticação para treinamento](docker-containers-adapt-your-own-private-registry-authentication.md). 1. Use um cliente Boto3 para criar um trabalho de treinamento e passar a configuração correta para a API [create\$1training\$1job](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_CreateTrainingJob.html). As instruções a seguir mostram como configurar os componentes e criar um trabalho de treinamento. 1. Crie o objeto `AlgorithmSpecification` que você deseja passar para `create_training_job`. Use o objeto de configuração da imagem de treinamento criado na etapa anterior, conforme exibido no seguinte exemplo de código. ``` algorithm_specification = { 'TrainingImage': 'myteam.myorg.com/docker-local/my-training-image:', 'TrainingImageConfig': training_image_config, 'TrainingInputMode': 'File' } ``` **nota** Para usar uma versão fixa, em vez de uma versão atualizada de uma imagem, consulte o [resumo](https://docs.docker.com/engine/reference/commandline/pull/#pull-an-image-by-digest-immutable-identifier) da imagem em vez de usar o nome ou a tag. 1. Especifique o nome do trabalho de treinamento e da função para a qual deseja passar para `create_training_job`, conforme mostrado no seguinte exemplo de código. ``` training_job_name = 'private-registry-job' execution_role_arn = 'arn:aws:iam::123456789012:role/SageMakerExecutionRole' ``` 1. Especifique um grupo de segurança e uma sub-rede para a configuração da VPC para o trabalho de treinamento. Seu registro privado do Docker deve permitir o tráfego de entrada dos grupos de segurança que você especificar, conforme mostrado no exemplo de código a seguir. ``` vpc_config = { 'SecurityGroupIds': ['sg-0123456789abcdef0'], 'Subnets': ['subnet-0123456789abcdef0','subnet-0123456789abcdef1'] } ``` **nota** Se sua sub-rede não estiver na mesma VPC que seu registro privado do Docker, você deverá configurar uma conexão de rede entre as duas. VPCs SeeConnect VPCs usando o [peering de VPC](https://docs.aws.amazon.com/vpc/latest/userguide/vpc-peering.html) para obter mais informações. 1. Especifique a configuração de recursos, incluindo instâncias de computação de machine learning e volumes de armazenamento a serem usados para treinamento, conforme mostrado no exemplo de código a seguir. ``` resource_config = { 'InstanceType': 'ml.m4.xlarge', 'InstanceCount': 1, 'VolumeSizeInGB': 10, } ``` 1. Especifique a configuração dos dados de entrada e saída, onde o conjunto de dados de treinamento é armazenado e onde você deseja armazenar os artefatos do modelo, conforme mostrado no exemplo de código a seguir. ``` input_data_config = [ { "ChannelName": "training", "DataSource": { "S3DataSource": { "S3DataDistributionType": "FullyReplicated", "S3DataType": "S3Prefix", "S3Uri": "s3://your-training-data-bucket/training-data-folder" } } } ] output_data_config = { 'S3OutputPath': 's3://your-output-data-bucket/model-folder' } ``` 1. Especifique o número máximo de segundos que um trabalho de treinamento de modelo pode ser executado, conforme mostrado no exemplo de código a seguir. ``` stopping_condition = { 'MaxRuntimeInSeconds': 1800 } ``` 1. Por fim, crie o trabalho de treinamento usando os parâmetros especificados nas etapas anteriores, conforme exibido no seguinte exemplo de código. ``` import boto3 sm = boto3.client('sagemaker') try: resp = sm.create_training_job( TrainingJobName=training_job_name, AlgorithmSpecification=algorithm_specification, RoleArn=execution_role_arn, InputDataConfig=input_data_config, OutputDataConfig=output_data_config, ResourceConfig=resource_config, VpcConfig=vpc_config, StoppingCondition=stopping_condition ) except Exception as e: print(f'error calling CreateTrainingJob operation: {e}') else: print(resp) ``` # Use um estimador de SageMaker IA para executar um trabalho de treinamento Você também pode usar um [estimador](https://sagemaker.readthedocs.io/en/stable/api/training/estimators.html) do SDK do SageMaker Python para lidar com a configuração e a execução do seu trabalho de treinamento. SageMaker Os exemplos de código a seguir mostram como configurar e executar um estimador usando imagens de um registro particular do Docker. 1. Importe as bibliotecas e dependências necessárias, conforme exibido no seguinte exemplo de código. ``` import boto3 import sagemaker from sagemaker.estimator import Estimator session = sagemaker.Session() role = sagemaker.get_execution_role() ``` 1. Forneça um Identificador de recursos uniforme (Uniform Resource Identifier, URI) para a imagem de treinamento, grupos de segurança e sub-redes para a configuração da VPC para o trabalho de treinamento, conforme mostrado no exemplo de código a seguir. ``` image_uri = "myteam.myorg.com/docker-local/my-training-image:" security_groups = ["sg-0123456789abcdef0"] subnets = ["subnet-0123456789abcdef0", "subnet-0123456789abcdef0"] ``` Para obter mais informações sobre `security_group_ids` e`subnets`, consulte a descrição apropriada do parâmetro na seção [Estimadores](https://sagemaker.readthedocs.io/en/stable/api/training/estimators.html) do SDK para Python SageMaker . **nota** SageMaker A IA usa uma conexão de rede em sua VPC para acessar imagens em seu registro do Docker. Para usar as imagens no registro do Docker para treinamento, o registro deve estar acessível em uma Amazon VPC na sua conta. 1. Opcionalmente, se seu registro do Docker exigir autenticação, você também deverá especificar o Amazon Resource Name (ARN) de uma AWS Lambda função que fornece credenciais de acesso à IA. SageMaker O exemplo a seguir mostra como especificar o ARN. ``` training_repository_credentials_provider_arn = "arn:aws:lambda:us-west-2:1234567890:function:test" ``` Para obter mais informações sobre o uso de imagens em um registro do Docker que exige autenticação, consulte abaixo **Usar um registro do Docker que exija autenticação para treinamento**. 1. Use os exemplos de código das etapas anteriores para configurar um estimador, conforme mostrado no exemplo de código a seguir. ``` # The training repository access mode must be 'Vpc' for private docker registry jobs training_repository_access_mode = "Vpc" # Specify the instance type, instance count you want to use instance_type="ml.m5.xlarge" instance_count=1 # Specify the maximum number of seconds that a model training job can run max_run_time = 1800 # Specify the output path for the model artifacts output_path = "s3://your-output-bucket/your-output-path" estimator = Estimator( image_uri=image_uri, role=role, subnets=subnets, security_group_ids=security_groups, training_repository_access_mode=training_repository_access_mode, training_repository_credentials_provider_arn=training_repository_credentials_provider_arn, # remove this line if auth is not needed instance_type=instance_type, instance_count=instance_count, output_path=output_path, max_run=max_run_time ) ``` 1. Inicie o trabalho de treinamento chamando `estimator.fit` com o nome do trabalho e o caminho de entrada como parâmetros, conforme mostrado no seguinte exemplo de código. ``` input_path = "s3://your-input-bucket/your-input-path" job_name = "your-job-name" estimator.fit( inputs=input_path, job_name=job_name ) ``` # Use um registro do Docker que exija autenticação para treinamento Se seu registro do Docker exigir autenticação, você deverá criar uma AWS Lambda função que forneça credenciais de acesso à IA. SageMaker Em seguida, crie um trabalho de treinamento e forneça o ARN dessa função do Lambda dentro da API [create\$1training\$1job](https://boto3.amazonaws.com/v1/documentation/api/latest/reference/services/sagemaker.html#SageMaker.Client.create_training_job). Por fim, você pode criar opcionalmente um Endpoint de interface da VPC para que sua VPC possa se comunicar com a função do Lambda sem enviar tráfego pela Internet. O guia a seguir mostra como criar uma função do Lambda, atribuir a ela a função correta e criar um Endpoint de interface da VPC. ## Criar a função do Lambda Crie uma AWS Lambda função que transmita as credenciais de acesso para a SageMaker IA e retorne uma resposta. O exemplo de código a seguir cria o manipulador da função do Lambda, da seguinte forma. ``` def handler(event, context): response = { "Credentials": {"Username": "username", "Password": "password"} } return response ``` O tipo de autenticação usado para configurar o registro privado do Docker determina o conteúdo da resposta retornada pela função do Lambda da seguinte forma. + Se seu registro privado do Docker usar autenticação básica, a função Lambda retornará o nome de usuário e a senha necessários para se autenticar no registro. + Se o seu registro privado do Docker usar a [autenticação do token do portador](https://docs.docker.com/registry/spec/auth/token/), o nome de usuário e a senha serão enviados ao seu servidor de autorização, que então retornará um token do portador. Esse token é então usado para se autenticar em seu registro privado do Docker. **nota** Se você tiver mais de uma função do Lambda para seus registros na mesma conta e a função de execução for a mesma para seus trabalhos de treinamento, os trabalhos de treinamento para registro terão acesso às funções do Lambda para outros registros. ## Conceda as permissões de função corretas para a função do Lambda. O [IAMrole](https://docs.aws.amazon.com/sagemaker/latest/dg/sagemaker-roles.html)que você usa na `create_training_job` API deve ter permissão para chamar uma AWS Lambda função. O exemplo de código a seguir mostra como estender uma política de permissões a uma função do IAM para chamar `myLambdaFunction`. ``` { "Effect": "Allow", "Action": [ "lambda:InvokeFunction" ], "Resource": [ "arn:aws:lambda:*:*:function:*myLambdaFunction*" ] } ``` Para saber mais sobre como editar uma política de permissões de uma função, consulte [Modificar a política de permissões de uma função (console)](https://docs.aws.amazon.com/IAM/latest/UserGuide/roles-managingrole-editing-console.html#roles-modify_permissions-policy), no *Guia do usuário do Gerenciamento de acesso do AWS *. **nota** Uma função do IAM com uma política **AmazonSageMakerFullAccess**gerenciada anexada tem permissão para chamar qualquer função do Lambda com “SageMaker AI” em seu nome. ## Criar um Endpoint de interface da VPC para o Lambda Se você criar um endpoint de interface, a Amazon VPC poderá se comunicar com a função do Lambda sem enviar tráfego pela Internet. Para obter mais informações, consulte [Configurar endpoints da VPC de interface para o Lambda](https://docs.aws.amazon.com/lambda/latest/dg/configuration-vpc-endpoints.html) no *Guia do desenvolvedor AWS Lambda *. Depois que seu endpoint de interface for criado, o SageMaker treinamento chamará sua função Lambda enviando uma solicitação por meio de sua VPC para. `lambda.region.amazonaws.com` Se você selecionar **Habilitar nome DNS** ao criar seu endpoint de interface, o [Amazon Route 53](https://docs.aws.amazon.com/Route53/latest/DeveloperGuide/Welcome.html) roteará a chamada para o endpoint da interface Lambda. Se você usar um provedor de DNS diferente, deverá relacionar o `lambda.region.amazonaws.co` ao endpoint da interface Lambda. # Adapte seu próprio contêiner de inferência para a Amazon AI SageMaker Se você não puder usar nenhuma das imagens listadas na [Imagens SageMaker AI Docker pré-construídas](docker-containers-prebuilt.md) Amazon SageMaker AI para seu caso de uso, você pode criar seu próprio contêiner Docker e usá-lo dentro da SageMaker IA para treinamento e inferência. Para ser compatível com a SageMaker IA, seu contêiner deve ter as seguintes características: + Seu contêiner deve ter uma listagem de servidores web na porta `8080`. + Seu contêiner deve aceitar solicitações `POST` para os endpoints `/invocations` e `/ping` em tempo real. As solicitações que você envia a esses endpoints devem ser retornadas em 60 segundos para respostas regulares e em 8 minutos para respostas em streaming, e ter o tamanho máximo de 25 MB. Para obter mais informações e um exemplo de como criar seu próprio contêiner do Docker para treinamento e inferência com SageMaker IA, consulte Como [criar seu próprio contêiner de algoritmo](https://github.com/aws/amazon-sagemaker-examples/blob/main/advanced_functionality/scikit_bring_your_own/scikit_bring_your_own.ipynb). O guia a seguir mostra como usar um `JupyterLab` espaço com o Amazon SageMaker Studio Classic para adaptar um contêiner de inferência para funcionar com hospedagem de SageMaker IA. O exemplo usa um servidor web NGINX, Gunicorn como uma interface de gateway de servidor web Python e Flask como uma estrutura de aplicação web. Você pode usar aplicações diferentes para adaptar o contêiner, desde que ele atenda aos requisitos listados anteriormente. Para obter mais informações sobre como usar seu próprio código de inferência, consulte[Código de inferência personalizado com serviços de host](your-algorithms-inference-code.md). **Adaptar seu contêiner de inferência** Use as etapas a seguir para adaptar seu próprio contêiner de inferência para funcionar com hospedagem de SageMaker IA. O exemplo mostrado nas seguintes etapas usa um [Modelo pré-treinado de Reconhecimento de Entidade Nomeada (NER)](https://spacy.io/universe/project/video-spacys-ner-model-alt) que usa a biblioteca [spaCy](https://spacy.io/) de processamento de linguagem natural (PLN) para `Python` e para o seguinte: + Um Dockerfile para criar o contêiner que contém o modelo NER. + Scripts de inferência para servir ao modelo NER. Se você adaptar esse exemplo para seu caso de uso, deverá usar Dockerfile e scripts de inferência necessários para implantar e servir seu modelo. 1. Crie JupyterLab espaço com o Amazon SageMaker Studio Classic (opcional). Você pode usar qualquer notebook para executar scripts e adaptar seu contêiner de inferência com a hospedagem de SageMaker IA. Este exemplo mostra como usar um JupyterLab espaço no Amazon SageMaker Studio Classic para iniciar um JupyterLab aplicativo que vem com uma imagem de distribuição de SageMaker IA. Para obter mais informações, consulte [SageMaker JupyterLab](studio-updated-jl.md). 1. Enviar um arquivo Docker e scripts de inferência. 1. Criar uma nova pasta no seu diretório inicial. Se você estiver usando o JupyterLab, no canto superior esquerdo, escolha o ícone **Nova pasta** e insira um nome de pasta para conter o Dockerfile. Para este exemplo, a pasta é chamada `docker_test_folder`. 1. Enviar um arquivo de texto Dockerfile em sua nova pasta. Veja a seguir um exemplo do Dockerfile que cria um contêiner do Docker com um [modelo pré-treinado de reconhecimento de entidades nomeadas (NER)](https://spacy.io/universe/project/video-spacys-ner-model) da [spaCy](https://spacy.io/), as aplicações e as variáveis de ambiente necessárias para executar o exemplo: ``` FROM python:3.8 RUN apt-get -y update && apt-get install -y --no-install-recommends \ wget \ python3 \ nginx \ ca-certificates \ && rm -rf /var/lib/apt/lists/* RUN wget https://bootstrap.pypa.io/get-pip.py && python3 get-pip.py && \ pip install flask gevent gunicorn && \ rm -rf /root/.cache #pre-trained model package installation RUN pip install spacy RUN python -m spacy download en # Set environment variables ENV PYTHONUNBUFFERED=TRUE ENV PYTHONDONTWRITEBYTECODE=TRUE ENV PATH="/opt/program:${PATH}" COPY NER /opt/program WORKDIR /opt/program ``` No exemplo de código anterior, a variável de ambiente `PYTHONUNBUFFERED` evita que Python armazene em buffer o fluxo de saída padrão, o que permite uma entrega mais rápida de logs ao usuário. A variável de ambiente `PYTHONDONTWRITEBYTECODE` evita que Python grave os arquivos `.pyc` de bytecode compilados, que são desnecessários para esse caso de uso. A variável de ambiente `PATH` é usada para identificar a localização dos programas `train` e `serve` quando o contêiner é invocado. 1. Crie um novo diretório dentro de sua nova pasta para conter scripts para servir ao seu modelo. Este exemplo usa um diretório chamado `NER`, que contém os seguintes scripts necessários para executar este exemplo: + `predictor.py`: um script Python que contém a lógica para enviar e realizar inferências com seu modelo. + `nginx.conf`: um script para configurar um servidor web. + `serve`: um script que inicia um servidor de inferência. + `wsgi.py`: um script auxiliar para servir a um modelo. **Importante** Se você copiar seus scripts de inferência em um caderno que termina em `.ipynb` e renomeá-los, seu script pode conter caracteres de formatação que impedirão a implantação do endpoint. Em vez disso, crie um arquivo de texto e renomeie-o. 1. Enviar um script para disponibilizar seu modelo para inferência. A seguir está um exemplo de script chamado `predictor.py` que usa Flask para fornecer os endpoints `/ping` e `/invocations`: ``` from flask import Flask import flask import spacy import os import json import logging #Load in model nlp = spacy.load('en_core_web_sm') #If you plan to use a your own model artifacts, #your model artifacts should be stored in /opt/ml/model/ # The flask app for serving predictions app = Flask(__name__) @app.route('/ping', methods=['GET']) def ping(): # Check if the classifier was loaded correctly health = nlp is not None status = 200 if health else 404 return flask.Response(response= '\n', status=status, mimetype='application/json') @app.route('/invocations', methods=['POST']) def transformation(): #Process input input_json = flask.request.get_json() resp = input_json['input'] #NER doc = nlp(resp) entities = [(X.text, X.label_) for X in doc.ents] # Transform predictions to JSON result = { 'output': entities } resultjson = json.dumps(result) return flask.Response(response=resultjson, status=200, mimetype='application/json') ``` O endpoint `/ping` no exemplo de script anterior retorna um código de status `200` se o modelo foi enviado corretamente e `404` se o modelo foi enviado incorretamente. O endpoint `/invocations` processa uma solicitação formatada em JSON, extrai o campo de entrada e usa o modelo NER para identificar e armazenar entidades nas entidades variáveis. A aplicação Flask retorna a resposta que contém essas entidades. Para obter mais informações sobre essas solicitações de integridade necessárias, consulte [Como o contêiner deve responder a solicitações de verificação de integridade (ping)](your-algorithms-inference-code.md#your-algorithms-inference-algo-ping-requests). 1. Enviar um script para iniciar um servidor de inferência. O exemplo de script a seguir chama `serve` usado Gunicorn como servidor de aplicações e Nginx como servidor web: ``` #!/usr/bin/env python # This file implements the scoring service shell. You don't necessarily need to modify it for various # algorithms. It starts nginx and gunicorn with the correct configurations and then simply waits until # gunicorn exits. # # The flask server is specified to be the app object in wsgi.py # # We set the following parameters: # # Parameter Environment Variable Default Value # --------- -------------------- ------------- # number of workers MODEL_SERVER_WORKERS the number of CPU cores # timeout MODEL_SERVER_TIMEOUT 60 seconds import multiprocessing import os import signal import subprocess import sys cpu_count = multiprocessing.cpu_count() model_server_timeout = os.environ.get('MODEL_SERVER_TIMEOUT', 60) model_server_workers = int(os.environ.get('MODEL_SERVER_WORKERS', cpu_count)) def sigterm_handler(nginx_pid, gunicorn_pid): try: os.kill(nginx_pid, signal.SIGQUIT) except OSError: pass try: os.kill(gunicorn_pid, signal.SIGTERM) except OSError: pass sys.exit(0) def start_server(): print('Starting the inference server with {} workers.'.format(model_server_workers)) # link the log streams to stdout/err so they will be logged to the container logs subprocess.check_call(['ln', '-sf', '/dev/stdout', '/var/log/nginx/access.log']) subprocess.check_call(['ln', '-sf', '/dev/stderr', '/var/log/nginx/error.log']) nginx = subprocess.Popen(['nginx', '-c', '/opt/program/nginx.conf']) gunicorn = subprocess.Popen(['gunicorn', '--timeout', str(model_server_timeout), '-k', 'sync', '-b', 'unix:/tmp/gunicorn.sock', '-w', str(model_server_workers), 'wsgi:app']) signal.signal(signal.SIGTERM, lambda a, b: sigterm_handler(nginx.pid, gunicorn.pid)) # Exit the inference server upon exit of either subprocess pids = set([nginx.pid, gunicorn.pid]) while True: pid, _ = os.wait() if pid in pids: break sigterm_handler(nginx.pid, gunicorn.pid) print('Inference server exiting') # The main routine to invoke the start function. if __name__ == '__main__': start_server() ``` O exemplo de script anterior define uma função de manipulador de sinal `sigterm_handler`, que desliga os subprocessos Nginx e Gunicorn quando recebe um sinal `SIGTERM`. Uma função `start_server` inicia o manipulador de sinal, inicia e monitora os subprocessos Nginx e Gunicorn e captura fluxos de log. 1. Enviar um script para configurar seu servidor web. O exemplo de script a seguir chamado `nginx.conf` configura um servidor web Nginx usando Gunicorn como servidor de aplicações para servir seu modelo para inferência: ``` worker_processes 1; daemon off; # Prevent forking pid /tmp/nginx.pid; error_log /var/log/nginx/error.log; events { # defaults } http { include /etc/nginx/mime.types; default_type application/octet-stream; access_log /var/log/nginx/access.log combined; upstream gunicorn { server unix:/tmp/gunicorn.sock; } server { listen 8080 deferred; client_max_body_size 5m; keepalive_timeout 5; proxy_read_timeout 1200s; location ~ ^/(ping|invocations) { proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for; proxy_set_header Host $http_host; proxy_redirect off; proxy_pass http://gunicorn; } location / { return 404 "{}"; } } } ``` O exemplo de script anterior configura Nginx para ser executado em primeiro plano, define o local para capturar o `error_log` e define `upstream` como o soquete do servidor Gunicorn. O servidor configura o bloco do servidor para escutar na porta `8080`, define limites no tamanho do corpo da solicitação do cliente e nos valores de tempo limite. O bloco do servidor encaminha solicitações contendo caminhos `/ping` ou `/invocations` para Gunicorn `server http://gunicorn` e retorna um erro `404` para outros caminhos. 1. Enviar todos os outros scripts necessários para atender ao seu modelo. Este exemplo precisa do seguinte exemplo de script chamado `wsgi.py` para ajudar o Gunicorn encontrar sua aplicação: ``` import predictor as myapp # This is just a simple wrapper for gunicorn to find your app. # If you want to change the algorithm file, simply change "predictor" above to the # new file. app = myapp.app ``` Na pasta `docker_test_folder`, sua estrutura de diretórios deve conter Dockerfile e a pasta NER. A pasta NER deve conter os arquivos `nginx.conf`, `predictor.py`, `serve` e `wsgi.py` da seguinte forma: ![\[The Dockerfile structure has inference scripts under the NER directory next to the Dockerfile.\]](http://docs.aws.amazon.com/pt_br/sagemaker/latest/dg/images/docker-file-struct-adapt-ex.png) 1. Criar seu próprio contêiner. Na pasta `docker_test_folder`, crie seu contêiner do Docker. O seguinte comando de exemplo criará o contêiner do Docker que está configurado no Dockerfile: ``` ! docker build -t byo-container-test . ``` O comando anterior criará um contêiner chamado `byo-container-test` no diretório de trabalho atual. Para obter mais informações sobre os parâmetros de criação Docker, consulte [Argumentos de criação](https://docs.docker.com/build/guide/build-args/). **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_test_folder/Dockerfile: no such file or directory ``` O Docker procura especificamente um arquivo chamado Dockerfile sem nenhuma extensão no diretório atual. Se você deu outro nome, poderá transmitir o nome de arquivo manualmente com a sinalização -f. Por exemplo, se você nomeou seu Dockerfile como Dockerfile-text.txt, crie seu contêiner do Docker usando a sinalização `-f` seguida pelo seu arquivo da seguinte forma: ``` ! docker build -t byo-container-test -f Dockerfile-text.txt . ``` 1. Enviar a imagem do Docker para o Amazon Elastic Container Registry (Amazon ECR) Em uma célula de caderno, envie sua imagem do Docker para um ECR. O seguinte exemplo de código mostra como criar o contêiner localmente, fazer login e enviá-lo para um ECR: ``` %%sh # Name of algo -> ECR algorithm_name=sm-pretrained-spacy #make serve executable chmod +x NER/serve account=$(aws sts get-caller-identity --query Account --output text) # Region, defaults to us-west-2 region=$(aws configure get region) region=${region:-us-east-1} 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/nullfi # 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} ``` O exemplo anterior mostra como executar as seguintes etapas necessárias para enviar o contêiner do Docker de exemplo para um ECR: 1. Defina o nome do algoritmo como `sm-pretrained-spacy`. 1. Torne executável o arquivo `serve` dentro da pasta NER. 1. Defina Região da AWS o. 1. Crie um ECR se ele ainda não existir. 1. Faça login no ECR. 1. Construa o contêiner do Docker localmente. 1. Envie a imagem do Docker por push ao ECR. 1. Configurar o cliente de SageMaker IA Se quiser usar serviços de hospedagem de SageMaker IA para inferência, você deve [criar um modelo, criar uma](https://boto3.amazonaws.com/v1/documentation/api/latest/reference/services/sagemaker/client/create_model.html) [configuração de endpoint](https://boto3.amazonaws.com/v1/documentation/api/latest/reference/services/sagemaker/client/create_endpoint_config.html#) e [criar](https://boto3.amazonaws.com/v1/documentation/api/latest/reference/services/sagemaker/client/create_endpoint.html#) um endpoint. Para obter inferências do seu endpoint, você pode usar o cliente SageMaker AI boto3 Runtime para invocar seu endpoint. O código a seguir mostra como configurar o cliente SageMaker AI e o cliente SageMaker Runtime usando o cliente [SageMaker AI boto3:](https://boto3.amazonaws.com/v1/documentation/api/latest/reference/services/sagemaker.html) ``` import boto3 from sagemaker import get_execution_role sm_client = boto3.client(service_name='sagemaker') runtime_sm_client = boto3.client(service_name='sagemaker-runtime') account_id = boto3.client('sts').get_caller_identity()['Account'] region = boto3.Session().region_name #used to store model artifacts which SageMaker AI will extract to /opt/ml/model in the container, #in this example case we will not be making use of S3 to store the model artifacts #s3_bucket = '' role = get_execution_role() ``` No exemplo de código anterior, o bucket do Amazon S3 não é usado, mas inserido como um comentário para mostrar como armazenar artefatos do modelo. Se você receber um erro de permissão depois de executar o exemplo de código anterior, talvez seja necessário adicionar permissões ao seu perfil do IAM. Para obter mais informações sobre perfis do IAM, consulte [Gerente de SageMaker funções da Amazon](role-manager.md). Para obter mais informações sobre como adicionar permissões à sua função atual, consulte [AWS políticas gerenciadas para Amazon SageMaker AI](security-iam-awsmanpol.md). 1. Criar seu modelo. Se você quiser usar serviços de hospedagem de SageMaker IA para inferência, deverá criar um modelo em SageMaker IA. O exemplo de código a seguir mostra como criar o spaCy NER modelo dentro da SageMaker IA: ``` from time import gmtime, strftime model_name = 'spacy-nermodel-' + strftime("%Y-%m-%d-%H-%M-%S", gmtime()) # MODEL S3 URL containing model atrifacts as either model.tar.gz or extracted artifacts. # Here we are not #model_url = 's3://{}/spacy/'.format(s3_bucket) container = '{}.dkr.ecr.{}.amazonaws.com/sm-pretrained-spacy:latest'.format(account_id, region) instance_type = 'ml.c5d.18xlarge' print('Model name: ' + model_name) #print('Model data Url: ' + model_url) print('Container image: ' + container) container = { 'Image': container } create_model_response = sm_client.create_model( ModelName = model_name, ExecutionRoleArn = role, Containers = [container]) print("Model Arn: " + create_model_response['ModelArn']) ``` O exemplo de código anterior mostra como definir um `model_url` usando o `s3_bucket` se você fosse usar o bucket do Amazon S3 a partir dos comentários na Etapa 5 e definir o URI do ECR para a imagem do contêiner. Os exemplos de código anteriores definem `ml.c5d.18xlarge` como o tipo de instância. Também é possível escolher um tipo de instância diferente. Para obter mais informações sobre os tipos de instância disponíveis, consulte [Tipos de instância do Amazon EC2](https://aws.amazon.com/ec2/instance-types/). No exemplo de código anterior, a chave `Image` aponta para o URI da imagem do contêiner. A definição `create_model_response` usa o `create_model method` para criar um modelo e retornar o nome do modelo, a função e uma lista contendo as informações do contêiner. Exemplo de saída do script anterior a seguir: ``` Model name: spacy-nermodel-YYYY-MM-DD-HH-MM-SS Model data Url: s3://spacy-sagemaker-us-east-1-bucket/spacy/ Container image: 123456789012.dkr.ecr.us-east-2.amazonaws.com/sm-pretrained-spacy:latest Model Arn: arn:aws:sagemaker:us-east-2:123456789012:model/spacy-nermodel-YYYY-MM-DD-HH-MM-SS ``` 1. 1. **Configurar e criar um endpoint** Para usar a hospedagem de SageMaker IA para inferência, você também deve configurar e criar um endpoint. SageMaker A IA usará esse endpoint para inferência. O exemplo de configuração a seguir mostra como gerar e configurar um endpoint com o tipo de instância e o nome do modelo que você definiu anteriormente: ``` endpoint_config_name = 'spacy-ner-config' + strftime("%Y-%m-%d-%H-%M-%S", gmtime()) print('Endpoint config name: ' + endpoint_config_name) create_endpoint_config_response = sm_client.create_endpoint_config( EndpointConfigName = endpoint_config_name, ProductionVariants=[{ 'InstanceType': instance_type, 'InitialInstanceCount': 1, 'InitialVariantWeight': 1, 'ModelName': model_name, 'VariantName': 'AllTraffic'}]) print("Endpoint config Arn: " + create_endpoint_config_response['EndpointConfigArn']) ``` No exemplo de configuração anterior, `create_endpoint_config_response` associa o `model_name` a um nome de configuração de endpoint `endpoint_config_name` exclusivo criado com um carimbo de data/hora. Exemplo de saída do script anterior a seguir: ``` Endpoint config name: spacy-ner-configYYYY-MM-DD-HH-MM-SS Endpoint config Arn: arn:aws:sagemaker:us-east-2:123456789012:endpoint-config/spacy-ner-config-MM-DD-HH-MM-SS ``` Para obter mais informações sobre erros de endpoint, consulte [Por que meu endpoint Amazon SageMaker AI entra em estado de falha quando eu crio ou atualizo um](https://repost.aws/knowledge-center/sagemaker-endpoint-creation-fail) endpoint? 1. **Crie um endpoint e aguarde até que o endpoint esteja em serviço.** O seguinte exemplo de código cria o endpoint usando a configuração do exemplo de configuração anterior e implanta o modelo: ``` %%time import time endpoint_name = 'spacy-ner-endpoint' + strftime("%Y-%m-%d-%H-%M-%S", gmtime()) print('Endpoint name: ' + endpoint_name) create_endpoint_response = sm_client.create_endpoint( EndpointName=endpoint_name, EndpointConfigName=endpoint_config_name) print('Endpoint Arn: ' + create_endpoint_response['EndpointArn']) resp = sm_client.describe_endpoint(EndpointName=endpoint_name) status = resp['EndpointStatus'] print("Endpoint Status: " + status) print('Waiting for {} endpoint to be in service...'.format(endpoint_name)) waiter = sm_client.get_waiter('endpoint_in_service') waiter.wait(EndpointName=endpoint_name) ``` No exemplo de código anterior, o método `create_endpoint` cria o endpoint com o nome do endpoint gerado criado no exemplo de código anterior e imprime o Nome do Recurso da Amazon do endpoint. O método `describe_endpoint` retorna informações sobre o endpoint e seu status. Um garçom de SageMaker IA espera que o endpoint esteja em serviço. 1. Teste seu endpoint. Quando seu endpoint estiver em serviço, envie uma [solicitação de invocação](https://boto3.amazonaws.com/v1/documentation/api/1.9.42/reference/services/sagemaker-runtime.html#SageMakerRuntime.Client.invoke_endpoint) para seu endpoint. O seguinte exemplo de código mostra como enviar uma solicitação de teste para o endpoint a seguir: ``` import json content_type = "application/json" request_body = {"input": "This is a test with NER in America with \ Amazon and Microsoft in Seattle, writing random stuff."} #Serialize data for endpoint #data = json.loads(json.dumps(request_body)) payload = json.dumps(request_body) #Endpoint invocation response = runtime_sm_client.invoke_endpoint( EndpointName=endpoint_name, ContentType=content_type, Body=payload) #Parse results result = json.loads(response['Body'].read().decode())['output'] result ``` No exemplo de código anterior, o método `json.dumps` serializa o `request_body` em uma string formatada em JSON e a salva na carga útil da variável. Em seguida, o cliente SageMaker AI Runtime usa o método [invoke endpoint](https://boto3.amazonaws.com/v1/documentation/api/latest/reference/services/sagemaker-runtime/client/invoke_endpoint.html) para enviar a carga para seu endpoint. O resultado contém a resposta do seu endpoint após extrair o campo de saída. O exemplo de código anterior deve retornar o seguinte resultado: ``` [['NER', 'ORG'], ['America', 'GPE'], ['Amazon', 'ORG'], ['Microsoft', 'ORG'], ['Seattle', 'GPE']] ``` 1. Excluir seu endpoint Depois de concluir suas invocações, exclua seu endpoint para conservar recursos. O seguinte exemplo de código mostra como excluir um endpoint: ``` sm_client.delete_endpoint(EndpointName=endpoint_name) sm_client.delete_endpoint_config(EndpointConfigName=endpoint_config_name) sm_client.delete_model(ModelName=model_name) ``` Para obter um caderno completo contendo o código deste exemplo, consulte [BYOC-Single-Model](https://github.com/aws-samples/sagemaker-hosting/tree/main/Bring-Your-Own-Container/BYOC-Single-Model).