Prerequisiti

Crea un IAM ruolo per Amazon SageMaker.

Crea un IAM ruolo per Amazon a SageMaker cui sia allegata la policy AmazonSageMakerFullAccess IAM gestita.

Configura il tuo ambiente.

Importa dipendenze e crea variabili per te Regione AWS, per il tuo SageMaker IAM ruolo (dalla Fase 1) e per il 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()

(Facoltativo) Esamina i modelli esistenti sottoposti a benchmark dal suggeritore di inferenza.

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.

Utilizzerai il dominio, il framework, la versione del framework, l'attività e il nome del modello nei passaggi successivi sia per selezionare un'immagine Docker di inferenza sia per registrare il tuo modello con SageMaker Model Registry. Quanto segue dimostra come elencare i metadati del modello con SDK for Python (Boto3):

list_model_metadata_response=sagemaker_client.list_model_metadata()

L'output include i riepiloghi del modello (ModelMetadataSummaries) e i metadati di risposta (ResponseMetadata) simili all'esempio seguente:

{
    '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 PyTorch (v1.7.1) ResNet -18 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 PyTorch (v1.7.1) ResNet -18 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/

Amazon SageMaker richiede che i modelli di machine learning preaddestrati siano impacchettati come TAR file compresso (). *.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. L'esempio seguente mostra come caricare il modello su Amazon S3 utilizzando: 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 fornisce contenitori per i suoi algoritmi integrati e immagini Docker predefinite per alcuni dei framework di machine learning più comuni, come Apache,, e Chainer. MXNet TensorFlow PyTorch Per un elenco completo delle SageMaker immagini disponibili, consulta Available Deep Learning Containers Images.

Se nessuno dei SageMaker contenitori esistenti soddisfa le tue esigenze e non disponi di un contenitore personale, crea una nuova immagine Docker. Per informazioni su come creare la propria immagine Docker, consulta Utilizzo del tuo codice di inferenza.

Quanto segue dimostra come recuperare un'immagine di inferenza della PyTorch versione 1.7.1 usando 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')

Per un elenco delle SageMaker istanze disponibili, consulta la pagina SageMakerdei prezzi di Amazon.

Crea un archivio di payload di esempio.

Crea un archivio contenente singoli file che lo strumento di test di carico può inviare ai tuoi SageMaker endpoint. 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 un passaggio successivo 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 Amazon S3: URI

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

Amazon S3 è necessario URI 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. Puoi registrare il tuo SageMaker modello con Model Registry, che puoi utilizzare per catalogare i modelli per la produzione, oppure puoi creare un SageMaker modello e specificarlo nel ContainerConfig campo quando crei un lavoro 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 SageMaker Model Registry, puoi catalogare i modelli per la produzione, gestire le versioni dei modelli, associare i metadati (come le metriche di formazione) a un modello, gestire lo stato di approvazione di un modello, distribuire i modelli alla produzione e automatizzare l'implementazione dei modelli con CI/CD.

Quando si utilizza SageMaker Model Registry per tracciare e gestire i modelli, questi vengono rappresentati come un pacchetto di modelli con 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, devi disporre di un pacchetto modello con versione. Puoi creare un pacchetto modello con versioni a livello di codice con o AWS SDK for Python (Boto3) con Amazon SageMaker Studio Classic. Per creare un pacchetto modello con versioni a livello di codice, crea prima un gruppo di pacchetti modello con. CreateModelPackageGroup API Quindi, create un pacchetto modello utilizzando. CreateModelPackage API La chiamata a questo metodo crea un pacchetto di modelli provvisti delle versioni.

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

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

1. Creazione di un gruppo di pacchetti di modelli

   Crea un gruppo di pacchetti modello con. CreateModelPackageGroup API 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 l'Amazon SageMaker API Reference Guide per un elenco completo degli argomenti opzionali e obbligatori a cui puoi passare CreateModelPackageGroup.

   Crea un pacchetto modello specificando un'immagine Docker che esegue il codice di inferenza e la posizione in Amazon S3 degli artefatti del modello e fornisci i valori per. InferenceSpecification InferenceSpecificationdovrebbe contenere informazioni sui lavori di inferenza che possono essere eseguiti con modelli basati su questo pacchetto di modelli, tra cui:

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

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

   • I formati di contenuto di input e output supportati dal pacchetto del modello 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. Specificate OTHER "" se nessuna delle attività elencate nella Guida di API riferimento soddisfa il vostro caso d'uso. Consulta le descrizioni dei API campi Task per un elenco delle attività di machine learning supportate.

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

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

   • FrameworkVersion: la versione framework dell'immagine del contenitore del pacchetto modello.

   Se si fornisce un elenco di tipi di istanze consentiti 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 un passaggio precedente, abbiamo scaricato un modello ResNet 18 pre-addestrato e lo abbiamo archiviato in un bucket Amazon S3 in una directory chiamata. models Abbiamo recuperato un'immagine di inferenza del Deep Learning Container PyTorch (v1.7.1) e l'abbiamo archiviata in una variabile chiamata. URI image_uri Utilizzate queste variabili nel seguente esempio di codice per definire un dizionario usato come input per. CreateModelPackageAPI

   # 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. Creare un pacchetto modello

   Utilizzate il CreateModelPackage API per creare un pacchetto modello. Passa il dizionario di input definito nella fase precedente:

   model_package_response = sagemaker_client.create_model_package(**model_package_input_dict)

   È necessario il pacchetto modello ARN per utilizzare Amazon SageMaker Inference Recommender. Prendi nota ARN del pacchetto del modello 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. Nei passaggi seguenti, si crea un modello in SageMaker e si configura il ContainerConfig campo come input per il processo di raccomandazione.

1. Crea un modello

   Crea un modello con CreateModelAPI. Per un esempio che chiama questo metodo quando si distribuisce un modello su SageMaker Hosting, consulta Create a Model (AWS SDK for Python (Boto3)).

   In un passaggio precedente, abbiamo scaricato un modello ResNet 18 pre-addestrato e lo abbiamo archiviato in un bucket Amazon S3 in una directory chiamata. models Abbiamo recuperato un'immagine di inferenza del Deep Learning Container PyTorch (v1.7.1) e l'abbiamo archiviata in una variabile chiamata. URI image_uri Utilizziamo queste variabili nel seguente esempio di codice in cui definiamo un dizionario usato come input per. CreateModel API

   
   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 ContainerConfigcampo con il modello appena creato e specificare i seguenti parametri al suo interno:

   • 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 apprendimento automatico dell'immagine del contenitore, 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 aNearestModelName, per definire un dizionario usato come input per CreateInferenceRecommendationsJobAPI.

   ## 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,
           }