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á.
# Preparação do produto no SageMaker AI
Para publicar o produto no AWS Marketplace, você deve prepará-lo no Amazon SageMaker AI. Existem dois tipos de produtos do SageMaker AI listados no AWS Marketplace: pacotes de modelos e algoritmos. Para obter mais informações, consulte [Produtos de machine learning no AWS Marketplace](machine-learning-products.md). Este tópico fornece uma visão geral das três etapas necessárias para preparar seu produto:
1. [Empacotando seu código em imagens para produtos de aprendizado de máquina em AWS Marketplace](ml-packaging-your-code-into-images.md): para preparar um pacote de modelo ou produto de algoritmo, você deve criar as imagens do contêiner do Docker para seu produto.
1. [Faça upload das imagens para o Amazon Elastic Container Registry](ml-uploading-your-images.md): depois de empacotar seu código em imagens de contêiner e testá-las localmente, faça o upload das imagens e verifique-as em busca de vulnerabilidades conhecidas. Corrija todas as vulnerabilidades antes de continuar.
1. [Criando seu recurso de SageMaker IA da Amazon](ml-creating-your-amazon-sagemaker-resource.md): depois que as imagens forem digitalizadas com sucesso, você poderá usá-las para criar um pacote de modelos ou um recurso de algoritmo no SageMaker AI.
# Empacotando seu código em imagens para produtos de aprendizado de máquina em AWS Marketplace
Os produtos de aprendizado de máquina AWS Marketplace usam o Amazon SageMaker AI para criar e executar a lógica de aprendizado de máquina que você fornece aos compradores. SageMaker A IA executa imagens de contêiner do Docker que contêm sua lógica. SageMaker A IA executa esses contêineres em uma infraestrutura segura e escalável. Para obter mais informações, consulte [Segurança e propriedade intelectual com a Amazon SageMaker AI](ml-security-and-intellectual-property.md). As seções a seguir fornecem informações sobre como empacotar seu código em imagens de contêiner do Docker para SageMaker IA.
**Topics**
+ [Que tipo de imagem de contêiner eu crio?](#ml-which-type-of-container-image-do-i-create)
+ [Criação de imagens do pacote de modelo](ml-model-package-images.md)
+ [Criação de imagens de algoritmo](ml-algorithm-images.md)
## Que tipo de imagem de contêiner eu crio?
Os dois tipos de imagens de contêiner são uma imagem de inferência e uma imagem de treinamento.
Para criar um produto de pacote de modelo, você precisa apenas de uma imagem de inferência. Para obter instruções detalhadas, consulte [Criação de imagens do pacote de modelo](ml-model-package-images.md).
Para criar um produto de algoritmo, você precisa de imagens de treinamento e inferência. Para obter instruções detalhadas, consulte [Criação de imagens de algoritmo](ml-algorithm-images.md).
Para empacotar o código corretamente em uma imagem de contêiner, o contêiner deve seguir a estrutura de arquivos do SageMaker AI. O contêiner deve expor os endpoints corretos para garantir que o serviço possa transmitir dados de e para seu contêiner. As seções a seguir explicam os detalhes desse processo.
**Importante**
Por motivos de segurança, quando um comprador assina seu produto em contêiner, os contêineres de Docker são executados em um ambiente isolado sem acesso à Internet. Ao criar contêineres, não dependa de chamadas de saída pela Internet, pois elas falharão. As chamadas para Serviços da AWS também falharão. Para obter mais informações, consulte a seção [Segurança e propriedade intelectual com a Amazon SageMaker AI](ml-security-and-intellectual-property.md).
Se desejar, ao criar imagens de inferência e treinamento, use um contêiner de [Imagens de contêiner de aprendizado profundo disponíveis](https://aws.amazon.com/releasenotes/available-deep-learning-containers-images/) como ponto de partida. As imagens já estão devidamente empacotadas com diferentes estruturas de machine learning.
# 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.
**Topics**
+ [Visão geral do](#ml-model-package-images-overview)
+ [Criar uma imagem de inferência para pacotes de modelo](#ml-creating-an-inference-image-for-model-packages)
## Visão geral do
Um pacote de modelo inclui os seguintes componentes:
+ Uma imagem de inferência armazenada no [Amazon Elastic Container Registry](https://aws.amazon.com/ecr/) (Amazon ECR)
+ (Opcional) Artefatos do modelo, armazenados separadamente no [Amazon S3](https://aws.amazon.com/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](https://docs.aws.amazon.com/sagemaker/latest/dg/neo.html) 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.
![\[Diagrama de como um vendedor cria uma imagem de pacote de modelo e como o comprador a usa.\]](http://docs.aws.amazon.com/pt_br/marketplace/latest/userguide/images/ml-model-package-images.png)
O fluxo de trabalho para criar um pacote de modelos de SageMaker IA AWS Marketplace inclui as seguintes etapas:
1. 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.
1. Em seguida, o vendedor cria um recurso de pacote modelo no Amazon SageMaker AI e publica seu produto de ML no AWS Marketplace.
1. 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](https://docs.aws.amazon.com/sagemaker/latest/dg/deploy-model.html).
1. 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.
1. 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:
**Topics**
+ [Etapa 1: criar a imagem do contêiner](#ml-step-1-creating-the-container-image)
+ [Etapa 2: criar e testar a imagem localmente](#ml-step-2-building-and-testing-the-image-locally)
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](https://docs.aws.amazon.com/sagemaker/latest/dg/your-algorithms.html) e os [exemplos de AWS Marketplace SageMaker IA](https://github.com/aws/amazon-sagemaker-examples/tree/master/aws_marketplace) em GitHub.
O exemplo a seguir usa um serviço da Web, o [Flask](https://pypi.org/project/Flask/), para simplificar, e não é considerado pronto para produção.
### 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](#ml-create-the-web-server-script)
+ [Criar o script para a execução do contêiner](#ml-create-the-script-for-the-container-run)
+ [Criar a `Dockerfile`](#ml-create-the-dockerfile)
+ [Empacotar ou fazer upload dos artefatos do modelo](#ml-package-or-upload-the-model-artifacts)
#### Criar o script do servidor da Web
Este exemplo usa um servidor Python chamado [Flask](https://pypi.org/project/Flask/), mas você pode usar qualquer servidor da Web que funcione para sua estrutura.
**nota**
O [Flask](https://pypi.org/project/Flask/) é usado aqui para simplificar. Ele não é considerado um servidor da Web pronto para produção.
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](ml-listing-requirements-and-best-practices.md).
**`./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:latest
```
#### Executar 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 GMT
```
#### Testar 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](ml-uploading-your-images.md).
# Criação de imagens de algoritmo
Um algoritmo de SageMaker IA da Amazon exige que o comprador traga seus próprios dados para treinar antes de fazer previsões. Como AWS Marketplace vendedor, você pode usar a SageMaker IA para criar algoritmos e modelos de aprendizado de máquina (ML) que seus compradores possam implantar AWS. Nas seções a seguir, você aprenderá a criar imagens de algoritmo para AWS Marketplace. Isso inclui criar a imagem de treinamento do Docker para treinar seu algoritmo e a imagem de inferência que contém sua lógica de inferência. Tanto as imagens de treinamento quanto as de inferência são necessárias ao publicar um produto de algoritmo.
**Topics**
+ [Visão geral do](#ml-algorithm-images-overview)
+ [Criação de uma imagem de treinamento para algoritmos](#ml-creating-a-training-image-for-algorithms)
+ [Criação de uma imagem de inferência para algoritmos](#ml-creating-an-inference-image-for-algorithms)
## Visão geral do
Um algoritmo inclui os seguintes componentes:
+ Uma imagem de treinamento armazenada no [Amazon ECR](https://aws.amazon.com/ecr/)
+ Uma imagem de inferência armazenada no Amazon Elastic Container Registry (Amazon ECR)
**nota**
Para produtos de algoritmo, o contêiner de treinamento gera artefatos de modelo que são carregados no contêiner de inferência na implantação do modelo.
O diagrama a seguir mostra um fluxo de trabalho para publicar e usar os produtos de algoritmo.
![\[Diagrama de como um vendedor cria uma imagem de pacote de algoritmo e como o comprador a usa.\]](http://docs.aws.amazon.com/pt_br/marketplace/latest/userguide/images/ml-algorithm-package-images.png)
O fluxo de trabalho para criar um algoritmo de SageMaker IA AWS Marketplace inclui as seguintes etapas:
1. O vendedor cria uma imagem de treinamento e uma imagem de inferência (sem acesso à rede quando implantadas) e as envia para o Amazon ECR Registry.
1. Em seguida, o vendedor cria um recurso de algoritmo na Amazon SageMaker AI e publica seu produto de ML no AWS Marketplace.
1. O comprador assina o produto de ML.
1. O comprador cria um trabalho de treinamento com um conjunto de dados compatível e valores de hiperparâmetros apropriados. SageMaker A IA executa a imagem de treinamento e carrega os dados e hiperparâmetros de treinamento no contêiner de treinamento. Quando o trabalho de treinamento é concluído, os artefatos do modelo localizados em `/opt/ml/model/` são compactados e copiados para o bucket do [Amazon S3](https://aws.amazon.com/s3/) do comprador.
1. O comprador cria um pacote de modelo com os artefatos do modelo do treinamento armazenados no Amazon S3 e implanta o modelo.
1. SageMaker A IA executa a imagem de inferência, extrai os artefatos do modelo compactado e carrega os arquivos no caminho do diretório do contêiner de inferência, `/opt/ml/model/` onde são consumidos pelo código que serve para a inferência.
1. Independentemente de o modelo ser implantado como um endpoint ou um trabalho de transformação em lote, a SageMaker IA passa os dados para inferência em nome do comprador para o contêiner por meio do endpoint HTTP do contêiner e retorna os resultados da previsão.
**nota**
Para obter mais informações, consulte [Treinar modelos](https://docs.aws.amazon.com/sagemaker/latest/dg/train-model.html).
## Criação de uma imagem de treinamento para algoritmos
Esta seção fornece um passo a passo para empacotar seu código de treinamento em uma imagem de treinamento. É necessária uma imagem de treinamento para criar um produto de algoritmo.
Uma *imagem de treinamento* é uma imagem do Docker contendo seu algoritmo de treinamento. O contêiner adere a uma estrutura de arquivo específica para permitir que a SageMaker IA copie dados de e para seu contêiner.
Tanto as imagens de treinamento quanto as de inferência são necessárias ao publicar um produto de algoritmo. Depois de criar sua imagem de treinamento, você deve criar uma imagem de inferência. As duas imagens podem ser combinadas em uma imagem ou permanecer como imagens separadas. Depende de você combinar as imagens ou separá-las. Normalmente, a inferência é mais simples do que o treinamento, e talvez você queira imagens separadas para ajudar no desempenho da inferência.
**nota**
Veja a seguir apenas um exemplo de código de empacotamento para uma imagem de treinamento. Para obter mais informações, consulte [Use seus próprios algoritmos e modelos com os](https://docs.aws.amazon.com/sagemaker/latest/dg/your-algorithms-marketplace.html) exemplos de IA AWS Marketplace e os [exemplos de AWS Marketplace SageMaker IA](https://github.com/aws/amazon-sagemaker-examples/tree/master/aws_marketplace) em GitHub.
**Topics**
+ [Etapa 1: criar a imagem do contêiner](#ml-step-1-creating-the-container-image-1)
+ [Etapa 2: criar e testar a imagem localmente](#ml-step-2-building-and-testing-the-image-locally-1)
### Etapa 1: criar a imagem do contêiner
Para que a imagem de treinamento seja compatível com a Amazon SageMaker AI, ela deve seguir uma estrutura de arquivo específica para permitir que a SageMaker IA copie os dados de treinamento e as entradas de configuração para caminhos específicos em seu contêiner. Quando o treinamento é concluído, os artefatos do modelo gerado são armazenados em um caminho de diretório específico no contêiner de onde a SageMaker IA copia.
O seguinte usa a CLI do Docker instalada em um ambiente de desenvolvimento em uma distribuição Ubuntu do Linux.
+ [Preparar o programa para ler as entradas de configuração](#ml-prepare-your-program-to-read-configuration-inputs)
+ [Preparar o programa para ler as entradas de dados](#ml-prepare-your-program-to-read-data-inputs)
+ [Preparar o programa para escrever resultados de treinamento](#ml-prepare-your-program-to-write-training-outputs)
+ [Criar o script para a execução do contêiner](#ml-create-the-script-for-the-container-run-1)
+ [Criar a `Dockerfile`](#ml-create-the-dockerfile-1)
#### Preparar o programa para ler as entradas de configuração
Se o programa de treinamento exigir alguma entrada de configuração fornecida pelo comprador, ela será copiada para aqui dentro do seu contêiner quando executada. Se necessário, seu programa deve ler esses caminhos de arquivo específicos.
+ `/opt/ml/input/config` é o diretório que contém informações que controlam como seu programa é executado.
+ `hyperparameters.json` é um dicionário formatado em JSON de nomes e valores de hiperparâmetros. Os valores são strings, então talvez seja necessário convertê-los.
+ `resourceConfig.json` é um arquivo formatado em JSON que descreve o layout de rede usado para [treinamento distribuído](https://docs.aws.amazon.com/sagemaker/latest/dg/your-algorithms-training-algo-running-container.html#your-algorithms-training-algo-running-container-dist-training). Se sua imagem de treinamento não suportar treinamento distribuído, você pode ignorar esse arquivo.
**nota**
Para obter mais informações sobre as entradas de configuração, consulte [Como a Amazon SageMaker AI fornece informações de treinamento](https://docs.aws.amazon.com/sagemaker/latest/dg/your-algorithms-training-algo-running-container.html).
#### Preparar o programa para ler as entradas de dados
Os dados de treinamento podem ser passados para o contêiner em um dos dois modos a seguir. Seu programa de treinamento executado no contêiner digere os dados de treinamento em um desses dois modos.
**Modo de arquivo**
+ `/opt/ml/input/data//` contém os dados de entrada desse canal. Os canais são criados com base na chamada para a operação `CreateTrainingJob`, mas geralmente é importante que os canais correspondam ao que o algoritmo espera. Os arquivos de cada canal são copiados do [Amazon S3](https://aws.amazon.com/s3/) para esse diretório, preservando a estrutura em árvore indicada pela estrutura de chaves do Amazon S3.
**Modo de canal**
+ `/opt/ml/input/data/_` é o cachimbo de uma determinada época. As épocas começam em zero e aumentam em uma cada vez que você as lê. Não há limite para o número de épocas que podem ser executadas, mas você deve fechar cada canal antes de ler a próxima época.
#### Preparar o programa para escrever resultados de treinamento
A saída do treinamento é gravada nos seguintes diretórios de contêineres:
+ `/opt/ml/model/` é o diretório em que você escreve o modelo ou os artefatos do modelo que o algoritmo de treinamento gera. O modelo pode estar em qualquer formato que você quiser. Pode ser um único arquivo ou uma árvore de diretórios inteira. SageMaker O AI empacota todos os arquivos desse diretório em um arquivo compactado (.tar.gz). Esse arquivo está disponível no local do Amazon S3 retornado pela operação de API `DescribeTrainingJob`.
+ `/opt/ml/output/` é um diretório em que o algoritmo pode gravar um arquivo `failure` que descreve por que o trabalho falhou. O conteúdo desse arquivo é retornado no campo `FailureReason` do resultado `DescribeTrainingJob`. Para trabalhos bem-sucedidos, não há razão para escrever esse arquivo porque ele é ignorado.
#### Criar o script para a execução do contêiner
Crie um script de `train` shell que a SageMaker IA execute ao executar a imagem do contêiner Docker. Quando o treinamento for concluído e os artefatos do modelo forem gravados nos respectivos diretórios, saia do script.
**`./train`**
```
#!/bin/bash
# Run your training program here
#
#
#
#
```
#### Criar a `Dockerfile`
Crie um `Dockerfile` no contexto de criação. Este exemplo usa o Ubuntu 18.04 como imagem base, mas você pode começar com qualquer imagem base que funcione para sua estrutura.
**`./Dockerfile`**
```
FROM ubuntu:18.04
# Add training dependencies and programs
#
#
#
#
#
# Add a script that SageMaker AI will run
# Set run permissions
# Prepend program directory to $PATH
COPY /train /opt/program/train
RUN chmod 755 /opt/program/train
ENV PATH=/opt/program:${PATH}
```
O `Dockerfile` adiciona o script `train` criado anteriormente à imagem. O diretório do script é adicionado ao PATH para que ele possa ser executado quando o contêiner for executado.
No exemplo anterior, não há uma lógica de treinamento real. Para a imagem real de treinamento, adicione as dependências de treinamento ao `Dockerfile` e adicione a lógica para ler as entradas de treinamento para treinar e gerar os artefatos do modelo.
A imagem de treinamento deve conter todas as dependências necessárias porque não terá acesso à Internet.
Para obter mais informações, consulte [Use seus próprios algoritmos e modelos com os](https://docs.aws.amazon.com/sagemaker/latest/dg/your-algorithms-marketplace.html) exemplos de IA AWS Marketplace e os [exemplos de AWS Marketplace SageMaker IA](https://github.com/aws/amazon-sagemaker-examples/tree/master/aws_marketplace) em GitHub.
### Etapa 2: criar e testar a imagem localmente
No contexto de criação, os seguintes arquivos agora existem:
+ `./Dockerfile`
+ `./train`
+ As dependências e a lógica de treinamento
Em seguida, você pode criar, executar e testar essa 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-training-image`.
```
sudo docker build --tag my-training-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-training-image:latest
```
#### Executar o localmente
Depois de concluído, teste a imagem localmente conforme mostrado no exemplo a seguir.
```
sudo docker run \
--rm \
--volume ':/opt/ml/input:ro' \
--volume ':/opt/ml/model' \
--volume ':/opt/ml/output' \
--name my-training-container \
my-training-image \
train
```
A seguir estão os detalhes do comando:
+ `--rm`: remova automaticamente o contêiner depois que ele parar.
+ `--volume ':/opt/ml/input:ro'`: disponibilize o diretório de entrada de teste para o contêiner como somente leitura.
+ `--volume ':/opt/ml/model'`: vincule o caminho em que os artefatos do modelo são armazenados na máquina host quando o teste de treinamento é concluído.
+ `--volume ':/opt/ml/output'`: vincule o caminho em que o motivo da falha em um arquivo `failure` é gravado na máquina host.
+ `--name my-training-container`: dê um nome a esse contêiner em execução.
+ `my-training-image`: execute a imagem criada.
+ `train`— 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 treinamento que você criou e o executa. O contêiner executa o script `train`, que inicia seu programa de treinamento.
Depois que seu programa de treinamento terminar e o contêiner sair, verifique se os artefatos do modelo de saída estão corretos. Além disso, verifique as saídas do log para confirmar se elas não estão produzindo logs que você não deseja e, ao mesmo tempo, garanta que informações suficientes sejam fornecidas sobre o trabalho de treinamento.
Isso conclui o empacotamento do código de treinamento para um produto de algoritmo. Como um produto de algoritmo também inclui uma imagem de inferência, continue na próxima seção, [Criação de uma imagem de inferência para algoritmos](#ml-creating-an-inference-image-for-algorithms).
## Criação de uma imagem de inferência para algoritmos
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 algoritmo.
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.
Tanto as imagens de treinamento quanto as de inferência são necessárias ao publicar um produto de algoritmo. Se ainda não tiver feito isso, veja a seção anterior sobre [Criação de uma imagem de treinamento para algoritmos](#ml-creating-a-training-image-for-algorithms). As duas imagens podem ser combinadas em uma imagem ou permanecer como imagens separadas. Depende de você combinar as imagens ou separá-las. Normalmente, a inferência é mais simples do que o treinamento, e talvez você queira imagens separadas para ajudar no desempenho da inferência.
**nota**
Veja a seguir apenas um exemplo de código de empacotamento para uma imagem de inferência. Para obter mais informações, consulte [Use seus próprios algoritmos e modelos com os](https://docs.aws.amazon.com/sagemaker/latest/dg/your-algorithms-marketplace.html) exemplos de IA AWS Marketplace e os [exemplos de AWS Marketplace SageMaker IA](https://github.com/aws/amazon-sagemaker-examples/tree/master/aws_marketplace) em GitHub.
O exemplo a seguir usa um serviço da Web, o [Flask](https://pypi.org/project/Flask/), para simplificar, e não é considerado pronto para produção.
**Topics**
+ [Etapa 1: criar a imagem de inferência](#ml-step-1-creating-the-inference-image)
+ [Etapa 2: criar e testar a imagem localmente](#ml-step-2-building-and-testing-the-image-locally-2)
### Etapa 1: criar a imagem de inferência
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 para inferência fornecidas pelo comprador para o endpoint HTTP do seu contêiner. O resultado da inferência é retornado no corpo da resposta de HTTP.
O seguinte usa a CLI do Docker instalada em um ambiente de desenvolvimento em uma distribuição Ubuntu do Linux.
+ [Criar o script do servidor da Web](#ml-create-the-web-server-script-1)
+ [Criar o script para a execução do contêiner](#ml-create-the-script-for-the-container-run-2)
+ [Criar a `Dockerfile`](#ml-create-the-dockerfile-2)
+ [Preparação do programa para carregar dinamicamente artefatos do modelo](#ml-preparing-your-program-to-dynamically-load-model-artifacts)
#### Criar o script do servidor da Web
Este exemplo usa um servidor Python chamado [Flask](https://pypi.org/project/Flask/), mas você pode usar qualquer servidor da Web que funcione para sua estrutura.
**nota**
O [Flask](https://pypi.org/project/Flask/) é usado aqui para simplificar. Ele não é considerado um servidor da Web pronto para produção.
Crie o script do servidor web Flask que serve os dois endpoints HTTP na porta TCP 8080 que a AI 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.
**`./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 here.
#
#
#
#
#
# Add your inference code here.
# 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.
A imagem de inferência deve conter todas as dependências necessárias porque não terá acesso à Internet.
#### 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. Nesse script, inicie o servidor da Web HTTP.
**`./serve`**
```
#!/bin/bash
# Run flask server on port 8080 for SageMaker AI
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.
#### Preparação do programa para carregar dinamicamente artefatos do modelo
Para produtos de algoritmo, o comprador usa seus próprios conjuntos de dados com a imagem de treinamento para gerar artefatos de modelo exclusivos. Quando o processo de treinamento é concluído, seu contêiner de treinamento envia artefatos do modelo para o diretório do contêiner. ` /opt/ml/model/` SageMaker A IA comprime o conteúdo desse diretório em um arquivo.tar.gz e o armazena no endereço do comprador no Amazon S3. Conta da AWS
Quando o modelo é implantado, a SageMaker IA executa sua imagem de inferência, extrai os artefatos do modelo do arquivo .tar.gz armazenado na conta do comprador no Amazon S3 e os carrega no contêiner de inferência no diretório. `/opt/ml/model/` Em runtime, o código de contêiner de inferência usa os dados do modelo.
**nota**
Para proteger a propriedade intelectual que possa estar nos arquivos de artefato de modelo, você pode optar por criptografar os arquivos antes de gerá-los. Para obter mais informações, consulte [Segurança e propriedade intelectual com a Amazon SageMaker AI](ml-security-and-intellectual-property.md).
### Etapa 2: criar e testar a imagem localmente
No contexto de criação, os seguintes arquivos agora existem:
+ `./Dockerfile`
+ `./web_app_serve.py`
+ `./serve`
Em seguida, você pode criar, executar e testar essa imagem de contêiner.
#### Criar a imagem
Execute o comando do Docker 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:latest
```
#### Executar o localmente
Depois que a criação for concluída, você poderá testar a imagem localmente.
```
sudo docker run \
--rm \
--publish 8080:8080/tcp \
--volume ':/opt/ml/model:ro' \
--detach \
--name my-inference-container \
my-inference-image \
serve
```
A seguir estão os detalhes do 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 o SageMaker AI envia solicitações HTTP.
+ `--volume ':/opt/ml/model:ro'`: vincule e monte o caminho até onde os artefatos do modelo de teste são armazenados na máquina host como somente leitura para disponibilizá-los para seu código de inferência no contêiner.
+ `--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 e o executa em segundo plano. O contêiner executa o script `serve`, que inicia 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.
Execute o comando a seguir para testar o endpoint e incluir o cabeçalho de resposta.
```
curl --include http://127.0.0.1:8080/ping
```
O resultado de exemplo é mostrado no exemplo a seguir.
```
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 GMT
```
#### Testar o endpoint HTTP de inferência
Quando o contêiner indica que está pronto retornando um código de status 200, a SageMaker IA passa os dados de inferência para o endpoint `/invocations` HTTP por meio de uma `POST` solicitação.
Execute o comando a seguir para testar o endpoint de inferência.
```
curl \
--request POST \
--data "hello world" \
http://127.0.0.1:8080/invocations
```
O resultado de exemplo é mostrado no exemplo a seguir.
```
{"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 algoritmo pode ser implantado de duas maneiras: em tempo real e em lote. Para 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
```
Depois que as imagens de treinamento e inferência do produto de algoritmo estiverem prontas e testadas, continue para [Faça upload das imagens para o Amazon Elastic Container Registry](ml-uploading-your-images.md).
# Faça upload das imagens para o Amazon Elastic Container Registry
Depois de criar as imagens de inferência e treinamento, você pode fazer o upload delas para o Amazon Elastic Container Registry. [O Amazon ECR](https://aws.amazon.com/ecr/) é um registro Docker totalmente gerenciado. O Amazon SageMaker AI extrai imagens do Amazon ECR para criar um pacote de modelos para inferência ou um algoritmo para trabalhos de treinamento. AWS Marketplace também recupera essas imagens do Amazon ECR para publicar seu pacote de modelos e produtos de algoritmo. Este tópico fornece um passo a passo para fazer o upload das imagens de inferência e treinamento para o Amazon ECR
**Topics**
+ [Quais imagens devo enviar?](#ml-which-images-must-i-upload)
+ [Quais permissões do IAM são necessárias?](#ml-what-iam-permissions-are-required)
+ [Faça o login do seu cliente Docker em AWS](#ml-log-in-your-docker-client)
+ [Criar um repositório e fazer o upload da imagem](#ml-create-repository-and-upload-image)
+ [Digitalizar a imagem enviada](#ml-scan-your-uploaded-image)
## Quais imagens devo enviar?
Se você estiver publicando um pacote de modelo, faça o upload somente de uma imagem de inferência. Se você estiver publicando um algoritmo, faça o upload de uma imagem de inferência e de treinamento. Se as imagens de inferência e treinamento forem combinadas, faça o upload da imagem combinada somente uma vez.
## Quais permissões do IAM são necessárias?
As etapas a seguir pressupõem que a máquina local tenha AWS as credenciais corretas para uma função ou usuário AWS Identity and Access Management (IAM) no vendedor Conta da AWS. A função ou o usuário deve ter as políticas corretas em vigor tanto para o Amazon ECR AWS Marketplace quanto para o Amazon ECR. Por exemplo, você pode usar as seguintes políticas AWS gerenciadas:
+ [https://docs.aws.amazon.com/aws-managed-policy/latest/reference/AWSMarketplaceSellerProductsFullAccess.html](https://docs.aws.amazon.com/aws-managed-policy/latest/reference/AWSMarketplaceSellerProductsFullAccess.html)— Para acesso a AWS Marketplace
+ [https://docs.aws.amazon.com/aws-managed-policy/latest/reference/AmazonEC2ContainerRegistryFullAccess.html](https://docs.aws.amazon.com/aws-managed-policy/latest/reference/AmazonEC2ContainerRegistryFullAccess.html): para ter acesso ao Amazon ECR
**nota**
Os links levam você até a *Referência de política gerenciada pela AWS *.
## Faça o login do seu cliente Docker em AWS
Defina uma variável para Região da AWS a qual você deseja publicar (consulte[Regiões da AWS Compatível com publicação](ml-service-restrictions-and-limits.md#ml-supported-aws-regions-for-publishing)). Para este exemplo, use a região Leste dos EUA (Ohio).
```
region=us-east-2
```
Execute o comando a seguir para definir uma variável com seu Conta da AWS ID. Este exemplo pressupõe que as credenciais atuais AWS Command Line Interface (AWS CLI) pertençam às do vendedor. Conta da AWS
```
account=$(aws sts get-caller-identity --query Account --output text)
```
Para autenticar seu cliente Docker CLI com seu registro Docker do Conta da AWS Amazon ECR para sua região, execute o comando a seguir.
```
aws ecr get-login-password \
--region ${region} \
| sudo docker login \
--username AWS \
--password-stdin \
${account}.dkr.ecr.${region}.amazonaws.com
```
## Criar um repositório e fazer o upload da imagem
Defina uma variável para a tag da imagem carregada e outra variável para o nome do repositório de imagens carregadas.
```
image=my-inference-image
repo=my-inference-image
```
**nota**
Nas seções anteriores deste guia, nas quais as imagens de inferência e treinamento foram criadas, elas foram marcadas como **my-inference-image**e **my-training-image**, respectivamente. Neste exemplo, crie e carregue a imagem de inferência em um repositório com o mesmo nome.
Execute o comando a seguir para criar o repositório de imagens no Amazon ECR.
```
aws ecr --region ${region} create-repository --repository-name "${repo}"
```
O nome completo da localização do repositório do Amazon ECR é composto pelas seguintes partes: ` .dkr.ecr..amazonaws.com/`
Para enviar a imagem para o repositório, você deve marcá-la com o nome completo do local do repositório.
Defina uma variável para o nome completo do local do repositório de imagens junto com a tag `latest`.
```
fullname="${account}.dkr.ecr.${region}.amazonaws.com/${repo}:latest"
```
Marque a imagem com o nome completo.
```
sudo docker tag ${image} ${fullname}
```
Por fim, envie a imagem de inferência para o repositório no Amazon ECR.
```
sudo docker push ${fullname}
```
Após a conclusão do upload, a imagem aparece na [lista de repositórios do console do Amazon ECR](https://console.aws.amazon.com/ecr/repositories?region=us-east-2) na região da qual você está publicando. No exemplo anterior, a imagem foi enviada para um repositório na região Leste dos EUA (Ohio).
## Digitalizar a imagem enviada
No [console do Amazon ECR](https://console.aws.amazon.com/ecr/repositories?region=us-east-2), escolha Região da AWS aquele do qual você está publicando e abra o repositório no qual a imagem foi carregada. Selecione a imagem enviada e inicie uma verificação para verificar se há vulnerabilidades conhecidas. AWS Marketplace verifica os resultados do escaneamento do Amazon ECR das imagens de contêiner usadas em seu recurso de SageMaker IA da Amazon antes de publicá-lo. Antes de criar o produto, você deve corrigir imagens de contêineres que tenham vulnerabilidades com gravidade crítica ou alta.
Depois que suas imagens forem verificadas, elas poderão ser usadas para criar um pacote de modelo ou recurso de algoritmo.
Se você acredita que o produto teve erros na varredura que são falsos positivos, entre em contato com a equipe de [operações do vendedor do AWS Marketplace](https://aws.amazon.com/marketplace/management/contact-us) com informações sobre o erro.
**Próximas etapas**
+ Consulte os limites de tamanho em [Requisitos e práticas recomendadas para criar produtos de machine learning](ml-listing-requirements-and-best-practices.md)
+ Avance para [Criando seu recurso de SageMaker IA da Amazon](ml-creating-your-amazon-sagemaker-resource.md)
# Criando seu recurso de SageMaker IA da Amazon
Para publicar um pacote de modelo ou um produto de algoritmo, você deve criar o respectivo recurso de [pacote de modelo ou recurso](https://docs.aws.amazon.com/marketplace/latest/userguide/ml-creating-your-amazon-sagemaker-resource.html#ml-creating-your-model-package-product) [de algoritmo](https://docs.aws.amazon.com/marketplace/latest/userguide/ml-creating-your-amazon-sagemaker-resource.html#ml-creating-your-algorithm-product) na Amazon SageMaker AI. Quando você cria o recurso para um produto do AWS Marketplace , ele deve ser certificado por meio de uma etapa de validação. A etapa de validação exige que você forneça dados para testar o pacote de modelo ou recurso de algoritmo antes que ele possa ser publicado. As seções a seguir mostram como criar seu recurso de SageMaker IA, seja um recurso de pacote de modelos ou recursos de algoritmo. Isso inclui definir as especificações de validação que informam à SageMaker IA como realizar a validação.
**nota**
Se você ainda não tiver criado as imagens do produto e as enviou para o Amazon Elastic Container Registry (Amazon ECR), consulte [Empacotando seu código em imagens para produtos de aprendizado de máquina em AWS Marketplace](ml-packaging-your-code-into-images.md) e [Faça upload das imagens para o Amazon Elastic Container Registry](ml-uploading-your-images.md) para obter informações sobre como fazer isso.
**Topics**
+ [Criação do pacote de modelo](#ml-creating-your-model-package-product)
+ [Criação do algoritmo](#ml-creating-your-algorithm-product)
## Criação do pacote de modelo
Confira a seguir os requisitos para criar um pacote de modelo para o AWS Marketplace:
+ Uma imagem de inferência armazenada no [Amazon ECR](https://aws.amazon.com/ecr/)
+ (Opcional) Artefatos do modelo, armazenados separadamente no [Amazon S3](https://aws.amazon.com/s3/)
+ Os dados de teste usados em inferências, armazenados no Amazon Simple Storage Service
**nota**
O texto a seguir fala sobre a criação de um produto de pacote de modelo. Para obter mais informações sobre pacotes de modelos na SageMaker IA, consulte [Create a Model Package Resource](https://docs.aws.amazon.com/sagemaker/latest/dg/sagemaker-mkt-create-model-package.html).
### Criação dos recursos do pacote de modelo
Os procedimentos a seguir orientam você na criação dos recursos do pacote de modelo.
**Etapa 1: para criar os recursos do pacote de modelo**
1. Abra o [console do Amazon SageMaker AI](https://us-east-2.console.aws.amazon.com/sagemaker/home).
1. Verifique se você está na AWS região em que deseja publicar consultando o canto superior direito da página. Para publicação, consulte a seção [Regiões da AWS Compatível com publicação](ml-service-restrictions-and-limits.md#ml-supported-aws-regions-for-publishing). A imagem de inferência que você enviou para o Amazon ECR nas etapas anteriores deve estar na mesma região.
1. No menu de navegação à esquerda, escolha **Pacotes de modelo**.
1. Escolha **Criar pacote de modelos**.
Depois de criar o pacote, você precisa definir as especificações do pacote de inferência.
**Etapa 2: definir especificações de inferência**
1. Forneça um **nome** para seu pacote de modelo (por exemplo,*my-model-package*).
1. Em **Localização da imagem de inferência**, insira o URI da imagem de inferência que foi enviada para o Amazon ECR. Você pode recuperar o URI localizando sua imagem no [console do Amazon ECR](https://us-east-2.console.aws.amazon.com/ecr/repositories).
1. Se os artefatos do modelo do treinamento estiverem agrupados com a lógica na imagem de inferência, deixe a opção **Localização dos artefatos de dados do modelo** vazia. Caso contrário, especifique a localização completa do Amazon S3 do arquivo compactado (.tar.gz) dos artefatos do modelo.
1. Usando a caixa suspensa, escolha os tipos de instância compatíveis da imagem de inferência para trabalhos de inferência em tempo real (também conhecida como *endpoint*) e de transformação em lote.
1. Escolha **Próximo**.
Antes que o pacote de modelo possa ser criado e publicado, a validação é necessária para garantir que ele funcione conforme o esperado. Isso exige que você execute um trabalho de transformação em lote com dados de teste para inferência fornecidos por você. As especificações de validação informam à SageMaker IA como realizar a validação.
**Etapa 3: para definir as especificações de validação**
1. Defina **Publicar este pacote de modelo no AWS Marketplace** como **Sim**. Se você definir isso como **Não**, não poderá publicar esse pacote de modelo posteriormente. Escolher **Sim** [certifica](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_CreateModelPackage.html#sagemaker-CreateModelPackage-request-CertifyForMarketplace) seu pacote de modelo AWS Marketplace e exige a etapa de validação.
1. Se for a primeira vez que conclui esse processo, escolha **Criar uma nova função** para o **perfil do IAM**. A Amazon SageMaker AI usa essa função quando implanta seu pacote de modelos. Isso inclui ações, como extrair imagens do Amazon ECR e artefatos do Amazon S3. Revise as configurações e escolha **Criar função**. Criar um papel aqui concede as permissões descritas pela política [ AmazonSageMakerFullAccess](https://console.aws.amazon.com/iam/home#/policies/arn:aws:iam::aws:policy/AmazonSageMakerFullAccess)do IAM para o papel que você cria.
1. Edite o **JSON** no perfil de validação. Para obter detalhes sobre os valores permitidos, consulte [TransformJobDefinition](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_TransformJobDefinition.html).
1. `TransformInput.DataSource.S3Uri`: defina onde os dados de teste para inferência são armazenados.
1. `TransformInput.ContentType`: especifique seu tipo de conteúdo de dados de teste (por exemplo`application/json`,`text/plain`,`image/png `,, ou qualquer outro valor). SageMaker A IA não valida os dados de entrada reais. Esse valor é passado para o endpoint HTTP do contêiner no valor do cabeçalho `Content-type`.
1. `TransformInput.CompressionType`: defina como `None` se os dados de teste para inferência no Amazon S3 não estiverem compactados.
1. `TransformInput.SplitType`: defina como `None` para passar cada objeto no Amazon S3 como um todo para inferência.
1. `TransformOutput.S3OutputPath`: defina o local em que a saída da inferência é armazenada.
1. `TransformOutput.AssembleWith`: defina como `None` para gerar cada inferência como objetos separados no Amazon S3.
1. Escolha **Criar pacote de modelos**.
SageMaker A IA extrai a imagem de inferência do Amazon ECR, copia todos os artefatos para o contêiner de inferência e executa um trabalho de transformação em lote usando seus dados de teste para inferência. Depois que a validação for bem-sucedida, o status mudará para **Concluído**.
**nota**
A etapa de validação não avalia a precisão do modelo com os dados de teste. A etapa de validação verifica se o contêiner é executado e responde conforme o esperado.
Você concluiu a criação dos recursos do produto de modelo. Avance para [Listando seu produto em AWS Marketplace](ml-publishing-your-product-in-aws-marketplace.md).
## Criação do algoritmo
Confira a seguir os requisitos para criar um algoritmo para o AWS Marketplace:
+ Uma imagem de inferência, armazenada no Amazon ECR
+ Uma imagem de treinamento, armazenada no Amazon ECR
+ Seus dados de teste para treinamento, armazenados no Amazon S3
+ Seus dados de teste para inferência, armazenados no Amazon S3
**nota**
O passo a passo a seguir cria um produto de algoritmo. Para obter mais informações, consulte [Criar um recurso de algoritmo](https://docs.aws.amazon.com/sagemaker/latest/dg/sagemaker-mkt-create-algo.html).
### Criação dos recursos do algoritmo
Os procedimentos a seguir orientam você na criação dos recursos no pacote de algoritmos.
**Etapa 1: para criar os recursos do algoritmo**
1. Abra o [console do Amazon SageMaker AI](https://us-east-2.console.aws.amazon.com/sagemaker/home).
1. Verifique se você está na AWS região da qual deseja publicar consultando o canto superior direito da página (consulte[Regiões da AWS Compatível com publicação](ml-service-restrictions-and-limits.md#ml-supported-aws-regions-for-publishing)). As imagens de treinamento e inferência que você enviou para o Amazon ECR nas etapas anteriores devem estar nessa mesma região.
1. No menu de navegação à esquerda, escolha **Algoritmos**.
1. Escolha **Criar algoritmo**.
Depois de criar o pacote de algoritmos, você deve definir as especificações para o treinamento e o ajuste do modelo.
**Etapa 2: para definir as especificações de treinamento e ajuste**
1. Insira o **nome do** seu algoritmo (por exemplo,*my-algorithm*).
1. Em **Imagem de treinamento**, cole a localização completa do URI da imagem de treinamento que foi enviada para o Amazon ECR. Você pode recuperar o URI localizando sua imagem no [console do Amazon ECR](https://us-east-2.console.aws.amazon.com/ecr/repositories).
1. Usando a caixa suspensa, escolha os **tipos de instância de treinamento compatíveis** com a imagem de treinamento.
1. Na seção **Especificação do canal**, adicione um canal para cada conjunto de dados de entrada compatível com o algoritmo, até 20 canais de fontes de entrada. Para obter mais informações, consulte [Configuração dos dados de entrada](https://docs.aws.amazon.com/sagemaker/latest/dg/your-algorithms-training-algo-running-container.html#your-algorithms-training-algo-running-container-inputdataconfig).
1. Escolha **Próximo**.
1. Se o algoritmo suportar hiperparâmetros e ajuste de hiperparâmetros, você deverá especificar os parâmetros de ajuste.
1. Escolha **Próximo**.
**nota**
É altamente recomendável que o algoritmo ofereça suporte ao ajuste de hiperparâmetros e torne os parâmetros apropriados ajustáveis. Isso permite que cientistas de dados ajustem modelos para obter os melhores resultados.
Depois de definir os parâmetros de ajuste, se houver, você deve definir as especificações para a imagem de inferência.
**Etapa 3: para definir a especificação da imagem de inferência**
1. Em **Localização da imagem de inferência**, cole o URI da imagem de inferência que foi enviada para o Amazon ECR. Você pode recuperar o URI localizando sua imagem no [console do Amazon ECR](https://us-east-2.console.aws.amazon.com/ecr/repositories).
1. Usando a caixa suspensa, escolha os tipos de instância compatíveis da imagem de inferência para trabalhos de inferência em tempo real (também conhecida como *endpoint*) e de transformação em lote.
1. Escolha **Próximo**.
Antes que o algoritmo possa ser criado e publicado, a validação é necessária para garantir que ele funcione conforme o esperado. Isso exige que você execute um trabalho de treinamento com dados de teste para treinamento e um trabalho de transformação em lote com dados de teste para inferência que você fornece. As especificações de validação informam à SageMaker IA como realizar a validação.
**Etapa 4: para definir as especificações de validação**
1. Defina **Publicar este algoritmo no AWS Marketplace** como **Sim**. Se você definir isso como **Não**, não poderá publicar esse algoritmo posteriormente. Escolher **Sim** [certifica](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_CreateAlgorithm.html#sagemaker-CreateAlgorithm-request-CertifyForMarketplace) seu algoritmo AWS Marketplace e exige a especificação de validação.
1. Se esta é a primeira vez que você cria um pacote de aprendizado de máquina para AWS Marketplace, escolha **Criar uma nova função** para a **função do IAM**. A Amazon SageMaker AI usa essa função ao treinar seu algoritmo e implantar o pacote de modelos subsequente. Isso inclui ações como extrair imagens do Amazon ECR, armazenar artefatos no Amazon S3 e copiar dados de treinamento do Amazon S3. Revise as configurações e escolha **Criar função**. Criar um papel aqui concede as permissões descritas pela política [ AmazonSageMakerFullAccess](https://console.aws.amazon.com/iam/home#/policies/arn:aws:iam::aws:policy/AmazonSageMakerFullAccess)do IAM para o papel que você cria.
1. Edite o arquivo **JSON** no perfil de validação para a **Definição do trabalho de treinamento**. Para obter mais informações sobre valores permitidos, consulte [ TrainingJobDefinition](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_TrainingJobDefinition.html).
1. `InputDataConfig`: nessa matriz JSON, adicione um [Objeto de canal](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_Channel.html) para cada canal indicado na etapa de especificação de treinamento. Para cada canal, especifique onde os dados de teste para treinamento são armazenados.
1. `OutputDataConfig`: após a conclusão do treinamento, os artefatos do modelo no caminho do diretório do contêiner de treinamento `/opt/ml/model/` são compactados e copiados para o Amazon S3. Especifique a localização do Amazon S3 onde o arquivo compactado (.tar.gz) está armazenado.
1. Edite o arquivo JSON no perfil de validação para a **Definição do trabalho de transformação**. Para obter mais informações sobre valores permitidos, consulte [ TransformJobDefinition](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_TransformJobDefinition.html).
1. `TransformInput.DataSource.S3Uri`: defina onde os dados de teste para inferência são armazenados.
1. `TransformInput.ContentType`: especifique o tipo de conteúdo de dados de teste. Por exemplo, `application/json`, `text/plain`, `image/png` ou qualquer outro valor. A Amazon SageMaker AI não valida os dados de entrada reais. Esse valor é passado para o endpoint HTTP do contêiner no valor do cabeçalho `Content-type`.
1. `TransformInput.CompressionType`: defina como `None` se os dados de teste para inferência no Amazon S3 não estiverem compactados.
1. `TransformInput.SplitType`: escolha como você deseja que os objetos sejam divididos no S3. Por exemplo, `None` transmite cada objeto no Amazon S3 como um todo para inferência. Para obter mais detalhes, consulte [ SplitType](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_TransformInput.html#sagemaker-Type-TransformInput-SplitType)a Amazon SageMaker AI API Reference.
1. `TransformOutput.S3OutputPath`: defina o local onde a saída da inferência é armazenada.
1. `TransformOutput.AssembleWith`: defina como `None` para gerar cada inferência como objetos separados no Amazon S3.
1. Escolha **Criar pacote de algoritmos**.
SageMaker A IA extrai a imagem de treinamento do Amazon ECR, executa um trabalho de treinamento de teste usando seus dados e armazena os artefatos do modelo no Amazon S3. Em seguida, ele extrai a imagem de inferência do Amazon ECR, copia os artefatos do Amazon S3 para o contêiner de inferência e executa um trabalho de transformação em lote usando seus dados de teste para inferência. Depois que a validação for bem-sucedida, o status mudará para **Concluído**.
**nota**
A etapa de validação não avalia a precisão do treinamento ou do modelo com os dados de teste. A etapa de validação verifica se os contêineres são executados e respondem conforme o esperado.
A etapa de validação valida somente o processamento em lote. Cabe a você validar se o processamento em tempo real funciona com seu produto.
Você concluiu a criação dos recursos do produto de algoritmo. Avance para [Listando seu produto em AWS Marketplace](ml-publishing-your-product-in-aws-marketplace.md).