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á.
Criação de imagens do pacote de modelo
Um pacote de modelos Amazon SageMaker AI é um modelo pré-treinado que faz previsões e não exige nenhum treinamento adicional do comprador. Você pode criar um pacote de modelos em SageMaker IA e publicar seu produto de aprendizado de máquina no AWS Marketplace. Nas seções a seguir, você aprenderá a criar um pacote de modelos para AWS Marketplace. Isso inclui criar a imagem do contêiner e criar e testar a imagem localmente.
Visão geral
Um pacote de modelo inclui os seguintes componentes:
-
Uma imagem de inferência armazenada no Amazon Elastic Container Registry
(Amazon ECR) -
(Opcional) Artefatos do modelo, armazenados separadamente no Amazon S3
nota
Os artefatos do modelo são arquivos que o modelo usa para fazer previsões e geralmente são o resultado de seus próprios processos de treinamento. Os artefatos podem ser qualquer tipo de arquivo necessário para o modelo, mas devem ser compactados em use.tar.gz. Para pacotes de modelos, eles podem ser agrupados em sua imagem de inferência ou armazenados separadamente na Amazon SageMaker AI. Os artefatos do modelo armazenados no Amazon S3 são carregados no contêiner de inferência em runtime. Ao publicar seu pacote de modelo, esses artefatos são publicados e armazenados em buckets AWS Marketplace próprios do Amazon S3 que não podem ser acessados diretamente pelo comprador.
dica
Se seu modelo de inferência for criado com uma estrutura de aprendizado profundo, como Gluon, Keras,,, MXNet PyTorch, TensorFlow TensorFlow -Lite ou ONNX, considere usar o Amazon AI Neo. SageMaker O Neo pode otimizar automaticamente os modelos de inferência que são implantados em uma família específica de tipos de instância de nuvem, como ml.c4, ml.p2 e outros. Para obter mais informações, consulte Otimizar o desempenho do modelo usando o Neo no Amazon SageMaker AI Developer Guide.
O diagrama a seguir mostra um fluxo de trabalho para publicar e usar os produtos de pacote de modelo.
O fluxo de trabalho para criar um pacote de modelos de SageMaker IA AWS Marketplace inclui as seguintes etapas:
-
O vendedor cria uma imagem de inferência (sem acesso à rede quando implantada) e a envia para o Amazon ECR Registry.
Os artefatos do modelo podem ser agrupados na imagem de inferência ou armazenados separadamente no S3.
-
Em seguida, o vendedor cria um recurso de pacote modelo no Amazon SageMaker AI e publica seu produto de ML no AWS Marketplace.
-
O comprador assina o produto de ML e implanta o modelo.
nota
O modelo pode ser implantado como um endpoint para inferências em tempo real ou como um trabalho em lote para obter previsões para um conjunto de dados inteiro de uma só vez. Para obter mais informações, consulte Implantar modelos para inferência.
-
SageMaker A IA executa a imagem de inferência. Todos os artefatos de modelo fornecidos pelo vendedor que não estejam incluídos na imagem de inferência são carregados dinamicamente em runtime.
-
SageMaker A IA passa os dados de inferência do comprador para o contêiner usando os endpoints HTTP do contêiner e retorna os resultados da previsão.
Criar uma imagem de inferência para pacotes de modelo
Esta seção fornece um passo a passo para empacotar o código de inferência em uma imagem de inferência para o produto de pacote de modelo. O processo consiste nas seguintes etapas:
A imagem de inferência é uma imagem do Docker contendo a lógica de inferência. O contêiner em tempo de execução expõe endpoints HTTP para permitir que a SageMaker IA transmita dados de e para seu contêiner.
nota
Veja a seguir apenas um exemplo de código de empacotamento para uma imagem de inferência. Para obter mais informações, consulte Como usar contêineres do Docker com SageMaker IA e os exemplos de AWS Marketplace
SageMaker IA
O exemplo a seguir usa um serviço da Web, o Flask
Etapa 1: criar a imagem do contêiner
Para que a imagem de inferência seja compatível com a SageMaker IA, a imagem do Docker deve expor os endpoints HTTP. Enquanto seu contêiner está em execução, a SageMaker IA passa as entradas do comprador para inferência ao endpoint HTTP do contêiner. Os resultados de inferência são retornados no corpo da resposta HTTP.
O passo a passo a seguir usa a CLI do Docker em um ambiente de desenvolvimento usando uma distribuição Linux Ubuntu.
Criar o script do servidor da Web
Este exemplo usa um servidor Python chamado Flask
nota
O Flask
Crie um script de servidor web Flask que atenda aos dois endpoints HTTP na porta TCP 8080 que a IA usa. SageMaker A seguir estão os dois endpoints esperados:
-
/ping— A SageMaker IA faz solicitações HTTP GET para esse endpoint para verificar se seu contêiner está pronto. Quando o contêiner estiver pronto, ele responderá às solicitações HTTP GET nesse endpoint com um código de resposta HTTP 200. -
/invocations— A SageMaker IA faz solicitações HTTP POST para esse endpoint para inferência. Os dados de entrada para inferência são enviados no corpo da solicitação. O tipo de conteúdo especificado pelo usuário é passado no cabeçalho HTTP. O corpo da resposta é a saída da inferência. Para obter detalhes sobre tempos limite, consulte Requisitos e práticas recomendadas para criar produtos de machine learning.
./web_app_serve.py
# Import modules import json import re from flask import Flask from flask import request app = Flask(__name__) # Create a path for health checks @app.route("/ping") def endpoint_ping(): return "" # Create a path for inference @app.route("/invocations", methods=["POST"]) def endpoint_invocations(): # Read the input input_str = request.get_data().decode("utf8") # Add your inference code between these comments. # # # # # # Add your inference code above this comment. # Return a response with a prediction response = {"prediction":"a","text":input_str} return json.dumps(response)
No exemplo anterior, não há uma lógica de inferência real. Para a imagem de inferência real, adicione a lógica de inferência ao aplicativo da Web para que ele processe a entrada e retorne a previsão real.
Sua imagem de inferência deve conter todas as dependências necessárias porque não terá acesso à Internet nem poderá fazer chamadas para nenhuma. Serviços da AWS
nota
Esse mesmo código é chamado para inferências em tempo real e em lote.
Criar o script para a execução do contêiner
Crie um script chamado serve que a SageMaker IA executa ao executar a imagem do contêiner Docker. O script a seguir inicia o servidor da Web HTTP.
./serve
#!/bin/bash # Run flask server on port 8080 for SageMaker flask run --host 0.0.0.0 --port 8080
Criar a Dockerfile
Crie um Dockerfile no contexto de criação. Este exemplo usa o Ubuntu 18.04, mas você pode começar a partir de qualquer imagem base que funcione para sua estrutura.
./Dockerfile
FROM ubuntu:18.04 # Specify encoding ENV LC_ALL=C.UTF-8 ENV LANG=C.UTF-8 # Install python-pip RUN apt-get update \ && apt-get install -y python3.6 python3-pip \ && ln -s /usr/bin/python3.6 /usr/bin/python \ && ln -s /usr/bin/pip3 /usr/bin/pip; # Install flask server RUN pip install -U Flask; # Add a web server script to the image # Set an environment to tell flask the script to run COPY /web_app_serve.py /web_app_serve.py ENV FLASK_APP=/web_app_serve.py # Add a script that Amazon SageMaker AI will run # Set run permissions # Prepend program directory to $PATH COPY /serve /opt/program/serve RUN chmod 755 /opt/program/serve ENV PATH=/opt/program:${PATH}
O Dockerfile adiciona os dois scripts criados anteriormente à imagem. O diretório do script serve é adicionado ao CAMINHO para que ele possa ser executado quando o contêiner for executado.
Empacotar ou fazer upload dos artefatos do modelo
As duas maneiras de fornecer os artefatos do modelo, desde o treinamento do modelo até a imagem de inferência, são as seguintes:
-
Empacotados estaticamente com a imagem de inferência.
-
Carregados dinamicamente em runtime. Como o carregamento é dinâmico, você pode usar a mesma imagem para empacotar diferentes modelos de machine learning.
Se você quiser empacotar os artefatos do modelo com a imagem de inferência, inclua os artefatos no Dockerfile.
Se você quiser carregar os artefatos de modelo dinamicamente, armazene esses artefatos separadamente em um arquivo compactado (.tar.gz) no Amazon S3. Ao criar o pacote do modelo, especifique a localização do arquivo compactado, e o SageMaker AI extrai e copia o conteúdo para o diretório do contêiner /opt/ml/model/ ao executar seu contêiner. Ao publicar o pacote de modelo, esses artefatos são publicados e armazenados em buckets do Amazon S3 de propriedade do AWS Marketplace
que não podem ser acessados diretamente pelo comprador.
Etapa 2: criar e testar a imagem localmente
No contexto de criação, os seguintes arquivos agora existem:
-
./Dockerfile -
./web_app_serve.py -
./serve -
Sua lógica de inferência e dependências (opcionais)
Em seguida, você cria, executa e testa a imagem de contêiner.
Criar a imagem
Execute o comando do Docker no contexto de criação para criar e marcar a imagem. Este exemplo usa a tag my-inference-image.
sudo docker build --tag my-inference-image ./
Depois de executar esse comando do Docker para criar a imagem, você deve ver a saída quando o Docker cria a imagem com base em cada linha do Dockerfile. Quando terminar, você deverá ver algo semelhante ao seguinte.
Successfully built abcdef123456
Successfully tagged my-inference-image:latestExecutar o localmente
Depois que a criação for concluída, você poderá testar a imagem localmente.
sudo docker run \ --rm \ --publish 8080:8080/tcp \ --detach \ --name my-inference-container \ my-inference-image \ serve
Veja a seguir os detalhes sobre o comando:
-
--rm: remova automaticamente o contêiner depois que ele parar. -
--publish 8080:8080/tcp— Exponha a porta 8080 para simular a porta para a qual a SageMaker IA envia solicitações HTTP. -
--detach: execute o contêiner em segundo plano. -
--name my-inference-container: dê um nome a esse contêiner em execução. -
my-inference-image: execute a imagem criada. -
serve— Execute o mesmo script que a SageMaker IA executa ao executar o contêiner.
Depois de executar esse comando, o Docker cria um contêiner a partir da imagem de inferência criada e o executa em segundo plano. O contêiner executa o script serve, que executa seu servidor da Web para fins de teste.
Testar o endpoint HTTP de ping
Quando a SageMaker IA executa seu contêiner, ela efetua um ping periódico no endpoint. Quando o endpoint retorna uma resposta HTTP com o código de status 200, ele sinaliza para a SageMaker IA que o contêiner está pronto para inferência. Você pode testar isso executando o comando a seguir, que testa o endpoint e inclui o cabeçalho de resposta.
curl --include http://127.0.0.1:8080/ping
O exemplo de saída é o seguinte.
HTTP/1.0 200 OK
Content-Type: text/html; charset=utf-8
Content-Length: 0
Server: MyServer/0.16.0 Python/3.6.8
Date: Mon, 21 Oct 2019 06:58:54 GMTTestar o endpoint HTTP de inferência
Quando o contêiner indica que está pronto retornando um código de status 200 ao seu ping, a SageMaker IA passa os dados de inferência para o endpoint /invocations HTTP por meio de uma POST solicitação. Teste o ponto de inferência executando o comando a seguir.
curl \ --request POST \ --data "hello world" \ http://127.0.0.1:8080/invocations
O exemplo de saída é o seguinte.
{"prediction": "a", "text": "hello
world"}
Com esses dois endpoints HTTP funcionando, a imagem de inferência agora é compatível com SageMaker a IA.
nota
O modelo do produto de pacote de modelo pode ser implantado de duas maneiras: em tempo real e em lote. Em ambas as implantações, a SageMaker IA usa os mesmos endpoints HTTP ao executar o contêiner Docker.
Para interromper o contêiner, execute o seguinte comando.
sudo docker container stop my-inference-container
Quando sua imagem de inferência estiver pronta e testada, você poderá continuar para Faça upload das imagens para o Amazon Elastic Container Registry.
