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 de pacotes de modelos
Um pacote de SageMaker modelos da Amazon é um modelo pré-treinado que faz previsões e não exige nenhum treinamento adicional do comprador. Você pode criar um pacote de modelos SageMaker 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
(AmazonECR) -
(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 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, TensorFlow -Lite ou PyTorch TensorFlow, ONNX considere usar o Amazon 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 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 SageMaker modelos 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 Registry. ECR
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 na Amazon SageMaker 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 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 passa os dados de inferência do comprador para o contêiner usando os HTTP pontos finais do contêiner e retorna os resultados da previsão.
Crie uma imagem de inferência para pacotes de modelos
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 HTTP endpoints para permitir SageMaker a transmissão de 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 e os AWS Marketplace
SageMaker exemplos
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 SageMaker, a imagem do Docker deve HTTP expor os endpoints. Enquanto seu contêiner está em execução, SageMaker transmite as informações do comprador para inferência ao endpoint do HTTP contêiner. Os resultados da inferência são retornados no corpo da HTTP resposta.
O passo a passo a seguir usa o Docker CLI 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 HTTP endpoints na TCP porta 8080 que usa. SageMaker A seguir estão os dois endpoints esperados:
-
/ping— SageMaker faz HTTP GET solicitações a esse endpoint para verificar se seu contêiner está pronto. Quando seu contêiner estiver pronto, ele responderá às HTTP GET solicitações nesse endpoint com um código de resposta HTTP 200. -
/invocations— SageMaker faz HTTP POST solicitações a 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 HTTP cabeçalho. 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 delas. 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 seja SageMaker executado ao executar a imagem do contêiner Docker. O script a seguir inicia o servidor HTTP web.
./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 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 serve script é adicionado ao para que ele PATH 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 SageMaker extraia e copie 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 SageMaker envia HTTP solicitações. -
--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 SageMaker é executado 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.
Teste o HTTP endpoint de ping
Quando SageMaker executa seu contêiner, ele efetua um ping periódico no endpoint. Quando o endpoint retorna uma HTTP resposta com o código de status 200, ele sinaliza SageMaker 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 GMTTeste o endpoint de inferência HTTP
Quando o contêiner indica que está pronto, retornando um código de status 200 ao seu ping, SageMaker passa os dados de inferência para o /invocations HTTP endpoint 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 HTTP endpoints funcionando, a imagem de inferência agora é compatível com o. SageMaker
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, SageMaker usa os mesmos HTTP endpoints 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 Carregando suas imagens para o Amazon Elastic Container Registry.
