

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

# Produtos de machine learning no AWS Marketplace
<a name="machine-learning-products"></a>

Como um vendedor do AWS Marketplace, você pode criar algoritmos e modelos de machine learning (ML) que seus compradores possam implantar na AWS. Este tópico apresenta informações sobre os tipos de produto do Amazon SageMaker AI listados no AWS Marketplace.

Existem dois tipos de produtos do SageMaker AI listados no AWS Marketplace: 

**Pacote de modelos**  
 Um modelo pré-treinado para fazer previsões que não exige nenhum treinamento adicional do comprador. 

**Algoritmo**  
 Um modelo que exige que o comprador forneça dados de treinamento antes de fazer previsões. O algoritmo de treinamento está incluído. 

Esses produtos estão disponíveis para os compradores por meio do console do Amazon SageMaker AI ou AWS Marketplace. Os compradores podem revisar descrições de produtos, documentações, análises de clientes, definições de preços e informações de suporte. Quando eles assinam um pacote de modelos ou um produto de algoritmo, ele é adicionado à lista de produtos no console do SageMaker AI. Os compradores também podem usar SDKs da AWS, a AWS Command Line Interface (AWS CLI) ou o console do SageMaker AI para criar um endpoint de inferência REST totalmente gerenciado ou realizar inferência em lotes de dados. 

 Para obter suporte à criação dos produtos de machine learning com o Amazon SageMaker AI, entre em contato com a equipe de [Operações do vendedor do AWS Marketplace](https://aws.amazon.com/marketplace/management/contact-us/). 

# Conceitos básicos dos produtos de machine learning
<a name="ml-overview"></a>

 AWS Marketplace suporta dois tipos de produtos de aprendizado de máquina, usando o Amazon SageMaker AI. Ambos os tipos, os produtos do pacote de modelos e os produtos do algoritmo, produzem um modelo de inferência implantável para fazer previsões.

## SageMaker Pacote de modelos de IA
<a name="ml-amazon-sagemaker-model-package"></a>

 Um produto de [pacote de modelos Amazon SageMaker AI](https://docs.aws.amazon.com/sagemaker/latest/dg/sagemaker-marketplace.html#sagemaker-mkt-model-package) contém um modelo pré-treinado. Modelos pré-treinados podem ser implantados na SageMaker IA para fazer inferências ou previsões em tempo real ou em lotes. Este produto contém um componente de inferência treinado com artefatos de modelo, se houver. Como vendedor, você pode treinar um modelo usando SageMaker IA ou trazer seu próprio modelo. 

## SageMaker Algoritmo AI
<a name="ml-amazon-sagemaker-algorithm"></a>

 Os compradores podem usar um produto de [algoritmo de SageMaker IA](https://docs.aws.amazon.com/sagemaker/latest/dg/sagemaker-marketplace.html#sagemaker-mkt-algorithm) para realizar cargas de trabalho completas de aprendizado de máquina. Um produto de algoritmo tem dois componentes lógicos: treinamento e inferência. Na SageMaker IA, os compradores usam seus próprios conjuntos de dados para criar um trabalho de treinamento com seu componente de treinamento. Quando o algoritmo em seu componente de treinamento é concluído, ele gera os artefatos do modelo de aprendizado de máquina. SageMaker A IA salva os artefatos do modelo no bucket Amazon Simple Storage Service (Amazon S3) dos compradores. Na SageMaker IA, os compradores podem então implantar seu componente de inferência junto com os artefatos de modelo gerados para realizar inferência (ou previsão) em tempo real ou em lotes. 

## Implantação de um modelo de inferência
<a name="ml-deploying-an-inference-model"></a>

 Se o modelo de inferência é criado a partir de um pacote de modelos ou de um algoritmo, há dois métodos para implantá-lo: 
+  **Endpoint** — Esse método usa SageMaker IA para implantar o modelo e criar um endpoint de API. O comprador pode usar esse endpoint como parte do serviço de backend para alimentar seus aplicativos. Quando os dados são enviados para o endpoint, a SageMaker IA os passa para o contêiner do modelo e retorna os resultados em uma resposta da API. O endpoint e o contêiner continuam funcionando até serem interrompidos pelo comprador.
**nota**  
 Em AWS Marketplace, o método de endpoint é chamado de *inferência em tempo real* e, na documentação de SageMaker IA, é chamado de *serviços de hospedagem*. Para obter mais informações, consulte [Implantar um modelo na Amazon SageMaker AI](https://docs.aws.amazon.com/sagemaker/latest/dg/how-it-works-deployment.html). 
+  **Trabalho de transformação em lote**: nesse método, um comprador armazena conjuntos de dados para inferência no Amazon S3. Quando o trabalho de transformação em lote é iniciado, a SageMaker IA implanta o modelo, passa os dados de um bucket do S3 para o contêiner do modelo e, em seguida, retorna os resultados para um bucket do Amazon S3. Quando o trabalho é concluído, a SageMaker IA interrompe o trabalho. Para obter mais informações, consulte [Usar transformação em lote](https://docs.aws.amazon.com/sagemaker/latest/dg/batch-transform.html).
**nota**  
 Ambos os métodos são transparentes para o modelo porque a SageMaker IA passa dados para o modelo e retorna os resultados ao comprador. 

# Ciclo de vida do produto de machine learning
<a name="ml-product-lifecycle"></a>

Um produto de aprendizado de máquina AWS Marketplace consiste em uma ou mais versões de software e metadados associados. A configuração do produto inclui propriedades essenciais, como nome, descrição, instruções de uso, definição de preço, categorização e palavras-chave de pesquisa. 

## Processo de criação do produto de machine learning
<a name="ml-publication-process"></a>

 Para listar um produto de aprendizado de máquina no AWS Marketplace, você deve concluir o seguinte: 

1. [Preparação do produto no SageMaker AI](ml-prepare-your-product-in-sagemaker.md)

1. [Listando seu produto em AWS Marketplace](ml-publishing-your-product-in-aws-marketplace.md)

 Depois que tiver criado o produto de machine learning, você poderá editar e gerenciar o produto. Para obter mais informações, consulte [Gerenciamento dos produtos de machine learning](ml-product-management.md). 

## Status do produto de machine learning
<a name="ml-product-status"></a>

 Inicialmente, novos produtos têm visibilidade limitada, acessíveis apenas a contas permitidas e ao criador do produto. Após o teste e a validação, você pode publicar seu produto para disponibilizá-lo no AWS Marketplace catálogo para todos os compradores. Os produtos em AWS Marketplace podem ter os seguintes valores de status: 


| Status | Definição | 
| --- |--- |
| Preparação |  Este status indica um produto incompleto para o qual você ainda está adicionando informações. Depois de salvar e sair da experiência de autoatendimento, AWS Marketplace cria um produto não publicado contendo informações das etapas concluídas. Com base nesse status, você pode continuar adicionando informações ou modificar detalhes enviados.   | 
| Limitado | Um produto atinge esse status depois de ser enviado AWS Marketplace e passar por todas as verificações de validação. Neste momento, o produto tem uma página de detalhes acessível somente para sua conta e entidades permitidas. Você pode realizar testes de produtos por meio desta página de detalhes. | 
| Public | Quando você estiver preparado para tornar seu produto visível aos compradores para assinatura, atualize a visibilidade do produto no console. Depois de processado, o produto passa do status Limitado para Público. Para obter informações sobre AWS diretrizes, consulte[Requisitos e práticas recomendadas para criar produtos de machine learning](ml-listing-requirements-and-best-practices.md).  | 
| Restrito |  Para evitar que novos usuários assinem o produto, você pode restringi-lo atualizando as configurações de visibilidade. Um status Restrito permite a usuários permitidos existentes continuar usando o produto, mas ele não estará mais visível para o público nem estará disponível para novos usuários.  | 

 Para obter mais informações ou suporte, entre em contato com a [equipe de operações do vendedor do AWS Marketplace](https://aws.amazon.com/marketplace/management/contact-us/). 

# Preços de produtos de aprendizado de máquina para AWS Marketplace
<a name="machine-learning-pricing"></a>

Você pode escolher entre vários modelos de preços disponíveis para seus produtos Amazon SageMaker AI em AWS Marketplace. Os compradores que assinam seu produto o executam em SageMaker IA dentro de si mesmos Conta da AWS. O preço para os compradores é uma combinação dos custos de infraestrutura dos recursos em execução na Conta da AWS e do preço do produto que você define. As seções a seguir fornecem informações sobre modelos de preços para produtos de SageMaker IA no AWS Marketplace

**Topics**
+ [Preços da infraestrutura](#ml-infrastructure-pricing)
+ [Preços de software](#ml-software-pricing)

## Preços da infraestrutura
<a name="ml-infrastructure-pricing"></a>

Os compradores são responsáveis por todos os custos de infraestrutura da SageMaker IA ao usar seu produto. Esses custos são definidos AWS e estão disponíveis na página de [preços do Amazon SageMaker AI](https://aws.amazon.com/sagemaker/pricing/).

## Preços de software
<a name="ml-software-pricing"></a>

Você determina os preços do software que AWS Marketplace cobram do comprador pelo uso do seu produto. Você define os preços e os termos quando você adiciona seu produto de machine learning ao AWS Marketplace.

Todos os preços de infraestrutura e software por tipo de instância são apresentados ao comprador nas páginas de listagem de produtos AWS Marketplace antes que o comprador se inscreva.

**Topics**
+ [Preços gratuitos](#ml-pricing-free)
+ [Preços por hora](#ml-pricing-hourly)
+ [Preços de inferência](#ml-pricing-inference)
+ [Teste gratuito](#ml-pricing-free-trial)

### Preços gratuitos
<a name="ml-pricing-free"></a>

Você pode optar por oferecer seu produto gratuitamente. Nesse caso, o comprador paga apenas pelos custos de infraestrutura.

### Preços por hora
<a name="ml-pricing-hourly"></a>

Você pode oferecer seu produto com um preço por hora por instância do seu software executado em SageMaker IA. Você pode cobrar um preço por hora diferente para cada tipo de instância em que seu software é executado. Enquanto um comprador executa seu software, AWS Marketplace rastreia o uso e, em seguida, cobra o comprador adequadamente. O uso é proporcional ao minuto.

Para produtos de *pacotes de modelos*, o comprador pode executar seu software de duas maneiras diferentes. Ele pode hospedar um endpoint continuamente para realizar inferência em tempo real ou executar um trabalho de transformação em lote em um conjunto de dados. Você pode definir preços diferentes para as duas formas pelas quais um comprador pode executar seu software.

Para produtos de *algoritmo*, além de determinar os preços para realizar inferências, conforme mencionado anteriormente, você também determina um preço por hora para trabalhos de treinamento. Você pode cobrar um preço por hora diferente para cada tipo de instância compatível com sua imagem de treinamento.

### Preços de inferência
<a name="ml-pricing-inference"></a>

Quando o comprador executa seu software hospedando um endpoint para realizar inferências em tempo real continuamente, você pode optar por definir um preço por inferência.

**nota**  
Os seguintes tipos de produtos de ML sempre usam preços por hora:  
Trabalhos de transformação em lote
Pontos finais de inferência assíncrona
Trabalhos de treinamento para produtos de algoritmos
Você define o preço para cada tipo, independentemente do preço de inferência e um do outro.

Por padrão, com preços de inferência, AWS Marketplace cobra do comprador por cada invocação do seu endpoint. No entanto, em alguns casos, seu software processa um lote de inferências em uma única invocação (também conhecida como *mini-lote*). Para uma implantação de endpoint, você pode indicar um número personalizado de inferências que o AWS Marketplace deve cobrar do comprador por essa única invocação. Para fazer isso, inclua um cabeçalho de medição personalizado nos cabeçalhos de resposta HTTP da sua invocação, como no exemplo a seguir. Este exemplo mostra uma invocação que cobra do comprador por três inferências.

```
X-Amzn-Inference-Metering: {"Dimension": "inference.count", "ConsumedUnits": 3}
```

**nota**  
Para preços de inferência, cobra AWS Marketplace apenas do comprador as solicitações em que o código de resposta HTTP está`2XX`.

### Teste gratuito
<a name="ml-pricing-free-trial"></a>

Se desejar, você pode criar uma avaliação gratuita para seu produto e definir o número de dias da avaliação gratuita. Os testes gratuitos podem durar de 5 a 31 dias. Durante a avaliação gratuita, os compradores podem executar seu software o quanto quiserem e não serão cobrados pelo software. Os compradores são cobrados pelos custos de infraestrutura durante a avaliação gratuita. Após o término da avaliação, será cobrado o preço normal do software, juntamente com os custos de infraestrutura.

Quando os compradores assinam um produto com uma avaliação gratuitas, eles recebem uma mensagem de e-mail de boas-vindas. A mensagem inclui o prazo da avaliação gratuita, uma data de expiração calculada e detalhes sobre o cancelamento da assinatura. Uma mensagem de e-mail de lembrete é enviada três dias antes da data de expiração.

Se você oferecer um teste gratuito para seu produto em AWS Marketplace, você concorda com a [política de reembolso](https://docs.aws.amazon.com/marketplace/latest/userguide/refunds.html#refund-policy) específica para testes gratuitos. 

**nota**  
Para obter informações sobre ofertas privadas para machine learning, consulte [Ofertas privadas](https://docs.aws.amazon.com/marketplace/latest/userguide/private-offers-overview.html).

# Restrições de serviço e cotas para produtos de aprendizado de máquina em AWS Marketplace
<a name="ml-service-restrictions-and-limits"></a>

Esta seção descreve restrições e cotas em produtos de machine learning (ML) no AWS Marketplace.

**Topics**
+ [Isolamento de rede](#ml-network-isolation)
+ [Tamanho da imagem](#ml-image-size)
+ [Tamanho de armazenamento](#ml-storage-size)
+ [Tamanho da instância](#ml-instance-size)
+ [Tamanho da carga para inferência](#ml-payload-size-for-inference)
+ [Tempo de processamento para inferência](#ml-processing-time-for-inference)
+ [Cotas de serviço](#ml-service-quotas)
+ [Inferência sem servidor](#severless-inference)
+ [Treinamento gerenciado de spots](#ml-managed-spot-training)
+ [Imagens do Docker e Contas da AWS](#ml-docker-images-and-aws-accounts)
+ [Publicação de pacotes de modelos a partir de algoritmos integrados ou AWS Marketplace](#ml-publishing-model-packages-from-built-in-algorithms-or-aws-marketplace)
+ [Regiões da AWS Compatível com publicação](#ml-supported-aws-regions-for-publishing)

## Isolamento de rede
<a name="ml-network-isolation"></a>

Quando um comprador assina seu produto em contêiner, os contêineres do 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. 

## Tamanho da imagem
<a name="ml-image-size"></a>

O tamanho da imagem do Docker é controlado pelas [cotas de serviço](https://docs.aws.amazon.com/AmazonECR/latest/userguide/service_limits.html) do Amazon Elastic Container Registry (Amazon ECR). O tamanho da imagem do Docker afeta o tempo de inicialização durante o treinamento, os trabalhos de transformação em lotes e os trabalhos de criação de endpoints. Para obter o melhor desempenho, mantenha o tamanho da imagem do Docker ideal. 

## Tamanho de armazenamento
<a name="ml-storage-size"></a>

Quando você cria um endpoint, o Amazon SageMaker AI anexa um volume de armazenamento do Amazon Elastic Block Store (Amazon EBS) a cada instância de computação de ML que hospeda o endpoint. (Um endpoint também é conhecido como *inferência em tempo real* ou *serviço de hospedagem Amazon SageMaker AI*.) O tamanho do volume de armazenamento depende do tipo de instância. Para obter mais informações, consulte [Host Instance Storage Volumes](https://docs.aws.amazon.com/sagemaker/latest/dg/host-instance-storage.html) no *Amazon SageMaker AI Developer Guide*. 

Para transformação em lote, consulte [Storage in Batch Transform](https://docs.aws.amazon.com/sagemaker/latest/dg/batch-transform-storage.html) no *Amazon SageMaker AI Developer Guide*. 

## Tamanho da instância
<a name="ml-instance-size"></a>

SageMaker A IA fornece uma seleção de tipos de instância que são otimizados para se adequar a diferentes casos de uso de ML. Os tipos de instância incluem combinações variadas de CPU, GPU, memória e capacidade de rede. Os tipos de instância oferecem a flexibilidade de escolher a combinação de recursos adequada para criar, treinar e implantar os modelos de ML. Para obter mais informações, consulte [Tipos de instância do Amazon SageMaker AI ML](https://aws.amazon.com/sagemaker/pricing/instance-types/). 

## Tamanho da carga para inferência
<a name="ml-payload-size-for-inference"></a>

 Para um endpoint, limite o tamanho máximo dos dados de entrada por invocação a 25 MB. Esse valor não pode ser ajustado.

Para transformação em lote, o tamanho máximo dos dados de entrada por invocação é 100 MB. Esse valor não pode ser ajustado.

## Tempo de processamento para inferência
<a name="ml-processing-time-for-inference"></a>

Para um endpoint, o tempo de processamento máximo por invocação é de 60 segundos para respostas regulares e de 8 minutos para respostas de streaming. Esse valor não pode ser ajustado.

Para transformação em lote, o tempo máximo de processamento por invocação é de 60 minutos. Esse valor não pode ser ajustado.

## Cotas de serviço
<a name="ml-service-quotas"></a>

Para obter mais informações sobre cotas relacionadas a treinamento e inferência, consulte [Amazon SageMaker AI Service Quotas](https://docs.aws.amazon.com/general/latest/gr/sagemaker.html#limits_sagemaker). 

## Inferência sem servidor
<a name="severless-inference"></a>

Pacotes de modelos e algoritmos publicados em não AWS Marketplace podem ser implantados em endpoints configurados para [Amazon SageMaker AI Serverless](https://docs.aws.amazon.com/sagemaker/latest/dg/serverless-endpoints.html) Inference. Os endpoints configurados para inferência com tecnologia sem servidor exigem que os modelos tenham conectividade de rede. Todos os AWS Marketplace modelos operam em isolamento de rede. Para mais informações, consulte [Sem acesso à rede](https://docs.aws.amazon.com/marketplace/latest/userguide/ml-security-and-intellectual-property.html#ml-no-network-access).

## Treinamento gerenciado de spots
<a name="ml-managed-spot-training"></a>

Para todos os algoritmos do AWS Marketplace, o valor de `MaxWaitTimeInSeconds` é definido como 3.600 segundos (60 minutos), mesmo que o ponto de verificação para [treinamento pontual gerenciado](https://docs.aws.amazon.com/sagemaker/latest/dg/model-managed-spot-training.html) seja implementado. Esse valor não pode ser ajustado. 

## Imagens do Docker e Contas da AWS
<a name="ml-docker-images-and-aws-accounts"></a>

Para publicação, as imagens devem ser armazenadas nos repositórios Amazon ECR de propriedade Conta da AWS do vendedor. Não é possível publicar imagens armazenadas em um repositório de propriedade de outra pessoa Conta da AWS. 

## Publicação de pacotes de modelos a partir de algoritmos integrados ou AWS Marketplace
<a name="ml-publishing-model-packages-from-built-in-algorithms-or-aws-marketplace"></a>

Pacotes de modelos criados a partir de trabalhos de treinamento usando um [algoritmo integrado de SageMaker IA da Amazon](https://docs.aws.amazon.com/sagemaker/latest/dg/algos.html) ou um algoritmo de uma AWS Marketplace assinatura não podem ser publicados. 

Você ainda pode usar os artefatos do modelo do trabalho de treinamento, mas sua própria imagem de inferência é necessária para publicar pacotes de modelo. 

## Regiões da AWS Compatível com publicação
<a name="ml-supported-aws-regions-for-publishing"></a>

AWS Marketplace suporta recursos de pacotes de modelos e algoritmos de publicação, nos Regiões da AWS quais o seguinte é verdadeiro: 
+ Uma região que a [Amazon SageMaker AI suporta](https://aws.amazon.com/about-aws/global-infrastructure/regional-product-services/) 
+ Uma [região disponível](https://aws.amazon.com/about-aws/global-infrastructure/regional-product-services/) que é ativada por padrão (por exemplo, [describe-regions](https://docs.aws.amazon.com/general/latest/gr/rande-manage.html#ec2-describe-regions) retorna `"OptInStatus": "opt-in-not-required"`) 

Todos os ativos necessários para publicar um pacote de modelo ou produto de algoritmo devem ser armazenados na mesma região da qual você escolhe publicar. Essa transmissão inclui o seguinte: 
+ Recursos de pacotes e algoritmos de modelos criados na Amazon SageMaker AI 
+ Imagens de inferência e treinamento que são carregadas nos repositórios do Amazon ECR 
+ Artefatos de modelo (se houver) armazenados no Amazon Simple Storage Service e carregados dinamicamente durante a implantação do modelo para recursos do pacote de modelos 
+ Dados de teste para inferência e validação de treinamento armazenados no Amazon S3 

Você pode desenvolver e treinar seu produto em qualquer região que seja suportada pela SageMaker IA. Mas, antes de publicar, você deve copiar todos os ativos e recriar recursos em uma região para a qual o AWS Marketplace ofereça suporte à publicação. 

# Segurança e propriedade intelectual com a Amazon SageMaker AI
<a name="ml-security-and-intellectual-property"></a>

A Amazon SageMaker AI protege sua propriedade intelectual e os dados do comprador para modelos e algoritmos obtidos de AWS Marketplace. As seções a seguir fornecem mais informações sobre como a SageMaker IA protege a propriedade intelectual e a segurança dos dados do cliente.

**Topics**
+ [Proteção de propriedade intelectual](#ml-protecting-intellectual-property)
+ [Sem acesso à rede](#ml-no-network-access)
+ [Segurança de dados do cliente](#ml-security-of-customer-data)

## Proteção de propriedade intelectual
<a name="ml-protecting-intellectual-property"></a>

 Quando você cria um produto, o código é empacotado em imagens de contêiner do Docker. Para obter mais informações, consulte [Preparação do produto no SageMaker AI](ml-prepare-your-product-in-sagemaker.md), adiante neste guia. Quando você carrega uma imagem de contêiner, a imagem e os artefatos são criptografados em trânsito e em repouso. As imagens também são verificadas em busca de vulnerabilidades antes de serem publicadas. 

 Para ajudar a proteger sua propriedade intelectual, a SageMaker IA permite que somente compradores acessem seu produto por meio de AWS service (Serviço da AWS) endpoints. Os compradores não podem acessar ou extrair diretamente imagens de contêineres ou artefatos de modelos, nem acessar a infraestrutura subjacente. 

## Sem acesso à rede
<a name="ml-no-network-access"></a>

 Ao contrário dos modelos e algoritmos de SageMaker IA que os compradores criam, quando os compradores lançam seu produto AWS Marketplace, os modelos e algoritmos são implantados sem acesso à rede. SageMaker A IA implanta imagens em um ambiente sem acesso à rede ou aos AWS service (Serviço da AWS) endpoints. Por exemplo, uma imagem de contêiner não pode fazer chamadas de API de saída para serviços na Internet, [endpoints da VPC](https://docs.aws.amazon.com/vpc/latest/userguide/vpc-endpoints.html) ou outros Serviços da AWS. 

## Segurança de dados do cliente
<a name="ml-security-of-customer-data"></a>

 Seu produto é executado em SageMaker IA dentro do comprador Conta da AWS. Portanto, quando um comprador usa seu produto para realizar inferência de dados, você, como vendedor, não pode acessar os dados dele. 

 Para produtos de algoritmo, os artefatos do modelo são gerados pela sua imagem de treinamento após cada trabalho de treinamento. Os artefatos do modelo são armazenados na conta do comprador. Os artefatos do modelo do trabalho de treinamento são usados quando o comprador implanta o modelo com sua imagem de inferência. Para proteger qualquer propriedade intelectual que possa estar contida no artefato do modelo, criptografe-a antes de enviá-la. 

**Importante**  
 Esse modelo de segurança evita que o código acesse a internet durante o tempo de execução. Portanto, seu código não pode usar recursos ou bibliotecas da Internet, então empacote as dependências na imagem do contêiner do Docker. Isso será especialmente importante se você optar por criptografar os artefatos de saída do trabalho de treinamento. As chaves para criptografar e descriptografar artefatos não podem ser acessadas pela Internet em runtime. Eles devem ser empacotados com a imagem. 

 Para obter mais informações, consulte [Segurança na Amazon SageMaker AI](https://docs.aws.amazon.com/sagemaker/latest/dg/security.html). 

# Relatórios de aprendizado de máquina em AWS Marketplace
<a name="ml-reporting"></a>

AWS Marketplace produz relatórios para seus produtos Amazon SageMaker AI que incluem dados sobre compradores, finanças, uso e impostos. Todos os relatórios estão disponíveis Portal de gerenciamento do AWS Marketplace na [página Relatórios](https://aws.amazon.com/marketplace/management/reports). Para obter mais informações, consulte [Relatórios do vendedor](https://docs.aws.amazon.com/marketplace/latest/userguide/Reporting.html). As seções a seguir fornecem informações resumidas sobre relatórios para produtos de machine learning.

**Topics**
+ [Relatório diário de negócios](#ml-daily-business-report)
+ [Relatório da receita mensal](#ml-monthly-revenue-report)
+ [Relatório de desembolso](#ml-disbursement-report)
+ [Outros relatórios e análises](#ml-other-reports)

## Relatório diário de negócios
<a name="ml-daily-business-report"></a>

 O relatório comercial diário fornece o tipo de instância, as horas de uso, a receita das cobranças de software e outros detalhes de cada comprador e produto. Os compradores podem ser identificados pelo documento de Conta da AWS identidade. Para mais informações, consulte [Relatório comercial diário](https://docs.aws.amazon.com/marketplace/latest/userguide/daily-business-report.html). 

## Relatório da receita mensal
<a name="ml-monthly-revenue-report"></a>

 O relatório de receita mensal fornece a receita mensal que foi cobrada dos compradores pelo uso do software. Para obter mais informações, consulte [Relatório mensal de receita faturada](https://docs.aws.amazon.com/marketplace/latest/userguide/monthly-billed-revenue-report.html). 

## Relatório de desembolso
<a name="ml-disbursement-report"></a>

 O relatório mensal de desembolso fornece um detalhamento de todos os fundos coletados em seu nome durante o período de liquidação das cobranças do software. O valor total da liquidação refletido no relatório deve corresponder ao valor depositado em sua conta bancária. Para obter mais informações, consulte [Relatório de desembolso](https://docs.aws.amazon.com/marketplace/latest/userguide/monthly-disbursement-report.html). 

## Outros relatórios e análises
<a name="ml-other-reports"></a>

 Para ver outros relatórios disponíveis, consulte [Relatórios do vendedor](https://docs.aws.amazon.com/marketplace/latest/userguide/dashboards.html). 

Você também pode criar relatórios personalizados usando o [Dados de entrega do vendedor inseridos em AWS Marketplace](data-feed-service.md) disponível no AWS Marketplace.

# Preparação do produto no SageMaker AI
<a name="ml-prepare-your-product-in-sagemaker"></a>

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
<a name="ml-packaging-your-code-into-images"></a>

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?
<a name="ml-which-type-of-container-image-do-i-create"></a>

 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
<a name="ml-model-package-images"></a>

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
<a name="ml-model-package-images-overview"></a>

 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
<a name="ml-creating-an-inference-image-for-model-packages"></a>

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
<a name="ml-step-1-creating-the-container-image"></a>

 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
<a name="ml-create-the-web-server-script"></a>

 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
<a name="ml-create-the-script-for-the-container-run"></a>

 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`
<a name="ml-create-the-dockerfile"></a>

 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
<a name="ml-package-or-upload-the-model-artifacts"></a>

 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
<a name="ml-step-2-building-and-testing-the-image-locally"></a>

 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
<a name="ml-build-the-image"></a>

 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
<a name="ml-run-locally"></a>

 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
<a name="ml-test-the-ping-http-endpoint"></a>

 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
<a name="ml-test-the-inference-http-endpoint"></a>

 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
<a name="ml-algorithm-images"></a>

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
<a name="ml-algorithm-images-overview"></a>

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
<a name="ml-creating-a-training-image-for-algorithms"></a>

 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
<a name="ml-step-1-creating-the-container-image-1"></a>

 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
<a name="ml-prepare-your-program-to-read-configuration-inputs"></a>

 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
<a name="ml-prepare-your-program-to-read-data-inputs"></a>

 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/<channel_name>/` 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/<channel_name>_<epoch_number>` é 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 name="ml-prepare-your-program-to-write-training-outputs"></a>

 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
<a name="ml-create-the-script-for-the-container-run-1"></a>

 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`
<a name="ml-create-the-dockerfile-1"></a>

 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
<a name="ml-step-2-building-and-testing-the-image-locally-1"></a>

 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
<a name="ml-build-the-image-1"></a>

 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
<a name="ml-run-locally-1"></a>

 Depois de concluído, teste a imagem localmente conforme mostrado no exemplo a seguir. 

```
sudo docker run \
  --rm \
  --volume '<path_to_input>:/opt/ml/input:ro' \
  --volume '<path_to_model>:/opt/ml/model' \
  --volume '<path_to_output>:/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 '<path_to_input>:/opt/ml/input:ro'`: disponibilize o diretório de entrada de teste para o contêiner como somente leitura. 
+  `--volume '<path_to_model>:/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 '<path_to_output>:/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
<a name="ml-creating-an-inference-image-for-algorithms"></a>

 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
<a name="ml-step-1-creating-the-inference-image"></a>

 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
<a name="ml-create-the-web-server-script-1"></a>

 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
<a name="ml-create-the-script-for-the-container-run-2"></a>

 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`
<a name="ml-create-the-dockerfile-2"></a>

 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
<a name="ml-preparing-your-program-to-dynamically-load-model-artifacts"></a>

 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
<a name="ml-step-2-building-and-testing-the-image-locally-2"></a>

 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
<a name="ml-build-the-image-2"></a>

 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
<a name="ml-run-locally-2"></a>

 Depois que a criação for concluída, você poderá testar a imagem localmente. 

```
sudo docker run \
  --rm \
  --publish 8080:8080/tcp \
  --volume '<path_to_model>:/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 '<path_to_model>:/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
<a name="ml-test-the-ping-http-endpoint-1"></a>

 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
<a name="ml-test-the-inference-http-endpoint-1"></a>

 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
<a name="ml-uploading-your-images"></a>

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?
<a name="ml-which-images-must-i-upload"></a>

 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?
<a name="ml-what-iam-permissions-are-required"></a>

 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
<a name="ml-log-in-your-docker-client"></a>

 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
<a name="ml-create-repository-and-upload-image"></a>

 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: ` <account-id>.dkr.ecr.<region>.amazonaws.com/<image-repository-name>` 

 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
<a name="ml-scan-your-uploaded-image"></a>

 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
<a name="ml-creating-your-amazon-sagemaker-resource"></a>

 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
<a name="ml-creating-your-model-package-product"></a>

 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
<a name="ml-create-model-package"></a>

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
<a name="ml-creating-your-algorithm-product"></a>

 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
<a name="ml-create-algorithm"></a>

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

# Listando seu produto em AWS Marketplace
<a name="ml-publishing-your-product-in-aws-marketplace"></a>

Depois de empacotar seu código em imagens de pacotes de modelos ou imagens de algoritmos, carregar suas imagens e criar seus recursos de SageMaker IA da Amazon, você pode publicar seu produto de aprendizado de máquina no AWS Marketplace. As seções a seguir orientam você em meio ao processo de publicação, o que inclui criar a lista de produtos, testar o produto e assinar para publicação. Assim que o produto é publicado, você solicita alterações para atualizar a lista. Para obter mais informações, consulte [Gerenciamento dos produtos de machine learning](ml-product-management.md). 

**Topics**
+ [Pré-requisitos](ml-publishing-prereq.md)
+ [Etapa 1: criar uma nova lista](create-new-listing.md)
+ [Etapa 2: Fornecer informações do produto](provide-general-info.md)
+ [Etapa 3: Adicionar uma versão do produto inicial](add-initial-version.md)
+ [Etapa 4: Configurar o modelo da definição de preço](set-pricing-model.md)
+ [Etapa 5: Configurar política de reembolso](configure-refund-policy.md)
+ [Etapa 6: Configurar EULA](configure-eula.md)
+ [Etapa 7: Configurar a lista de permissões](configure-allowlist.md)

# Pré-requisitos
<a name="ml-publishing-prereq"></a>

Antes de publicar seu pacote de modelo ou algoritmo no AWS Marketplace, você deve ter o seguinte:
+  E Conta da AWS que está registrado como AWS Marketplace vendedor. Isso pode ser feito no [Portal de gerenciamento do AWS Marketplace](https://aws.amazon.com/marketplace/management/). 
+  Um perfil de vendedor completo na página [Configurações](https://aws.amazon.com/marketplace/management/seller-settings) do Portal de gerenciamento do AWS Marketplace. 
+  Para publicar produtos pagos, você deve preencher o questionário tributário e os formulários bancários. Isso não é necessário para publicar produtos gratuitos. Para obter mais informações, consulte [Processo de registro do vendedor](https://docs.aws.amazon.com/marketplace/latest/userguide/registration-process.html). 
+ Você deve ter permissões para acessar o Portal de gerenciamento do AWS Marketplace e o Amazon SageMaker AI. Para obter mais informações, consulte [Permissões obrigatórias](#ml-permissions-required).

## Permissões obrigatórias
<a name="ml-permissions-required"></a>

Para publicar um produto Amazon SageMaker AI, você deve especificar um ARN de função do IAM válido que tenha uma relação de confiança com o responsável pelo AWS Marketplace serviço. Além disso, o usuário do IAM ou a função de login conforme exigido pelas permissões necessárias.

**Definição das permissões de login**
+  Adicione as seguintes permissões ao perfil do IAM: 

  1. **sagemaker: DescribeModelPackage** — Para listar um pacote de modelos 

  1.  **sagemaker: DescribeAlgorithm** — Para listar um algoritmo 

------
#### [ JSON ]

****  

     ```
     { 
         "Version":"2012-10-17",		 	 	 
         "Statement": [ 
             { 
                 "Effect": "Allow", 
                 "Action": [ 
                     "sagemaker:DescribeModelPackage", 
                     "sagemaker:DescribeAlgorithm"
                 ],
                 "Resource": "*"  
            }
         ] 
     }
     ```

------

**Definindo o AddVersion/Create produto de função do IAM**

1. Siga as etapas para criar uma função com uma política de confiança personalizada. Para obter mais informações, consulte [Criação de um perfil do IAM usando uma política de confiança personalizada (console)](https://docs.aws.amazon.com//IAM/latest/UserGuide/id_roles_create_for-custom.html).

1. Insira o seguinte para a declaração da política de confiança personalizada:

------
#### [ JSON ]

****  

   ```
   {
       "Version":"2012-10-17",		 	 	 
       "Statement": [
           {
               "Sid": "Statement1",
               "Effect": "Allow",
               "Principal": {
                   "Service": "assets.marketplace.amazonaws.com"
               },
               "Action": "sts:AssumeRole"
           }
       ]
   }
   ```

------

1. Insira a seguinte política de permissões:

------
#### [ JSON ]

****  

   ```
   { 
       "Version":"2012-10-17",		 	 	 
       "Statement": [ 
           { 
               "Effect": "Allow", 
               "Action": [ 
                   "sagemaker:DescribeModelPackage", 
                   "sagemaker:DescribeAlgorithm"
               ],
               "Resource": "*"  
          }
       ] 
   }
   ```

------

1. Forneça o ARN da função quando solicitado. A função deve seguir o formato: `arn:aws:iam::<account-id>:role/<role-name>`.

 Para obter as AWS Marketplace permissões necessárias ou para gerenciar sua conta de vendedor, consulte [Políticas e permissões para AWS Marketplace vendedores](https://docs.aws.amazon.com/marketplace/latest/userguide/detailed-management-portal-permissions.html). 

## Ativos necessários
<a name="ml-required-assets"></a>

Antes de criar uma lista de produtos de machine learning, verifique se você tem os seguintes ativos necessários:
+ **Nome de recurso da Amazon (ARN)** — Forneça o ARN do pacote de modelo ou recurso de algoritmo no Região da AWS qual você está publicando (consulte). [Regiões da AWS Compatível com publicação](ml-service-restrictions-and-limits.md#ml-supported-aws-regions-for-publishing) 
  +  Um ARN para um pacote de modelo tem o seguinte formato: `arn:aws:sagemaker:<region>:<account-id>:model-package/<model-package-name>` 

     Para encontrar o ARN do pacote de modelos, consulte [Meus pacotes de modelos do mercado](https://console.aws.amazon.com/sagemaker/home#/model-packages/my-resources). 
  +  Um ARN para um algoritmo tem o seguinte formato: `arn:aws:sagemaker:<region>:<account-id>:algorithm/<algorithm-name>` 

     Para encontrar o ARN do recurso de algoritmo, consulte [Meus algoritmos](https://console.aws.amazon.com/sagemaker/home#/algorithms/my-resources). 
+ [Requisitos para informações de uso](ml-listing-requirements-and-best-practices.md#ml-requirements-for-usage-information): dê detalhes sobre entradas, saídas e exemplos de código. 
+  [Requisitos para entradas e saídas](ml-listing-requirements-and-best-practices.md#ml-requirements-for-inputs-and-outputs): forneça arquivos ou texto. 
+ [Requisitos para caderno Jupyter](ml-listing-requirements-and-best-practices.md#ml-requirements-for-jupyter-notebook): demonstre o uso completo do produto. 

# Etapa 1: criar uma nova lista
<a name="create-new-listing"></a>

 Para começar a usar um produto de machine learning, você iniciará o processo de listagem definindo o nome do produto, adicionando tags de recurso opcionais para a organização e gerando o ID do produto. O ID do produto é usado para rastrear seu produto durante todo o ciclo de vida. 

**nota**  
 Antes de criar a lista, verifique se você tem os recursos necessários especificados em [Requisitos e práticas recomendadas para criar produtos de machine learning](ml-listing-requirements-and-best-practices.md). 

1. Faça login na Conta da AWS do vendedor e navegue até o [Portal de gerenciamento do AWS Marketplace](https://aws.amazon.com/marketplace/management). 

1.  No menu superior, vá até **Produtos** e escolha **Machine learning**. 

1.  Escolha **Criar produto de machine learning**.

1. Em **Nome do produto**, insira um nome de produto exclusivo que será exibido para os compradores na parte superior da página de listagem dos produtos e nos resultados da pesquisa.

1.  (Opcional) Em **Tags**, insira as tags que você deseja associar ao produto. Para obter mais informações, consulte [Etiquetar recursos da AWS](https://docs.aws.amazon.com/tag-editor/latest/userguide/tagging.html). 

1.  Em **ID do produto e código**, escolha **Gerar ID do produto e código**. 

1.  Escolha **Continuar para assistente**. Você iniciará o processo de adicionar informações do produto detalhadas no assistente. 

# Etapa 2: Fornecer informações do produto
<a name="provide-general-info"></a>

 Ao listar o produto de machine learning no AWS Marketplace, o fornecimento de informações abrangentes e precisas sobre o produto é crucial. Use a etapa **Fornecer informações do produto** no assistente para capturar detalhes essenciais sobre a oferta, como categorias de produto e informações de suporte. 

1.  Insira as informações sobre o produto. 

1.  Escolha **Próximo** para avançar à próxima etapa no assistente. 

# Etapa 3: Adicionar uma versão do produto inicial
<a name="add-initial-version"></a>

 Esta página orienta você em meio à adição da versão inicial do produto. O produto pode ter várias versões em todo o ciclo de vida, e cada versão é identificada por um ARN do SageMaker AI exclusivo. 

1.  Em **Nomes do recurso da Amazon (ARNs)**: 

   1.  Insira o modelo ou o algoritmo do ARN do Amazon SageMaker AI. 
      +  ARN do pacote de modelos de exemplo: `arn:aws:sagemaker:<region>:<account-id>:model-package/<model-package-name>` 

         Para encontrar o ARN do pacote de modelos, consulte [Meus pacotes de modelos do mercado](https://console.aws.amazon.com/sagemaker/home#/model-packages/my-resources). 
      +  ARN do algoritmo de exemplo: `arn:aws:sagemaker:<region>:<account-id>:algorithm/<algorithm-name>` 

         Para encontrar o ARN do recurso de algoritmo, consulte [Meus algoritmos](https://console.aws.amazon.com/sagemaker/home#/algorithms/my-resources). 

   1.  Insira o ARN da função de acesso do IAM. 

       ARN do IAM de exemplo: `arn:aws:iam::<account-id>:role/<role-name>` 

1.  Em **Informações da versão**, insira o **Nome da versão** e as **Notas da versão**. 

1.  Em **Detalhes da entrada do modelo**, insira um resumo das entradas de modelo e forneça dados de entrada de exemplo para entradas de trabalho em lote e em tempo real. Você também pode oferecer eventuais limitações de entrada. 

1.  (Opcional) Em **Parâmetros de entrada**, dê informações detalhadas sobre cada parâmetro de entrada compatível com o produto. Você pode fornecer o nome do parâmetro, uma descrição, restrições e especificar se o parâmetro é obrigatório ou opcional. Você pode fornecer até 24 parâmetros de entrada. 

1.  (Opcional) Em **Atributos personalizados**, forneça todos os parâmetros de invocação personalizados compatíveis com o produto. Para cada atributo, você pode fornecer um nome, descrição, restrições e especificar se o atributo é obrigatório ou opcional. 

1.  Em **Detalhes da saída do modelo**, insira um resumo das saídas de modelo e forneça dados de saída de exemplo para saídas de trabalho em lote e em tempo real. Você também pode oferecer eventuais limitações de saída. 

1.  (Opcional) Em **Parâmetros de saída**, dê informações detalhadas sobre cada parâmetro de saída compatível com o produto. Você pode fornecer o nome do parâmetro, uma descrição, restrições e especificar se o parâmetro é obrigatório ou opcional. Você pode fornecer até 24 parâmetros de saída. 

1.  Em **Instruções de uso**, dê instruções claras de uso do modelo de maneira eficaz, como práticas recomendadas, como lidar com casos de borda comuns ou sugestões de otimização do desempenho. 

1.  Em **Links de caderno e repositório do Git**, dê links para cadernos de exemplo e repositórios do Git. Os cadernos de amostra devem incluir como invocar o modelo. O repositório do Git deve incluir cadernos, arquivos de dados e outras ferramentas para desenvolvedores. 

1.  Em **Tipos de instância recomendados**, selecione os tipos de instância recomendados para o produto. 

   Para *pacotes de modelos*, você selecionará os tipos de instância recomendados para transformação em lote e inferência em tempo real.

   Para *pacotes de algoritmos*, você selecionará o tipo de instância recomendado para tarefas de treinamento.
**nota**  
 Os tipos de instância disponíveis para seleção são limitados aos compatíveis com o pacote de modelos ou algoritmos. Esses tipos de instância compatíveis foram determinados quando você criou inicialmente os recursos no Amazon SageMaker AI. Isso garante que o produto só seja associado a configurações de hardware que possam executar com eficiência a solução de machine learning. 

1. Escolha **Próximo** para avançar à próxima etapa no assistente.

# Etapa 4: Configurar o modelo da definição de preço
<a name="set-pricing-model"></a>

 Ao configurar o modelo da definição de preço do produto, você pode oferecer gratuitamente o produto ou implementar a definição de preço baseada em uso. O modelo da definição de preço não poderá ser alterado depois que você tiver publicado o produto. 

1.  Escolha um modelo de preços. Os produtos de treinamento de algoritmo e transformação em lote só podem ser gratuitos ou cobrados pelo uso por hora. 
   +  Se optar por oferecer gratuitamente o produto, escolha **Avançar** e avance ao assistente. 
   +  Se você optar pela definição de preço por uso, dê continuidade a essas etapas. 

1.  Se optar por cobrar com base no uso, você poderá inserir os custos de uso. Você pode optar por inserir um preço que se aplique a todos os tipos de instância ou inserir um preço por tipo de instância para obter preços mais granulares. 

1.  Selecione **Sim, oferecer um teste gratuito** se quiser oferecer um teste gratuito do produto. 

1. Escolha **Próximo** para avançar à próxima etapa no assistente.

# Etapa 5: Configurar política de reembolso
<a name="configure-refund-policy"></a>

 Embora não precise oferecer reembolsos, você deve registrar uma política de reembolso oficial com o AWS Marketplace. 

1. Insira uma política de reembolso.

1.  Escolha **Próximo** para avançar à próxima etapa no assistente. 

# Etapa 6: Configurar EULA
<a name="configure-eula"></a>

 Nesta etapa, você escolherá o contrato legal que regerá a maneira como os clientes podem usar o produto. Você pode selecionar os termos do contrato padrão da AWS ou carregar do próprio contrato de licença do usuário final (EULA) personalizado. 

1.  Selecione o contrato padrão ou indique um contrato de licença do usuário final personalizado. 

1.  Escolha **Próximo** para avançar à próxima etapa no assistente. 

# Etapa 7: Configurar a lista de permissões
<a name="configure-allowlist"></a>

 Para enviar o produto, você precisará especificar qual Contas da AWS pode acessá-lo. Esta etapa opcional controla a visibilidade inicial do produto, limitando o acesso à própria conta e a qualquer Contas da AWS autorizada especificamente adicionada por você à lista de permissões. 

1.  Insira os IDs da Conta da AWS que você deseja que acessem o produto.

1.  Escolha **Enviar** para enviar o produto. 

    O produto terá o status de **visibilidade limitada** e só estará visível para a Conta da AWS que criou o produto e as outras Contas da AWS permitidas. 

    Para obter mais informações sobre status, consulte [Status do produto de machine learning](ml-product-lifecycle.md#ml-product-status). 

 Você pode exibir e testar a lista de produtos enquanto ela está em **Visibilidade limitada**. Quando tudo estiver pronto para alterar a visibilidade do produto, consulte [Atualização da visibilidade do produto](ml-update-visibility.md). 

# Gerenciamento dos produtos de machine learning
<a name="ml-product-management"></a>

No Portal de gerenciamento do AWS Marketplace, escolha **Solicitar alterações** para modificar um produto ou uma versão no AWS Marketplace. Quando você envia as alterações, o sistema as processa. O tempo de processamento varia de minutos a dias, dependendo do tipo de modificação. Você pode monitorar o status das alterações no Portal de gerenciamento do AWS Marketplace. 

**Topics**
+ [Atualização das informações sobre o produto](ml-update-product.md)
+ [Atualização da visibilidade do produto](ml-update-visibility.md)
+ [Atualização da lista de permissões](ml-update-allowlist.md)
+ [Gerenciamento das versões de produto](ml-manage-product-version.md)
+ [Atualização da definição de preço do produto](ml-update-public-offer.md)
+ [Atualizar sua política de reembolso](ml-update-refund-policy.md)
+ [Atualizar o EULA](ml-update-eula.md)
+ [Remoção de um produto](ml-remove-a-product.md)

**nota**  
 Além de fazer alterações por meio do Portal de gerenciamento do AWS Marketplace, você também pode fazer alterações usando o [AWS Marketplace Catalog API](https://docs.aws.amazon.com/marketplace/latest/APIReference/welcome.html). 

# Atualização das informações sobre o produto
<a name="ml-update-product"></a>

 Depois de criar o produto de machine learning (ML), você poderá modificar determinadas informações de produto no AWS Marketplace, como descrições, destaques, título, SKU, categorias e palavras-chave. 

1.  Faça login na conta do vendedor no [Portal de gerenciamento do AWS Marketplace](https://aws.amazon.com/marketplace/management/tour/). 

1.  Vá até a página **Produtos de machine learning** e selecione o produto desejado. 

1.  Escolha **Solicitar alterações** e selecione **Atualizar informações do produto**. 

1.  Atualize os campos conforme necessário. 
**nota**  
 Para obter as especificações de logotipo, consulte [Requisitos de logotipo de empresa e produto](product-submission.md#seller-and-product-logos). 

1.  Selecione **Enviar**. 

 Você pode monitorar a solicitação na guia **Solicitações** da página de produtos **Machine learning**. Para obter mais informações sobre status, consulte [Status do produto de machine learning](ml-product-lifecycle.md#ml-product-status). 

# Atualização da visibilidade do produto
<a name="ml-update-visibility"></a>

1.  Faça login na conta do vendedor no [Portal de gerenciamento do AWS Marketplace](https://aws.amazon.com/marketplace/management/tour/). 

1.  Vá até a página **Produto de machine learning** e selecione o produto. 

1.  Escolha **Solicitar alterações**, selecione **Atualizar visibilidade do produto** e **Público** ou **Restrito**. 

1.  Revise as alterações e escolha **Enviar**. 

 Você pode monitorar a solicitação na guia **Solicitações** da página de produtos **Machine learning**. Para obter mais informações sobre status, consulte [Status do produto de machine learning](ml-product-lifecycle.md#ml-product-status). 

# Atualização da lista de permissões
<a name="ml-update-allowlist"></a>

1.  Faça login na conta do vendedor no [Portal de gerenciamento do AWS Marketplace](https://aws.amazon.com/marketplace/management/tour/). 

1.  Vá até a página **Produto de machine learning** e selecione o produto. 

1.  Escolha **Solicitar alterações** e selecione **Atualizar lista de permissões**. 

1.  Modifique as informações que você precisa alterar e escolha **Enviar**. Para obter mais informações, consulte [Etapa 7: Configurar a lista de permissões](configure-allowlist.md). 

 Você pode monitorar a solicitação na guia **Solicitações** da página de produtos **Machine learning**. Para obter mais informações sobre status, consulte [Status do produto de machine learning](ml-product-lifecycle.md#ml-product-status). 

# Gerenciamento das versões de produto
<a name="ml-manage-product-version"></a>

 Como vendedor, você pode gerenciar as versões do produto AWS Marketplace atualizando as informações da versão existente, adicionando novas versões ou removendo versões que não sejam mais compatíveis. Cada versão tem um ARN do SageMaker AI exclusivo e informações associadas usadas pelos compradores para avaliar e implantar o produto. 

**nota**  
 Antes de adicionar versões, crie uma ID do produto e estabeleça uma definição de preço. Para obter mais informações, consulte [Etapa 1: criar uma nova lista](create-new-listing.md). 

## Atualização das informações da versão
<a name="ml-updating-versions"></a>

 Depois de criar uma versão, você poderá modificar as informações associadas, como notas de versão, instruções de uso e recomendações de instância. 

**nota**  
 Os nomes da versão e os ARNs não podem ser modificados. Essas alterações exigem a criação de uma nova versão. 

1.  Faça login na conta do vendedor no [Portal de gerenciamento do AWS Marketplace](https://aws.amazon.com/marketplace/management/tour/). 

1.  Vá até a página **Produto de machine learning** e selecione o produto. 

1.  Escolha **Solicitar alterações** e selecione **Atualizar informações da versão**. 

1.  Selecione a versão que você deseja atualizar. 

1.  Escolha **Editar versão**. 

1.  Modifique os campos necessários e escolha **Próximo**. 

1.  Insira as informações da definição de preço e escolha **Enviar**. Para obter mais informações, consulte [Etapa 4: Configurar o modelo da definição de preço](set-pricing-model.md). 

 Você pode monitorar a solicitação na guia **Solicitações** da página de produtos **Machine learning**. Para obter mais informações sobre status, consulte [Status do produto de machine learning](ml-product-lifecycle.md#ml-product-status). 

## Adição de novas versões
<a name="ml-adding-new-versions"></a>

 Você pode adicionar novas versões do produto para introduzir atributos, atualizações ou melhorias, mantendo acesso atributo versões anteriores. 

1.  Faça login na conta do vendedor no [Portal de gerenciamento do AWS Marketplace](https://aws.amazon.com/marketplace/management/tour/). 

1.  Vá até a página **Produto de machine learning** e selecione o produto. 

1.  Escolha **Versões** e **Adicionar nova versão**. 

1.  Insira informações da nova versão seguindo as etapas em [Etapa 3: Adicionar uma versão do produto inicial](add-initial-version.md). 

1.  Insira as informações da definição de preço e escolha **Enviar**. Para obter mais informações, consulte [Etapa 4: Configurar o modelo da definição de preço](set-pricing-model.md). 

Quando você tiver adicionado com êxito uma nova versão, os compradores receberão uma notificação por e-mail de que há uma nova versão disponível.

## Restrições de versões
<a name="ml-restricting-versions"></a>

 Quando uma versão fica desatualizada ou você deseja descontinuar a disponibilidade, você pode restringir o acesso do comprador a essa versão, ao mesmo tempo em que mantém o acesso a outras versões. 

1.  Faça login na conta do vendedor no [Portal de gerenciamento do AWS Marketplace](https://aws.amazon.com/marketplace/management/tour/). 

1.  Vá até a página **Produto de machine learning** e selecione o produto. 

1.  Escolha **Versões** e **Restringir versões**. 
**nota**  
 Você deve sempre ter pelo menos uma versão disponível. 

1.  Selecione **Enviar**. 

 Quando você tiver restringido uma versão com êxito, os compradores receberão uma notificação por e-mail informando que a versão foi restrita. 

# Atualização da definição de preço do produto
<a name="ml-update-public-offer"></a>

 Você pode modificar as taxas e o período de teste gratuito do produto de machine learning no AWS Marketplace, embora o modelo da definição de preço propriamente dito não possa ser alterado. Para modelos pagos, os aumentos de preço entram em vigor após um período de aviso prévio de 90 dias, no primeiro dia do mês seguinte. Alterações de preço adicionais não podem ser feitas durante esse período de aviso. 

1.  Faça login na conta do vendedor no [Portal de gerenciamento do AWS Marketplace](https://aws.amazon.com/marketplace/management/tour/). 

1.  Vá até a página **Produto de machine learning** e selecione o produto. 

1.  Escolha **Solicitar alterações**, selecione **Atualizar oferta pública** e **Editar informações da oferta**. 

1.  Modifique as informações que você precisa alterar e escolha **Enviar**. 

 Você pode monitorar a solicitação na guia **Solicitações** da página de produtos **Machine learning**. Para obter mais informações sobre status, consulte [Status do produto de machine learning](ml-product-lifecycle.md#ml-product-status). 

# Atualizar sua política de reembolso
<a name="ml-update-refund-policy"></a>

1.  Faça login na conta do vendedor no [Portal de gerenciamento do AWS Marketplace](https://aws.amazon.com/marketplace/management/tour/). 

1.  Vá até a página **Produto de machine learning** e selecione o produto. 

1.  Escolha **Solicitar alterações**, selecione **Atualizar oferta pública** e **Atualizar política de reembolso**. 

1.  Modifique as informações que você precisa alterar e escolha **Enviar**. 

 Você pode monitorar a solicitação na guia **Solicitações** da página de produtos **Machine learning**. Para obter mais informações sobre status, consulte [Status do produto de machine learning](ml-product-lifecycle.md#ml-product-status). 

# Atualizar o EULA
<a name="ml-update-eula"></a>

1.  Faça login na conta do vendedor no [Portal de gerenciamento do AWS Marketplace](https://aws.amazon.com/marketplace/management/tour/). 

1.  Vá até a página **Produto de machine learning** e selecione o produto. 

1.  Escolha **Solicitar alterações**, selecione **Atualizar oferta pública** e **Atualizar EULA**. 

1.  Modifique as informações que você precisa alterar e escolha **Enviar**. 

 Você pode monitorar a solicitação na guia **Solicitações** da página de produtos **Machine learning**. Para obter mais informações sobre status, consulte [Status do produto de machine learning](ml-product-lifecycle.md#ml-product-status). 

# Remoção de um produto
<a name="ml-remove-a-product"></a>

 Você pode remover (desativar) o produto publicado do AWS Marketplace. Depois de removidos, os novos clientes não poderão assinar, mas você deve dar suporte a clientes existentes por pelo menos 90 dias. 

 Estas são as condições de remoção de um produto do AWS Marketplace: 
+  O produto será removido das ferramentas de pesquisa e descoberta do AWS Marketplace. 
+  A funcionalidade de assinatura será desabilitada. 
+  A página de detalhes do produto permanece acessível por meio do URL direto. 
+  Os assinantes atuais reterão acesso ao software até cancelarem a assinatura. 
+  O AWS Marketplace notifica os compradores atuais da remoção. 

**Para remover o produto de machine learning:**

1.  Faça login na conta do vendedor no [Portal de gerenciamento do AWS Marketplace](https://aws.amazon.com/marketplace/management/tour/). 

1.  Vá até a página **Produto de machine learning** e selecione o produto. 

1.  Escolha **Solicitar alterações**, selecione **Atualizar visibilidade do produto** e **Restrito**. 

1.  (Opcional) Insira um ID do produto de substituição. 

1.  Revise as alterações e escolha **Enviar**. 

 Você pode monitorar a solicitação na guia **Solicitações** da página de produtos **Machine learning**. Para obter mais informações sobre status, consulte [Status do produto de machine learning](ml-product-lifecycle.md#ml-product-status). 

 Depois de removido, o produto será exibido na lista **Produtos atuais**, na qual você só poderá baixar planilhas de produtos. Se você tiver dúvidas sobre como remover produtos, entre em contato com a equipe de [Operações de vendedor do AWS Marketplace](https://aws.amazon.com/marketplace/management/contact-us/). 

# Criação de ofertas privadas para produtos de machine learning
<a name="machine-learning-private-offers"></a>

 Você pode negociar e oferecer diretamente uma oferta privada aos clientes para os produtos de machine learning. Para obter mais informações sobre ofertas privadas, consulte [Preparando uma oferta privada para seu AWS Marketplace produto](private-offers-overview.md). 

**Pré-requisitos:**
+  Você deve ter um anúncio pago em AWS Marketplace. 
+  Você deve ter acesso ao Portal AWS Marketplace de Gerenciamento (AMMP). 

**Para criar uma oferta privada para um produto de machine learning:**

1.  Faça login no Portal AWS Marketplace de Gerenciamento. 

1. Escolha **Ofertas** e **Criar uma oferta privada**

1.  Na página **Criar oferta privada**, selecione o produto para o qual você deseja criar uma oferta privada. Você só pode criar ofertas para produtos disponíveis. 

1.  Na página **Detalhes da oferta**: 

   1.  Insira o nome e a descrição da oferta. 

   1.  Selecione a opção de renovação. 

   1.  Defina a data de expiração da oferta. As ofertas expiram às 23:59:59 UTC na data definida. 

1. Escolha **Next** (Próximo) duas vezes.

1.  Na página **Configurar definição de preço e duração da oferta**, especifique: 
   +  Opções de definição de preço

     (Para obter mais informações, consulte [Ofertas privadas para produtos de ML](https://docs.aws.amazon.com/marketplace/latest/userguide/private-offers-supported-product-types.html#ml-private-offers))
   + Uso ou duração do contrato
   + Moeda da oferta
   + Dimensões de preços.

     (Para preços de uso, as tarifas baseadas no uso só se aplicam durante o período da oferta. Para contratos, as tarifas baseadas no uso só se aplicam quando a vigência do contrato expira e são perpétuas.)
**nota**  
Para obter mais informações sobre planos de parcelamento, consulte [Planos de parcelamento da oferta privada](installment-plans.md). 

1. Escolha **Próximo**.

1. Na página **Adicionar compradores**, insira Conta da AWS IDs para seus compradores. Escolha **Próximo**. 
**Importante**  
Para contas vinculadas aproveitarem uma oferta privada:  
Inclua o ID da AWS conta do pagador.
A conta do pagador deve aceitar os termos por hora da oferta privada primeiro.
Depois que a conta do pagador aceitar, as contas vinculadas poderão aceitar a oferta privada.

1. Na página **Configurar termos legais e documentos da oferta**, adicione todos os termos personalizados e escolha **Avançar**.
**nota**  
 Você pode adicionar até cinco arquivos (termos legais, declaração de trabalho, lista de materiais, planilha da definição de preço ou adendos). O sistema os combina em um único documento. 

1. Na página **Analisar e criar**, verifique os detalhes da oferta e escolha **Criar oferta**.

1. Depois que a oferta for exibida na página **Gerenciar ofertas privadas**, abra o menu **Ações**, escolha **Copiar URL da oferta** e a envie por e-mail para o comprador.
**nota**  
 As ofertas podem demorar para serem publicadas. Você poderá editar ofertas na página **Gerenciar ofertas privadas** até um comprador aceitar. 

# Requisitos e práticas recomendadas para criar produtos de machine learning
<a name="ml-listing-requirements-and-best-practices"></a>

É importante que os compradores achem fácil testar seu pacote de modelo e produtos de algoritmo. As seções a seguir descrevem práticas recomendadas para produtos de ML. Para obter um resumo completo dos requisitos e recomendações, consulte a [Resumo dos requisitos e recomendações para listagens de produtos de ML](#ml-summary-table-of-requirements-and-recommendations).

**nota**  
Um AWS Marketplace representante pode entrar em contato com você para ajudá-lo a atender a esses requisitos, caso seus produtos publicados não os atendam.

**Topics**
+ [Práticas recomendadas gerais para produtos de ML](#ml-general-best-practices)
+ [Requisitos para informações de uso](#ml-requirements-for-usage-information)
+ [Requisitos para entradas e saídas](#ml-requirements-for-inputs-and-outputs)
+ [Requisitos para caderno Jupyter](#ml-requirements-for-jupyter-notebook)
+ [Resumo dos requisitos e recomendações para listagens de produtos de ML](#ml-summary-table-of-requirements-and-recommendations)

## Práticas recomendadas gerais para produtos de ML
<a name="ml-general-best-practices"></a>

 Forneça as seguintes informações para seu produto de machine learning: 
+  Para obter descrições de produtos, inclua o seguinte: 
  +  O que seu modelo faz 
  +  Quem é o cliente-alvo 
  +  Qual é o caso de uso mais importante 
  +  Como seu modelo foi treinado ou a quantidade de dados usada 
  +  Quais são as métricas de desempenho e os dados de validação usados 
  +  Se for médico, se o modelo é ou não para uso em diagnóstico 
+ Por padrão, os produtos de machine learning são configurados para ter visibilidade pública. No entanto, você pode criar um produto com visibilidade limitada. Para obter mais informações, consulte [Etapa 7: Configurar a lista de permissões](configure-allowlist.md).
+  (Opcional) Para produtos pagos, ofereça uma avaliação gratuita de 14 a 30 dias para que os clientes experimentem seu produto. Para obter mais informações, consulte [Preços de produtos de aprendizado de máquina para AWS Marketplace](machine-learning-pricing.md). 

## Requisitos para informações de uso
<a name="ml-requirements-for-usage-information"></a>

Informações claras de uso que descrevam as entradas e saídas esperadas do produto (com exemplos) são cruciais para promover uma experiência positiva para o comprador. 

Com cada nova versão do recurso adicionada à lista de produtos, você deve fornecer informações de uso. 

Para editar as informações de uso existentes de uma versão específica, consulte [Atualização das informações da versão](ml-manage-product-version.md#ml-updating-versions).

## Requisitos para entradas e saídas
<a name="ml-requirements-for-inputs-and-outputs"></a>

Uma explicação clara dos parâmetros de entrada compatíveis e dos parâmetros de saída retornados com exemplos é importante ajudar os compradores a compreender e usar o produto. Esse entendimento ajuda os compradores a realizar as transformações necessárias nos dados de entrada para obter os melhores resultados de inferência. 

Você será solicitado a fornecer o seguinte ao adicionar seu recurso de SageMaker inteligência artificial da Amazon à sua lista de produtos.

### Entradas e saídas de inferência
<a name="ml-inference-inputs-and-outputs"></a>

Para entrada de inferência, dê uma descrição dos dados de entrada esperados pelo produto para o endpoint em tempo real e o trabalho de transformação em lote. Inclua snippets de código para qualquer pré-processamento necessário dos dados. Inclua limitações, se aplicável. Forneça amostras de entrada hospedadas em [GitHub](https://github.com).

Para a saída de inferência, dê uma descrição dos dados de saída retornados para o endpoint em tempo real e o trabalho de transformação em lote. Inclua limitações, se aplicável. Forneça amostras de saída hospedadas em [GitHub](https://github.com). 

Para amostras, forneça arquivos de entrada que funcionem com seu produto. Se o modelo executar a classificação multiclasse, forneça pelo menos um arquivo de entrada de amostra para cada uma das classes. 

### Entradas de treinamento
<a name="ml-training-inputs"></a>

Na seção **Informações para treinar um modelo**, forneça o formato dos dados de entrada e os snippets de código para qualquer pré-processamento necessário dos dados. Inclua uma descrição de valores e limitações, se aplicável. Forneça amostras de entrada hospedadas em [GitHub](https://github.com). 

Explique os recursos opcionais e obrigatórios que podem ser fornecidos pelo comprador e especifique se o modo de entrada `PIPE` é compatível. Se houver suporte 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) (treinamento com mais de uma CPU/GPU instância), especifique isso. Para ajustar, liste os hiperparâmetros recomendados. 

## Requisitos para caderno Jupyter
<a name="ml-requirements-for-jupyter-notebook"></a>

Ao adicionar seu recurso de SageMaker IA à sua lista de produtos, forneça um link para um exemplo de notebook Jupyter hospedado em [GitHub](https://github.com)que demonstre o fluxo de trabalho completo sem solicitar que o comprador faça upload ou encontre dados. 

Use a AWS SDK para Python (Boto). Um caderno de amostra bem desenvolvido torna mais fácil para os compradores tentarem usar sua lista. 

Para produtos de pacotes de modelo, o caderno de amostra demonstra a preparação dos dados de entrada, a criação de um endpoint para inferência em tempo real e o desempenho de trabalhos de transformação em lote. Para obter mais informações, consulte a [lista do Model Package e o exemplo de caderno](https://github.com/aws/amazon-sagemaker-examples/tree/main/aws_marketplace/curating_aws_marketplace_listing_and_sample_notebook/ModelPackage) em GitHub. Para ver um exemplo de caderno, consulte [auto\$1insurance](https://github.com/awslabs/amazon-sagemaker-examples/tree/master/aws_marketplace/using_model_packages/auto_insurance). O notebook funciona em tudo Regiões da AWS, sem inserir nenhum parâmetro e sem que o comprador precise localizar os dados da amostra.

**nota**  
Um exemplo de caderno Jupyter subdesenvolvido que não mostra várias entradas possíveis e etapas de pré-processamento de dados pode dificultar que o comprador entenda completamente a proposta de valor do seu produto. 

Para produtos de algoritmo, o caderno de amostra demonstra treinamento completo, ajuste, criação de modelos, criação de um endpoint para inferência em tempo real e o desempenho de trabalhos de transformação em lote. Para obter mais informações, consulte [Lista de algoritmos e Exemplo de caderno de anotações](https://github.com/awslabs/amazon-sagemaker-examples/tree/master/aws_marketplace/curating_aws_marketplace_listing_and_sample_notebook/Algorithm) em GitHub. [Para exemplos de cadernos, consulte [amazon\$1demo\$1product](https://github.com/awslabs/amazon-sagemaker-examples/tree/master/aws_marketplace/using_algorithms/amazon_demo_product) e automl on.](https://github.com/awslabs/amazon-sagemaker-examples/tree/master/aws_marketplace/using_algorithms/automl) GitHub Esses cadernos de amostra funcionam em todas as regiões sem inserir nenhum parâmetro e sem que o comprador precise localizar dados de amostra. 

**nota**  
A falta de dados de treinamento de exemplo impede que o comprador execute o caderno Jupyter com êxito. Um caderno de exemplo subdesenvolvido pode impedir que os compradores usem seu produto e dificultar a adoção. 

## Resumo dos requisitos e recomendações para listagens de produtos de ML
<a name="ml-summary-table-of-requirements-and-recommendations"></a>

A tabela a seguir fornece um resumo dos requisitos e das recomendações para uma página de listagem de produtos de machine learning.


|  **Detalhes**  |  **Para listas de pacotes de modelo**  |  **Para listas de algoritmos**  | 
| --- |--- |--- |
| **Product descriptions** | 
| --- |
| Explique em detalhes o que o produto faz com os tipos de conteúdo compatíveis (por exemplo, “detecta X em imagens”).  |  Obrigatório  |  Obrigatório  | 
| Forneça informações convincentes e diferenciadoras sobre o produto (evite adjetivos como “melhor” ou afirmações infundadas).  |  Recomendado  |  Recomendado  | 
| Liste os casos de uso mais importantes desse produto.  |  Obrigatório  |  Obrigatório  | 
| Descreva os dados (fonte e tamanho) nos quais ele foi treinado e liste todas as limitações conhecidas.  |  Obrigatório  |  Não aplicável | 
| Descreva a estrutura principal na qual o modelo foi construído.  |  Recomendado  |  Recomendado  | 
| Resuma a métrica de desempenho do modelo nos dados de validação (por exemplo, “XX.YY percentual de precisão comparada usando o conjunto de dados Z”).  |  Obrigatório  |  Não aplicável | 
| Resuma as métricas de taxa de and/or transferência de latência do modelo no tipo de instância recomendado.  |  Obrigatório  |  Não aplicável | 
| Descreva a categoria do algoritmo. Por exemplo, “Esse algoritmo de regressão da floresta de decisão é baseado em um conjunto de classificadores estruturados em árvore que são construídos usando a técnica geral de agregação de bootstrap e uma escolha aleatória de recursos”.  |  Não aplicável |  Obrigatório  | 
| **Usage information** | 
| --- |
| Para inferência, forneça uma descrição do formato de entrada esperado para o endpoint em tempo real e o trabalho de transformação em lote. Inclua limitações, se aplicável. Consulte [Requisitos para entradas e saídas](#ml-requirements-for-inputs-and-outputs).  |  Obrigatório  |  Obrigatório  | 
| Para inferência, forneça amostras de entrada para o endpoint em tempo real e o trabalho de transformação em lote. As amostras devem ser hospedadas em GitHub. Consulte [Requisitos para entradas e saídas](#ml-requirements-for-inputs-and-outputs).  |  Obrigatório  |  Obrigatório  | 
| Para inferência, forneça o nome e a descrição de cada parâmetro de entrada. Forneça detalhes sobre suas limitações e especifique se é obrigatório ou opcional. | Recomendado | Recomendado | 
| Para inferência, forneça detalhes sobre os dados de saída que seu produto retorna tanto para o endpoint em tempo real quanto para o trabalho de transformação em lote. Inclua quaisquer limitações, se aplicável. Consulte [Requisitos para entradas e saídas](#ml-requirements-for-inputs-and-outputs).  |  Obrigatório  |  Obrigatório  | 
| Para inferência, forneça amostras de saída para o endpoint em tempo real e o trabalho de transformação em lote. As amostras devem ser hospedadas em GitHub. Consulte [Requisitos para entradas e saídas](#ml-requirements-for-inputs-and-outputs).  |  Obrigatório  |  Obrigatório  | 
| Para inferência, forneça um exemplo do uso de um trabalho de transformação de endpoint ou lote. Inclua um exemplo de código usando os comandos AWS Command Line Interface (AWS CLI) ou usando um AWS SDK.  |  Obrigatório  |  Obrigatório  | 
| Para inferência, forneça o nome e a descrição de cada parâmetro de saída. Especifique se ele é sempre retornado.  | Recomendado | Recomendado | 
| Para treinamento, forneça detalhes sobre as informações necessárias para treinar o modelo, como linhas mínimas de dados necessárias. Veja[Requisitos para entradas e saídas](#ml-requirements-for-inputs-and-outputs).  |  Não aplicável |  Obrigatório  | 
| Para treinamento, forneça amostras de entrada hospedadas em GitHub. Consulte [Requisitos para entradas e saídas](#ml-requirements-for-inputs-and-outputs).  |  Não aplicável |  Obrigatório  | 
| Para treinamento, forneça um exemplo de execução de trabalhos de treinamento. Descreva os hiperparâmetros suportados, seus intervalos e seu impacto geral. Especifique se o algoritmo é compatível com ajuste de hiperparâmetros, treinamento distribuído ou instâncias de GPU. Inclua exemplos de código, como AWS CLI comandos ou usando um AWS SDK, por exemplo.  |  Não aplicável |  Obrigatório  | 
| Forneça um notebook Jupyter hospedado para GitHub demonstrar o uso completo do seu produto. Consulte [Requisitos para caderno Jupyter](#ml-requirements-for-jupyter-notebook).  |  Obrigatório  |  Obrigatório  | 
| Forneça informações técnicas relacionadas ao uso do produto, incluindo manuais do usuário e dados de amostra.  |  Recomendado  |  Recomendado  | 

# Solução de problemas com produtos de machine learning
<a name="ml-troubleshooting"></a>

 Esta seção fornece ajuda para alguns erros comuns que você pode encontrar durante o processo de publicação do produto de machine learning. Se o problema não estiver listado, entre em contato com a equipe de [operações do vendedor do AWS Marketplace](https://aws.amazon.com/marketplace/management/contact-us/). 

## Geral: recebo um erro 400 quando adiciono o Amazon Resource Name (ARN) do meu pacote de modelo ou algoritmo no Portal de gerenciamento do AWS Marketplace
<a name="troubleshooting_error_code_400"></a>

### Causa comum
<a name="troubleshooting_common_cause"></a>

 Ao criar seu produto de aprendizado de máquina em SageMaker IA, você não optou por publicá-lo em AWS Marketplace. 

### Resolução
<a name="troubleshooting_resolution"></a>

 Se você usou o console Amazon SageMaker AI para criar seu recurso, você deve escolher **Sim** na página final do processo para **Publicar este pacote de modelo em AWS Marketplace** ou **Sim** para **Publicar este algoritmo em AWS Marketplace**. Você não pode escolher **Não** e depois publicá-lo. Selecionar **Sim** não publica o pacote de modelo ou o algoritmo. No entanto, isso valida o pacote de modelo ou recurso de algoritmo quando ele é criado, o que é necessário para uso no AWS Marketplace.

 Se você estiver usando o AWS SDK para [criar um pacote de modelos](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_CreateModelPackage.html#sagemaker-CreateModelPackage-request-CertifyForMarketplace) ou [criar um algoritmo](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_CreateAlgorithm.html#sagemaker-CreateAlgorithm-request-CertifyForMarketplace), verifique se o parâmetro `CertifyForMarketplace` está definido como. `true` 

Depois de recriar o pacote de modelo certificado e validado ou recurso de algoritmo, adicione o novo ARN no Portal de gerenciamento do AWS Marketplace. 

## Geral: recebo um erro 404 quando adiciono o ARN do meu pacote de modelo ou algoritmo no Portal de gerenciamento do AWS Marketplace
<a name="troubleshooting_error_code_404"></a>

### Causa comum
<a name="troubleshooting_common_cause"></a>

 Esse erro pode acontecer por vários motivos: 
+  O ARN pode ser inválido. 
+  O pacote do modelo ou o recurso de algoritmo não foi criado da Conta da AWS mesma forma que a conta do vendedor. 
+  O usuário ou a função que você usa para publicar não tem as permissões corretas do IAM para acessar o pacote do modelo ou o recurso do algoritmo. 

### Resolução
<a name="troubleshooting_resolution"></a>

1.  Verifique o ARN para garantir que ele seja o ARN correto e esteja no formato esperado: 

    Para pacotes de modelos, o ARNs deve ser semelhante `arn:aws:sagemaker:us-east-2:000123456789:model-package/my-model-package-name` a. 

    Para algoritmos, o ARNs deve ser semelhante `arn:aws:sagemaker:us-east-2:000123456789:algorithm/my-algorithm` a. 

1.  Certifique-se de que todos os recursos e ativos para publicação estejam na conta de vendedor da qual você está publicando. 

1.  Certifique-se de que seu usuário ou sua função do tenha as seguintes permissões: 

    Para pacotes de modelo, a ação `sagemaker:DescribeModelPackage` no recurso do pacote de modelo deve ser permitida. 

    Para algoritmos, a ação `sagemaker:DescribeAlgorithm` no recurso do algoritmo deve ser permitida. 

## Amazon SageMaker AI: recebo a mensagem de falha “Erro do cliente: acesso negado para registro” quando crio um pacote de modelo ou recurso de algoritmo
<a name="troubleshooting_error_sm_access_denied"></a>

### Causa comum
<a name="troubleshooting_common_cause"></a>

Esse erro pode ocorrer quando a imagem que está sendo usada para criar o pacote ou algoritmo do modelo é armazenada em um repositório do [Amazon ECR](https://aws.amazon.com/ecr/) que pertence a outra Conta da AWS. A validação do pacote ou do algoritmo do modelo não é compatível com imagens de contas cruzadas.

### Resolução
<a name="troubleshooting_resolution"></a>

Copie a imagem para um repositório Amazon ECR de propriedade do Conta da AWS que você está usando para publicar. Em seguida, continue criando o recurso usando o novo local da imagem.

## Amazon SageMaker AI: recebo “Não iniciado” e “Erro do cliente: nenhuma verificação agendada...” quando eu crio um pacote de modelo ou recurso de algoritmo
<a name="troubleshooting_error_sm_failure"></a>

### Causa comum
<a name="troubleshooting_common_cause"></a>

Esse erro pode ocorrer quando a SageMaker IA falha em iniciar uma varredura da imagem do contêiner Docker armazenada no Amazon ECR.

### Resolução
<a name="troubleshooting_resolution"></a>

Se isso acontecer, abra o [console do Amazon ECR](https://console.aws.amazon.com/ecr/repositories?region=us-east-2), encontre o repositório no qual a imagem foi carregada, escolha a imagem e escolha **Verificar**.