Prerequisiti per l’utilizzo di Amazon SageMaker Inference Recommender

Crea un ruolo IAM per Amazon SageMaker AI.

Crea un ruolo IAM per Amazon SageMaker AI con la policy gestita IAM AmazonSageMakerFullAccess collegata.

Configurare l’ambiente.

Importa dipendenze e crea variabili per la tua Regione AWS, il tuo ruolo IAM di SageMaker AI (dalla fase 1) e il client SageMaker AI.

!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()

(Facoltativo) Esaminare i modelli esistenti sottoposti a benchmark da Inference Recommender.

Il suggeritore di inferenza esegue il benchmark per i modelli delle serie di modelli più diffusi. Il suggeritore di inferenza supporta il tuo modello anche se non è già stato sottoposto a benchmark.

Utilizza ListModelMetaData per ottenere un oggetto di risposta che elenchi il dominio, il framework, l'attività e il nome del modello dei modelli di machine learning presenti nelle serie di modelli più diffusi.

Nelle fasi successive utilizza il dominio, il framework, la versione del framework, l'attività e il nome del modello sia per selezionare un'immagine Docker di inferenza sia per registrare il modello con il registro dei modelli di SageMaker. Di seguito viene illustrato come elencare i metadati dei modelli con SDK for Python (Boto3):

list_model_metadata_response=sagemaker_client.list_model_metadata()

L’output include i riepiloghi dei modelli (ModelMetadataSummaries) e i metadati di risposta (ResponseMetadata) simili al seguente esempio:

{
    '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
    }
}

Per questa demo, utilizziamo un modello ResNet-18 (v1.7.1) di PyTorch per eseguire la classificazione delle immagini. Il seguente esempio di codice Python memorizza il framework, la versione del framework, il dominio e l'attività in variabili per un uso successivo:

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

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

Carica il tuo modello di machine learning su Amazon S3.

Usa questo modello ResNet-18 (v1.7.1) di PyTorch se non disponi di un modello di machine learning pre-addestrato:

# 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')

Scarica uno script di inferenza di esempio inference.py. Crea una directory code e sposta lo script di inferenza nella directory 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/

Per Amazon SageMaker AI è necessario che i modelli di machine learning preaddestrati siano inclusi in pacchetti come file TAR compressi (*.tar.gz). Comprimi il modello e lo script di inferenza per soddisfare questo requisito:

!tar -czf test.tar.gz model.pth code/inference.py

Una volta effettuato il provisioning dell'endpoint, i file nell'archivio vengono estratti in /opt/ml/model/ sull'endpoint.

Dopo aver compresso il modello e gli artefatti del modello come file .tar.gz, caricali nel tuo bucket Amazon S3. Il seguente esempio illustra come caricare il modello su Amazon S3 utilizzando l’AWS CLI:

!aws s3 cp test.tar.gz s3://{your-bucket}/models/

Seleziona un'immagine di inferenza Docker predefinita o crea la tua immagine Docker di inferenza.

SageMaker AI fornisce container per i suoi algoritmi integrati e immagini Docker predefinite per alcuni dei framework di machine learning più comuni, come Apache MXNet, TensorFlow, PyTorch e Chainer. Per un elenco completo delle immagini SageMaker AI disponibili, consulta Available Deep Learning Containers Images.

Se nessuno dei container SageMaker AI esistenti soddisfa le tue esigenze e non hai un container personale, crea una nuova immagine Docker. Per informazioni su come creare la propria immagine Docker, consulta Container con codice di inferenza personalizzato.

Di seguito viene illustrato come recuperare un'immagine di inferenza PyTorch versione 1.7.1 utilizzando SageMaker Python 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')

Per un elenco delle istanze di SageMaker AI disponibili, consulta Prezzi di Amazon SageMaker AI.

Crea un archivio di payload di esempio.

Crea un archivio contenente singoli file che lo strumento di test di carico può inviare agli endpoint SageMaker AI. Il codice di inferenza deve essere in grado di leggere i formati di file dal payload di esempio.

Di seguito viene scaricata un'immagine .jpg che questo esempio utilizza in una fase successiva per il modello ResNet-18.

!wget https://cdn.pixabay.com/photo/2020/12/18/05/56/flowers-5841251_1280.jpg

Comprimi il payload di esempio come tarball:

!tar -cvzf payload.tar.gz flowers-5841251_1280.jpg

Carica il payload di esempio su Amazon S3 e annota l'URI di Amazon S3:

!aws s3 cp payload.tar.gz s3://{bucket}/models/

L'URI Amazon S3 ti servirà in una fase successiva, quindi memorizzalo in una variabile:

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}"

Prepara l'input del modello per il processo di raccomandazione

Per l'ultimo prerequisito, sono disponibili due opzioni per preparare l'input del modello. È possibile registrare il modello con SageMaker Model Registry, che può essere utilizzato per catalogare i modelli per la produzione, oppure è possibile creare un modello SageMaker AI e specificarlo nel campo ContainerConfig durante la creazione di un progetto di raccomandazione. La prima opzione è la migliore se si desidera sfruttare le funzionalità offerte da Model Registry, come la gestione delle versioni dei modelli e l'automazione dell'implementazione dei modelli. La seconda opzione è ideale se si desidera iniziare rapidamente. Per la prima opzione, vai alla fase 7. Per la seconda opzione, salta la fase 7 e vai alla fase 8.

Opzione 1: registrare il modello nel registro dei modelli

Con il registro di modelli di SageMaker, è possibile catalogare i modelli per la produzione, gestire le versioni dei modelli, associare i metadati (come i parametri di addestramento) a un modello, gestire lo stato di approvazione di un modello, implementare i modelli in produzione e automatizzare l'implementazione dei modelli con CI/CD.

Quando si utilizza il registro di modelli di SageMaker per tracciare e gestire i modelli, questi sono rappresentati come un pacchetto di modelli provvisti delle versioni all'interno dei gruppi di pacchetti di modelli. I pacchetti di modelli senza versione non fanno parte di un gruppo di modelli. I gruppi di pacchetti di modelli contengono più versioni o iterazioni di un modello. Sebbene non sia necessario crearli per ogni modello nel registro, aiutano a organizzare vari modelli che hanno tutti lo stesso scopo e offrono l'assegnazione automatica delle versioni.

Per utilizzare Amazon SageMaker Inference Recommender, è necessario disporre di un pacchetto di modelli provvisti di versione. Puoi creare un pacchetto di modelli con versioni a livello di programmazione con AWS SDK per Python (Boto3) o con Amazon SageMaker Studio Classic. Per creare un pacchetto di modelli provvisti delle versioni a livello di programmazione, crea prima un gruppo di pacchetti di modelli con l'API CreateModelPackageGroup. Quindi, crea un pacchetto di modelli utilizzando l'API CreateModelPackage. La chiamata a questo metodo crea un pacchetto di modelli provvisti delle versioni.

Consulta Creazione di un gruppo di modelli e Registrazione di una versione del modello per istruzioni dettagliate su come creare a livello di programmazione e in modo interattivo un gruppo di pacchetti di modelli e su come creare un pacchetto di modelli con versioni, rispettivamente, con AWS SDK per Python (Boto3) e Amazon SageMaker Studio Classic.

Il seguente esempio di codice mostra come creare un pacchetto di modelli con versione utilizzando AWS SDK per Python (Boto3).

1. Creazione di un gruppo di pacchetti di modelli

   Crea un gruppo di pacchetti di modelli con l'API CreateModelPackageGroup. Fornisci un nome al gruppo di pacchetti di modelli per ModelPackageGroupName e, facoltativamente, fornisci una descrizione del pacchetto di modelli nel 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)

   Consulta la guida Amazon SageMaker API Reference per un elenco completo degli argomenti facoltativi e obbligatori che è possibile passare a CreateModelPackageGroup.

   Crea un pacchetto di modelli specificando un’immagine Docker che esegue il codice di inferenza e la posizione di Amazon S3 degli artefatti dei modelli e fornisci valori per InferenceSpecification. InferenceSpecification deve contenere informazioni sui processi di inferenza che possono essere eseguiti con modelli basati su questo pacchetto di modelli, inclusi i seguenti:

   • I percorsi Amazon ECR delle immagini che eseguono il codice di inferenza.

   • (Facoltativo) I tipi di istanza supportati dal pacchetto di modelli per i processi di trasformazione e gli endpoint in tempo reale utilizzati per l’inferenza.

   • I formati dei contenuti di input e output supportati dal pacchetto di modelli per l’inferenza.

   Inoltre, quando crei un pacchetto di modelli, devi specificare i parametri seguenti:

   • dominio: il dominio di machine learning del pacchetto di modelli e dei relativi componenti. I domini comuni di machine learning includono la visione artificiale e l'elaborazione del linguaggio naturale.

   • attività: l'attività di machine learning svolta dal pacchetto di modelli. Le attività comuni di machine learning includono il rilevamento degli oggetti e la classificazione delle immagini. Indica "ALTRO" se nessuna delle attività elencate nella guida API Reference corrisponde al proprio caso d'uso. Consulta le descrizioni dei campi dell'API Attività per un elenco delle attività di machine learning supportate.

   • SamplePayloadUrl: il percorso di Amazon Simple Storage Service (Amazon S3) in cui sono memorizzati i payload di esempio. Questo percorso deve puntare a un singolo archivio TAR compresso GZIP (suffisso .tar.gz).

   • Framework: il framework di machine learning dell'immagine container del pacchetto di modelli.

   • FrameworkVersion: la versione del framework dell’immagine di container del pacchetto di modelli.

   Se fornisci un elenco di tipi di istanze consentite da utilizzare per generare inferenze in tempo reale per SupportedRealtimeInferenceInstanceTypes, Inference Recommender limita lo spazio di ricerca per i tipi di istanze durante un processo Default. Utilizza questo parametro se hai vincoli di budget o sai che esiste un set specifico di tipi di istanze in grado di supportare l’immagine del container e del modello.

   In una fase precedente abbiamo scaricato un modello ResNet18 preaddestrato e lo abbiamo archiviato in un bucket Amazon S3 in una directory chiamata models. Abbiamo recuperato un’immagine di inferenza del Container per il Deep Learning (v1.7.1) di PyTorch e archiviato l’URI in una variabile chiamata image_uri. Utilizza queste variabili nel seguente esempio di codice per definire un dizionario utilizzato come input per l’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. Crea un pacchetto di modelli

   Utilizza l’API CreateModelPackage per creare un pacchetto di modelli. Passa il dizionario di input definito nella fase precedente:

   model_package_response = sagemaker_client.create_model_package(**model_package_input_dict)

   È necessario l'ARN del pacchetto di modelli per utilizzare Amazon SageMaker Inference Recommender. Prendi nota dell'ARN del pacchetto di modelli o memorizzalo in una variabile:

   model_package_arn = model_package_response["ModelPackageArn"]
   
   print('ModelPackage Version ARN : {}'.format(model_package_arn))

Opzione 2: crea un modello e configura il campo ContainerConfig

Utilizza questa opzione se desideri avviare un processo di raccomandazioni di inferenza e non hai bisogno di registrare il modello nel Model Registry. Nelle fasi seguenti scoprirai come creare un modello in SageMaker AI e configurare il campo ContainerConfig come input per il processo di raccomandazione.

1. Creazione di un modello

   Crea un modello con l'API CreateModel. Per un esempio che chiama questo metodo quando si implementa un modello in SageMaker AI Hosting, consulta Create a Model (AWS SDK per Python (Boto3)).

   In una fase precedente abbiamo scaricato un modello ResNet18 preaddestrato e lo abbiamo archiviato in un bucket Amazon S3 in una directory chiamata models. Abbiamo recuperato un'immagine di inferenza del container di Deep Learning (v1.7.1) di PyTorch e memorizzato l'URI in una variabile chiamata image_uri. Utilizziamo queste variabili nel seguente esempio di codice in cui definiamo un dizionario utilizzato come input per l'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. Configurazione del campo ContainerConfig

   Successivamente, è necessario configurare il campo ContainerConfig con il modello appena creato e specificarvi i seguenti parametri:

   • Domain: il dominio di machine learning del modello e dei suoi componenti, come la visione artificiale o l'elaborazione del linguaggio naturale.

   • Task: l'attività di machine learning svolta dal modello, ad esempio la classificazione delle immagini o il rilevamento di oggetti.

   • PayloadConfig: la configurazione per il payload per un processo di raccomandazione. Per ulteriori informazioni sui sottocampi, consulta RecommendationJobPayloadConfig.

   • Framework: il framework di machine learning dell'immagine container, ad esempio PyTorch.

   • FrameworkVersion: la versione del framework dell'immagine container.

   • (Facoltativo) SupportedInstanceTypes: un elenco dei tipi di istanza utilizzati per generare inferenze in tempo reale.

   Se utilizzi il parametro SupportedInstanceTypes, il suggeritore di inferenza limita lo spazio di ricerca per i tipi di istanze durante un processo di Default. Utilizza questo parametro se hai vincoli di budget o sai che esiste un set specifico di tipi di istanze in grado di supportare l'immagine del container e del modello.

   Nel seguente esempio di codice, utilizziamo i parametri definiti in precedenza, insieme a NearestModelName, per definire un dizionario utilizzato come input per l'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,
           }