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 aqui usam o AWS SDK for Python (Boto3).

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 ter mais informações sobre o Studio, consulte SageMaker Estúdio Amazon.

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

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

Configurar o ambiente.

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


!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 mais comuns. O recomendador de inferência oferece apoio 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 exemplo demonstra como listar metadados do modelo com o SDK para 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 aos seguinte exemplo:


{
    '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 seguinte exemplo de código Python 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/
```
O Amazon SageMaker AI exige que modelos de aprendizado de máquina pré-treinados sejam empacotados como um arquivo TAR 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 seguinte exemplo demonstra como carregar seu modelo para o Amazon S3 usando a AWS CLI:
```
!aws s3 cp test.tar.gz s3://{your-bucket}/models/
```
Selecione uma imagem do Docker de inferência pré-criada ou crie sua própria imagem do Docker de inferência.

SageMaker A IA 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 ver uma lista completa das imagens de SageMaker IA disponíveis, consulte Imagens de contêineres de Deep Learning Disponíveis.

Se nenhum dos contêineres de SageMaker IA 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 SDK do Python: SageMaker
```
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 das instâncias de SageMaker IA disponíveis, consulte Amazon SageMaker AI Pricing.
Crie um arquivo de exemplo de carga útil.

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

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 útil como um pacote:
```
!tar -cvzf payload.tar.gz flowers-5841251_1280.jpg
```
Faça o upload do exemplo de carga útil no Amazon S3 e anote o URI do Amazon S3:
```
!aws s3 cp payload.tar.gz s3://{bucket}/models/
```
Você precisará do URI do Amazon S3 em uma etapa posterior, portanto, 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 modelo de SageMaker IA e especificá-lo no ContainerConfig campo ao criar um trabalho de recomendações. A primeira opção é melhor se você quiser aproveitar os atributos 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 a API CreateModelPackageGroup. Em seguida, crie um pacote de modelo usando a API CreateModelPackage. 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 a API CreateModelPackageGroup. 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 referência de SageMaker API da Amazon para obter uma lista completa dos argumentos opcionais e obrigatórios para os quais você pode passar CreateModelPackageGroup.
  
  Crie um pacote de modelos especificando uma imagem do Docker que execute seu código de inferência e a localização do Amazon S3 dos seus artefatos de modelo, e forneça valores para InferenceSpecification. O InferenceSpecification deve conter informações sobre jobs de inferência que podem ser executados com modelos baseados neste pacote de modelos, incluindo o seguinte:
  - Os caminhos de imagens do Amazon ECR que executam seu código de inferência.
  - (Opcional) Os tipos de instância compatíveis com o pacote de modelo para trabalhos de transformação e endpoints em tempo real usados para inferência.
  - Os formatos de conteúdo de entrada e saída compatíveis com o pacote de modelos 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 “OUTRO” se nenhuma das tarefas listadas no Guia de referência da API atender ao seu caso de uso. Consulte as descrições dos campos da API Task para obter uma lista de tarefas de machine learning 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 arquivo tar compactado por gzip (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 apoiar 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 armazenamos o URI em uma variável chamada. image_uri Use essas variáveis no exemplo de código a seguir para definir um dicionário usado como entrada para a API CreateModelPackage.
```
# 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. Criar um pacote de modelo
  
  Usar a API CreateModelPackage para criar um pacote de modelos. 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 ARN do pacote de modelos para usar o Amazon SageMaker Inference Recommender. Observe o ARN do pacote de modelos ou o armazene 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 no SageMaker AI e configura o ContainerConfig campo como entrada para o trabalho de recomendações.
1. Criar um modelo
  
  Criar um modelo com a API do CreateModel Para ver um exemplo que chama esse método ao implantar um modelo no SageMaker AI 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 armazenamos o URI em uma variável chamada. image_uri Usamos essas variáveis no exemplo de código a seguir, onde definimos um dicionário usado como entrada para a API CreateModel.
```
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 machine learning 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 do 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 apoiar seu modelo e imagem de contêiner.
  
  No exemplo de código a seguir, usamos os parâmetros definidos anteriormente, juntamente comNearestModelName, para definir um dicionário usado como entrada para a API CreateInferenceRecommendationsJob.
```
## 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