Pré-requisitos para usar o Amazon Inference Recommender SageMaker

Antes de usar o Amazon SageMaker Inference Recommender, você deve concluir as etapas de pré-requisito. Como exemplo, mostramos como usar um modelo pré-treinado PyTorch (v1.7.1) ResNet -18 para os dois tipos de trabalhos de recomendação do Amazon SageMaker Inference Recommender. Os exemplos mostrados usam AWS SDK for Python (Boto3) o.

nota

Os exemplos a seguir foram criados em Python. Remova o caractere de prefixo ! se você executar qualquer um dos seguintes exemplos de código no seu terminal ou AWS CLI.
Você pode executar os exemplos a seguir com o kernel Python 3 (2.6 TensorFlow Python 3.8 CPU Optimized) em um notebook Amazon Studio. SageMaker Para obter mais informações sobre o Studio, consulte SageMaker Estúdio Amazon.

Crie uma IAM função para a Amazon SageMaker.

Crie uma IAM função para a Amazon SageMaker que tenha a política AmazonSageMakerFullAccess IAM gerenciada anexada.

Configure seu ambiente.

Importe dependências e crie variáveis para você Região da AWS, sua SageMaker IAM função (da Etapa 1) e para o SageMaker cliente.


!pip install --upgrade pip awscli botocore boto3  --quiet
from sagemaker import get_execution_role, Session, image_uris
import boto3

region = boto3.Session().region_name
role = get_execution_role()
sagemaker_client = boto3.client("sagemaker", region_name=region)
sagemaker_session = Session()

(Opcional) Analise os modelos existentes comparados pelo recomendador de inferência.

O recomendador de inferência compara modelos de zoológicos populares. O recomendador de inferência oferece suporte ao seu modelo, mesmo que ele ainda não tenha sido comparado.

Use ListModelMetaData para obter um objeto de resposta que lista o domínio, a estrutura, a tarefa e o nome do modelo dos modelos de machine learning encontrados em zoológicos comuns.

Você usa o domínio, a estrutura, a versão da estrutura, a tarefa e o nome do modelo em etapas posteriores para selecionar uma imagem de inferência do Docker e registrar seu modelo no Model Registry SageMaker . O seguinte demonstra como listar os metadados do modelo com SDK for Python (Boto3):


list_model_metadata_response=sagemaker_client.list_model_metadata()

A saída inclui resumos do modelo (ModelMetadataSummaries) e metadados de resposta (ResponseMetadata) semelhantes ao exemplo a seguir:


{
    'ModelMetadataSummaries': [{
            'Domain': 'NATURAL_LANGUAGE_PROCESSING',
            'Framework': 'PYTORCH:1.6.0',
             'Model': 'bert-base-cased',
             'Task': 'FILL_MASK'
             },
            {
             'Domain': 'NATURAL_LANGUAGE_PROCESSING',
             'Framework': 'PYTORCH:1.6.0',
             'Model': 'bert-base-uncased',
             'Task': 'FILL_MASK'
             },
            {
            'Domain': 'COMPUTER_VISION',
             'Framework': 'MXNET:1.8.0',
             'Model': 'resnet18v2-gluon',
             'Task': 'IMAGE_CLASSIFICATION'
             },
             {
             'Domain': 'COMPUTER_VISION',
             'Framework': 'PYTORCH:1.6.0',
             'Model': 'resnet152',
             'Task': 'IMAGE_CLASSIFICATION'
             }],
    'ResponseMetadata': {
                            'HTTPHeaders': {
                            'content-length': '2345',
                            'content-type': 'application/x-amz-json-1.1',
                            'date': 'Tue, 19 Oct 2021 20:52:03 GMT',
                            'x-amzn-requestid': 'xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx'
                          },
    'HTTPStatusCode': 200,
    'RequestId': 'xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx',
    'RetryAttempts': 0
    }
}

Para esta demonstração, usamos um modelo PyTorch (v1.7.1) ResNet -18 para realizar a classificação de imagens. O exemplo de código Python a seguir armazena a framework, a versão da estrutura, o domínio e a tarefa em variáveis para uso posterior:


# ML framework details
framework = 'pytorch'
framework_version = '1.7.1'

# ML model details
ml_domain = 'COMPUTER_VISION'
ml_task = 'IMAGE_CLASSIFICATION'

Faça o upload do seu modelo de machine learning para o Amazon S3.

Use este modelo PyTorch (v1.7.1) ResNet -18 se você não tiver um modelo de aprendizado de máquina pré-treinado:
```
# Optional: Download a sample PyTorch model
import torch
from torchvision import models, transforms, datasets

# Create an example input for tracing
image = torch.zeros([1, 3, 256, 256], dtype=torch.float32)

# Load a pretrained resnet18 model from TorchHub
model = models.resnet18(pretrained=True)

# Tell the model we are using it for evaluation (not training). Note this is required for Inferentia compilation.
model.eval()
model_trace = torch.jit.trace(model, image)

# Save your traced model
model_trace.save('model.pth')
```
Faça download de um exemplo de script inference.py de inferência. Crie um code diretório e mova o script de inferência para o diretório code.
```
# Download the inference script
!wget https://aws-ml-blog-artifacts.s3.us-east-2.amazonaws.com/inference.py

# move it into a code/ directory
!mkdir code
!mv inference.py code/
```
A Amazon SageMaker exige que modelos de aprendizado de máquina pré-treinados sejam empacotados como um TAR arquivo compactado (). *.tar.gz Comprima seu modelo e script de inferência para atender a esse requisito:
```
!tar -czf test.tar.gz model.pth code/inference.py
```
Quando seu endpoint é provisionado, os arquivos no arquivamento são extraídos para /opt/ml/model/ o endpoint.

Depois de compactar o modelo e os artefatos do modelo como um .tar.gz arquivo, faça o upload deles no bucket do Amazon S3. O exemplo a seguir demonstra como fazer o upload do seu modelo para o Amazon S3 usando o: AWS CLI
```
!aws s3 cp test.tar.gz s3://{your-bucket}/models/
```
Selecione uma imagem de inferência Docker pré-criada ou crie sua própria imagem do Docker de inferência.

SageMaker fornece contêineres para seus algoritmos integrados e imagens pré-criadas do Docker para algumas das estruturas de aprendizado de máquina mais comuns, como Apache, MXNet TensorFlow, PyTorch e Chainer. Para obter uma lista completa das SageMaker imagens disponíveis, consulte Imagens disponíveis de contêineres de Deep Learning.

Se nenhum dos SageMaker contêineres existentes atender às suas necessidades e você não tiver um contêiner próprio, crie uma nova imagem do Docker. Consulte Contêineres com código de inferência personalizado para obter informações sobre como criar uma imagem do Docker.

Veja a seguir como recuperar uma imagem de inferência da PyTorch versão 1.7.1 usando o Python: SageMaker SDK
```
from sagemaker import image_uris

## Uncomment and replace with your own values if you did not define  
## these variables a previous step.
#framework = 'pytorch'
#framework_version = '1.7.1'

# Note: you can use any CPU-based instance here, 
# this is just to set the arch as CPU for the Docker image
instance_type = 'ml.m5.2xlarge' 

image_uri = image_uris.retrieve(framework, 
                                region, 
                                version=framework_version, 
                                py_version='py3', 
                                instance_type=instance_type, 
                                image_scope='inference')
```
Para obter uma lista de SageMaker instâncias disponíveis, consulte Amazon SageMaker Pricing.
Crie um arquivo de exemplo de carga.

Crie um arquivo que contenha arquivos individuais que a ferramenta de teste de carga possa enviar para seus SageMaker endpoints. Seu código de inferência deve ser capaz de ler os formatos de arquivo do exemplo de carga.

A seguir, é baixada uma imagem.jpg que esse exemplo usa em uma etapa posterior para o modelo ResNet -18.
```
!wget https://cdn.pixabay.com/photo/2020/12/18/05/56/flowers-5841251_1280.jpg
```
Comprima o exemplo de carga como um pacote:
```
!tar -cvzf payload.tar.gz flowers-5841251_1280.jpg
```
Faça o upload da carga útil da amostra para o Amazon S3 e observe o Amazon S3: URI
```
!aws s3 cp payload.tar.gz s3://{bucket}/models/
```
Você precisará do Amazon S3 URI em uma etapa posterior, então armazene-o em uma variável:
```
bucket_prefix='models'
bucket = '<your-bucket-name>' # Provide the name of your S3 bucket
payload_s3_key = f"{bucket_prefix}/payload.tar.gz"
sample_payload_url= f"s3://{bucket}/{payload_s3_key}"
```
Prepare sua entrada do modelo para o trabalho de recomendações

Como último pré-requisito, você tem duas opções para preparar a entrada do modelo. Você pode registrar seu modelo no SageMaker Model Registry, que pode ser usado para catalogar modelos para produção, ou criar um SageMaker modelo e especificá-lo no ContainerConfig campo ao criar um trabalho de recomendações. A primeira opção é melhor se você quiser aproveitar os recursos que o Model Registry fornece, como gerenciar versões de modelos e automatizar a implantação de modelos. A segunda opção é ideal se você quiser começar rapidamente. Para a primeira opção, vá para a etapa 7. Para a segunda opção, pule a etapa 7 e vá para a etapa 8.
Opção 1: registrar seu modelo no registro de modelos

Com o SageMaker Model Registry, você pode catalogar modelos para produção, gerenciar versões de modelos, associar metadados (como métricas de treinamento) a um modelo, gerenciar o status de aprovação de um modelo, implantar modelos na produção e automatizar a implantação de modelos com CI/CD.

Quando você usa o SageMaker Model Registry para rastrear e gerenciar seus modelos, eles são representados como um pacote de modelo versionado dentro de grupos de pacotes de modelos. Pacotes de modelos sem versão não fazem parte de um grupo de modelos. Os grupos de pacotes de modelos contêm várias versões ou iterações de um modelo. Embora não seja obrigatório criá-los para cada modelo no registro, eles ajudam a organizar vários modelos que têm o mesmo propósito e fornecem versionamento automático.

Para usar o Amazon SageMaker Inference Recommender, você deve ter um pacote de modelo versionado. Você pode criar um pacote de modelo versionado programaticamente com o ou AWS SDK for Python (Boto3) com o Amazon Studio Classic. SageMaker Para criar um pacote de modelo versionado programaticamente, primeiro crie um grupo de pacotes de modelo com o. CreateModelPackageGroup API Em seguida, crie um pacote de modelo usando CreateModelPackage API o. Chamar esse método cria um pacote de modelo versionado.

Consulte Criar um grupo de modelos e obtenha Registrar uma versão do modelo instruções detalhadas sobre como criar de forma programática e interativa um grupo de pacotes de modelos e como criar um pacote de modelos versionados, respectivamente, com o e AWS SDK for Python (Boto3) o Amazon Studio Classic. SageMaker

O exemplo de código a seguir demonstra como criar um pacote de modelo versionado usando o AWS SDK for Python (Boto3).

nota
Você não precisa aprovar o pacote de modelos para criar um trabalho do recomendador de inferência.
1. Criar um grupo de pacote de modelos
  
  Crie um grupo de pacotes de modelos com CreateModelPackageGroup API o. Forneça um nome para o grupo de pacotes de modelos ModelPackageGroupName e, opcionalmente, forneça uma descrição do pacote de modelos no campo ModelPackageGroupDescription.
```
model_package_group_name = '<INSERT>'
model_package_group_description = '<INSERT>' 

model_package_group_input_dict = {
 "ModelPackageGroupName" : model_package_group_name,
 "ModelPackageGroupDescription" : model_package_group_description,
}

model_package_group_response = sagemaker_client.create_model_package_group(**model_package_group_input_dict)
```
  Consulte o Guia de SageMaker API referência da Amazon para obter uma lista completa dos argumentos opcionais e obrigatórios para os quais você pode transmitir CreateModelPackageGroup.
  
  Crie um pacote de modelo especificando uma imagem do Docker que executa seu código de inferência e a localização dos artefatos do seu modelo no Amazon S3 e forneça valores para. InferenceSpecification InferenceSpecificationdeve conter informações sobre trabalhos de inferência que podem ser executados com modelos baseados nesse pacote de modelos, incluindo o seguinte:
  - Os ECR caminhos de imagens da Amazon que executam seu código de inferência.
  - (Opcional) Os tipos de instância compatíveis com o pacote de modelos para trabalhos de transformação e endpoints em tempo real usados para inferência.
  - Os formatos de conteúdo de entrada e saída que o pacote do modelo suporta para inferência.
  Além disso, você deve especificar os seguintes parâmetros ao criar um pacote de modelos.
  - Domínio: o domínio de machine learning do pacote de modelos e seus componentes. Os domínios comuns de machine learning incluem visão computacional e processamento de linguagem natural.
  - Tarefa: a tarefa de machine learning realizada pelo pacote de modelos. Tarefas comuns de machine learning incluem detecção de objetos e classificação de imagens. Especifique OTHER "" se nenhuma das tarefas listadas no Guia de API referência atender ao seu caso de uso. Consulte as descrições dos API campos Tarefas para ver uma lista das tarefas de aprendizado de máquina compatíveis.
  - SamplePayloadUrl: O caminho do Amazon Simple Storage Service (Amazon S3) em que a carga útil da amostra é armazenada. Esse caminho deve apontar para um único TAR arquivo GZIP compactado (sufixo.tar.gz).
  - Framework: a framework de machine learning da imagem do contêiner do pacote de modelos.
  - FrameworkVersion: a versão da estrutura da imagem do contêiner do pacote modelo.
  Se você fornecer uma lista de permissões de tipos de instância a serem usados para gerar inferências em tempo real para o SupportedRealtimeInferenceInstanceTypes, o Inference Recommender limitará o espaço de pesquisa dos tipos de instância durante um trabalho. Default Use este parâmetro se você tiver restrições orçamentárias ou souber que há um conjunto específico de tipos de instância que podem suportar seu modelo e imagem de contêiner.
  
  Em uma etapa anterior, baixamos um modelo ResNet 18 pré-treinado e o armazenamos em um bucket do Amazon S3 em um diretório chamado. models Recuperamos uma imagem de inferência do Deep Learning Container PyTorch (v1.7.1) e a armazenamos em uma variável chamada. URI image_uri Use essas variáveis no exemplo de código a seguir para definir um dicionário usado como entrada para CreateModelPackageAPIo.
```
# Provide the Amazon S3 URI of your compressed tarfile
# so that Model Registry knows where to find your model artifacts
bucket_prefix='models'
bucket = '<your-bucket-name>' # Provide the name of your S3 bucket
model_s3_key = f"{bucket_prefix}/test.tar.gz"
model_url= f"s3://{bucket}/{model_s3_key}"

# Similar open source model to the packaged model
# The name of the ML model as standardized by common model zoos
nearest_model_name = 'resnet18'

# The supported MIME types for input and output data. In this example, 
# we are using images as input.
input_content_type='image/jpeg'


# Optional - provide a description of your model.
model_package_description = '<INSERT>'

## Uncomment if you did not store the domain and task in an earlier
## step 
#ml_domain = 'COMPUTER_VISION'
#ml_task = 'IMAGE_CLASSIFICATION'

## Uncomment if you did not store the framework and framework version
## in a previous step.
#framework = 'PYTORCH'
#framework_version = '1.7.1'

# Optional: Used for optimizing your model using SageMaker Neo
# PyTorch uses NCHW format for images
data_input_configuration = "[[1,3,256,256]]"

# Create a dictionary to use as input for creating a model pacakge group
model_package_input_dict = {
        "ModelPackageGroupName" : model_package_group_name,
        "ModelPackageDescription" : model_package_description,
        "Domain": ml_domain,
        "Task": ml_task,
        "SamplePayloadUrl": sample_payload_url,
        "InferenceSpecification": {
                "Containers": [
                    {
                        "Image": image_uri,
                        "ModelDataUrl": model_url,
                        "Framework": framework.upper(), 
                        "FrameworkVersion": framework_version,
                        "NearestModelName": nearest_model_name,
                        "ModelInput": {"DataInputConfig": data_input_configuration}
                    }
                    ],
                "SupportedContentTypes": [input_content_type]
        }
    }
```
2. Crie um pacote de modelo
  
  Use o CreateModelPackage API para criar um pacote de modelo. Passe o dicionário de entrada definido na etapa anterior:
```
model_package_response = sagemaker_client.create_model_package(**model_package_input_dict)
```
  Você precisa do pacote de modelos ARN para usar o Amazon SageMaker Inference Recommender. Observe o pacote ARN do modelo ou armazene-o em uma variável:
```
model_package_arn = model_package_response["ModelPackageArn"]

print('ModelPackage Version ARN : {}'.format(model_package_arn))
```
Opção 2: criar um modelo e configurar o campo ContainerConfig

Use esta opção se desejar iniciar um trabalho de recomendações de inferência e não precisar registrar seu modelo no registro do modelo. Nas etapas a seguir, você cria um modelo SageMaker e configura o ContainerConfig campo como entrada para o trabalho de recomendações.
1. Criar um modelo
  
  Crie um modelo com CreateModel API o. Para ver um exemplo que chama esse método ao implantar um modelo no SageMaker Hosting, consulte Create a Model (AWS SDK for Python (Boto3)).
  
  Em uma etapa anterior, baixamos um modelo ResNet 18 pré-treinado e o armazenamos em um bucket do Amazon S3 em um diretório chamado. models Recuperamos uma imagem de inferência do Deep Learning Container PyTorch (v1.7.1) e a armazenamos em uma variável chamada. URI image_uri Usamos essas variáveis no exemplo de código a seguir, onde definimos um dicionário usado como entrada para CreateModel API o.
```
model_name = '<name_of_the_model>'
# Role to give SageMaker permission to access AWS services.
sagemaker_role= "arn:aws:iam::<region>:<account>:role/*"

# Provide the Amazon S3 URI of your compressed tarfile
# so that Model Registry knows where to find your model artifacts
bucket_prefix='models'
bucket = '<your-bucket-name>' # Provide the name of your S3 bucket
model_s3_key = f"{bucket_prefix}/test.tar.gz"
model_url= f"s3://{bucket}/{model_s3_key}"

#Create model
create_model_response = sagemaker_client.create_model(
    ModelName = model_name,
    ExecutionRoleArn = sagemaker_role, 
    PrimaryContainer = {
        'Image': image_uri,
        'ModelDataUrl': model_url,
    })
```
2. Configurar o campo ContainerConfig
  
  Em seguida, você deve configurar o ContainerConfigcampo com o modelo que você acabou de criar e especificar os seguintes parâmetros nele:
  - Domain: o domínio de aprendizado de máquina do modelo e seus componentes, como visão computacional ou processamento de linguagem natural.
  - Task: a tarefa de machine learning que o modelo realiza, como classificação de imagens ou detecção de objetos.
  - PayloadConfig: a configuração da carga útil de um trabalho de recomendação. Para obter mais informações sobre os campos, consulte RecommendationJobPayloadConfig.
  - Framework: a estrutura de aprendizado de máquina da imagem do contêiner, como PyTorch.
  - FrameworkVersion: a versão da framework da imagem de contêiner
  - (Opcional) SupportedInstanceTypes: uma lista dos tipos de instância utilizados para gerar inferências em tempo real.
  Se você usar o SupportedInstanceTypes parâmetro, o recomendador de inferência limitará o espaço de pesquisa para tipos de instância durante um trabalho Default. Use este parâmetro se você tiver restrições orçamentárias ou souber que há um conjunto específico de tipos de instância que podem suportar seu modelo e imagem de contêiner.
  
  No exemplo de código a seguir, usamos os parâmetros definidos anteriormente, junto comNearestModelName, para definir um dicionário usado como entrada para CreateInferenceRecommendationsJob API o.
```
## Uncomment if you did not store the domain and task in a previous step
#ml_domain = 'COMPUTER_VISION'
#ml_task = 'IMAGE_CLASSIFICATION'

## Uncomment if you did not store the framework and framework version in a previous step
#framework = 'PYTORCH'
#framework_version = '1.7.1'

# The name of the ML model as standardized by common model zoos
nearest_model_name = 'resnet18'

# The supported MIME types for input and output data. In this example, 
# we are using images as input
input_content_type='image/jpeg'

# Optional: Used for optimizing your model using SageMaker Neo
# PyTorch uses NCHW format for images
data_input_configuration = "[[1,3,256,256]]"

# Create a dictionary to use as input for creating an inference recommendation job
container_config = {
        "Domain": ml_domain,
        "Framework": framework.upper(), 
        "FrameworkVersion": framework_version,
        "NearestModelName": nearest_model_name,
        "PayloadConfig": { 
            "SamplePayloadUrl": sample_payload_url,
            "SupportedContentTypes": [ input_content_type ]
         },
        "DataInputConfig": data_input_configuration
        "Task": ml_task,
        }
```

Atenção O Javascript está desativado ou não está disponível no seu navegador.

Para usar a documentação da AWS, o Javascript deve estar ativado. Consulte as páginas de Ajuda do navegador para obter instruções.

Convenções do documento

Recomendador de inferência

Trabalhos de recomendação