Requisitos previos para utilizar el Recomendador de inferencias de Amazon SageMaker

Cree un rol de IAM para Amazon SageMaker AI.

Cree un rol de IAM para Amazon SageMaker AI que tenga asociada la política administrada de IAM de AmazonSageMakerFullAccess.

Configure el entorno.

Importe las dependencias y cree variables para su Región de AWS, su rol de IAM de SageMaker AI (del paso 1) y el cliente de 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()

(Opcional) Revise los modelos existentes comparados con Recomendador de inferencias.

Recomendador de inferencias compara modelos de referencia con Model Zoos. Recomendador de inferencias es compatible con su modelo incluso si aún no se ha comparado con él.

Utilice ListModelMetaData para obtener un objeto de respuesta que indique el dominio, el marco, la tarea y el nombre de los modelos de machine learning que se encuentran en los Model Zoos comunes.

Utilice el dominio, el marco, la versión del marco, la tarea y el nombre del modelo en los pasos posteriores para seleccionar una imagen de Docker de inferencia y registrar el modelo con el registro de modelos de SageMaker. A continuación, se muestra cómo enumerar los metadatos del modelo con SDK para Python (Boto3):

list_model_metadata_response=sagemaker_client.list_model_metadata()

La salida incluye resúmenes de modelo (ModelMetadataSummaries) y metadatos de respuesta (ResponseMetadata) similares al siguiente ejemplo:

{
    '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 demostración, utilizamos un modelo PyTorch (v1.7.1) ResNet-18 para realizar la clasificación de imágenes. El siguiente ejemplo de código de Python almacena el marco, la versión del marco, el dominio y la tarea en variables para su uso posterior:

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

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

Cargue su modelo de machine learning en Amazon S3.

Utilice este modelo ResNet-18 de PyTorch (v1.7.1) si no tiene un modelo de machine learning previamente entrenado:

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

Descargue un ejemplo de script de inferencia inference.py. Cree un directorio code y mueva el script de inferencia al directorio 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 AI requiere que los modelos de machine learning previamente entrenados se empaqueten como archivo TAR comprimido (*.tar.gz). Comprima el modelo y el script de inferencia para satisfacer este requisito:

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

Cuando se aprovisiona el punto de conexión, los archivos del archivo se extraen en /opt/ml/model/ en el punto de conexión.

Tras comprimir el modelo y los artefactos del modelo en un archivo .tar.gz, cárguelos en su bucket de Amazon S3. En el siguiente ejemplo, se muestra cómo cargar su modelo en Amazon S3 mediante la AWS CLI:

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

Seleccionar una imagen de inferencia de Docker prediseñada o crear su propia imagen de Docker de inferencia.

SageMaker AI proporciona contenedores para sus algoritmos integrados e imágenes de Docker precompiladas para algunos de los marcos de machine learning más comunes, como Apache MXNet, TensorFlow, PyTorch y Chainer. Para obtener una lista completa de las imágenes disponibles de SageMaker AI, consulte Imágenes disponibles de contenedores de aprendizaje profundo.

Si ninguno de los contenedores de SageMaker AI existentes satisface sus necesidades y usted no tiene uno propio, cree una nueva imagen de Docker. Consulte Contenedores con código de inferencia personalizado para obtener información acerca de cómo crear una imagen de Docker.

A continuación, se muestra cómo recuperar una imagen de inferencia de PyTorch versión 1.7.1 mediante el SDK de Python de 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 obtener una lista de las instancias de SageMaker AI disponibles, consulte Precios de Amazon SageMaker AI.

Cree un archivo de carga útil de ejemplo.

Cree un archivo que contenga archivos individuales que la herramienta de pruebas de carga pueda enviar a sus puntos de conexión de SageMaker AI. El código de inferencia debe poder leer los formatos de archivo de la carga útil de muestra.

A continuación, se descarga una imagen en formato .jpg que este ejemplo utiliza en un paso posterior para el modelo ResNet-18.

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

Comprima la carga útil de muestra como un archivo tar:

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

Cargue la carga útil de muestra en Amazon S3 y anote el URI de Amazon S3:

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

Necesitará la URI de Amazon S3 en un paso posterior, así que guárdela en una variable:

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

Preparar la entrada del modelo para el trabajo de recomendaciones

Para el último requisito previo, tiene dos opciones para preparar la entrada del modelo. Puede registrar el modelo en el registro de modelos de SageMaker AI, que puede utilizar para catalogar modelos para su producción, o puede crear un modelo de SageMaker AI y especificarlo en el campo ContainerConfig al crear un trabajo de recomendaciones. La primera opción es la mejor si quiere aprovechar las funciones que ofrece el registro de modelos, como la gestión de las versiones de los modelos y la automatización de la implementación de los modelos. La segunda opción es ideal si desea comenzar rápidamente. Para la primera opción, vaya al paso 7. Para la segunda opción, omita el paso 7 y vaya al paso 8.

Opción 1: Registrar el modelo en el registro de modelos

Con el registro de modelos de Sagemaker, puede catalogar modelos para producción, gestionar versiones de modelos, asociar metadatos (como métricas de entrenamiento) a un modelo, gestionar el estado de aprobación de un modelo, implementar modelos en producción y automatizar la implementación del modelo con CI/CD.

Cuando utiliza el registro de modelos de SageMaker para realizar un seguimiento y administrar sus modelos, estos se representan como un paquete de modelos versionados dentro de los grupos de paquetes de modelos. Los paquetes de modelos sin control de versiones no forman parte de un grupo de modelos. Los grupos de paquetes de modelos contienen múltiples versiones o iteraciones de un modelo. Si bien no es necesario crearlos para todos los modelos del registro, ayudan a organizar varios modelos que tienen el mismo propósito y proporcionan un control de versiones automático.

Para utilizar Recomendador de inferencias de Amazon SageMaker, debe tener un paquete de modelos versionado. Puede crear un paquete de modelos con control de versiones mediante programación con el AWS SDK para Python (Boto3) o con Amazon SageMaker Studio. Para crear un paquete de modelos versionados mediante programación, primero cree un grupo de paquetes de modelos con la API CreateModelPackageGroup. A continuación, cree un paquete de modelos mediante la API CreateModelPackage. Al llamar a este método, se crea un paquete de modelos versionado.

Consulte Cree un grupo de modelos y Registro de una versión del modelo para obtener instrucciones detalladas sobre cómo crear mediante programación e interactivamente un grupo de paquetes de modelos y cómo crear un paquete de modelos con control de versiones, respectivamente, con el AWS SDK para Python (Boto3) y Amazon SageMaker Studio Classic.

En el siguiente ejemplo de código se muestra cómo crear un paquete de modelos versionados mediante el AWS SDK para Python (Boto3).

1. Crear un grupo de paquetes de modelos

   Cree un grupo de paquetes de modelos con la API CreateModelPackageGroup. Asigne un nombre al grupo de paquetes de modelos para el ModelPackageGroupName y, si lo desea, proporcione una descripción del paquete de modelos en el 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 la Guía de referencia de la API de Amazon Sagemaker para obtener una lista completa de los argumentos opcionales y obligatorios que puede pasar a CreateModelPackageGroup.

   Cree un paquete de modelos especificando una imagen de Docker que ejecute el código de inferencia y la ubicación en Amazon S3 de los artefactos del modelo y proporcione valores para InferenceSpecification. InferenceSpecification debe contener información sobre los trabajos de inferencia que se pueden ejecutar con modelos basados en este paquete de modelos, incluida la siguiente:

   • Las rutas de imágenes de Amazon ECR que ejecutan el código de inferencia.

   • (Opcional) Los tipos de instancia que admite el paquete de modelos para los trabajos de transformación y los puntos de conexión en tiempo real que se utilizan para la inferencia.

   • Los formatos de contenido de entrada y salida que el paquete de modelos admite para la inferencia.

   Además, debe especificar los siguientes parámetros al crear un paquete de modelos:

   • Dominio: el dominio de machine learning del paquete de modelos y sus componentes. Los dominios comunes de machine learning incluyen la visión artificial y el procesamiento del lenguaje natural.

   • Tarea_ la tarea de machine learning que realiza el paquete de modelos. Las tareas comunes de machine learning incluyen la detección de objetos y la clasificación de imágenes. Especifique “OTHER” (OTRAS) si ninguna de las tareas enumeradas en la Guía de referencia de API satisface su caso de uso. Consulte las descripciones de los campos de la API de tareas para obtener una lista de las tareas de machine learning compatibles.

   • SamplePayloadUrl: la ruta de Amazon Simple Storage Service (Amazon S3) en la que se almacena la carga de muestra. Esta ruta debe apuntar a un único archivo TAR comprimido con GZIP (sufijo .tar.gz).

   • Framework: el marco de machine learning de la imagen de contenedor del paquete modelo.

   • FrameworkVersion: la versión del marco de la imagen de contenedor del paquete de modelos.

   Si proporciona una lista de tipos de instancias permitidos para generar inferencias en tiempo real para SupportedRealTimeInferenceInstanceTypes, el Recomendador de inferencias limitará el espacio de búsqueda para los tipos de instancias durante un trabajo Default. Use este parámetro si tiene limitaciones presupuestarias o si sabe que hay un conjunto específico de tipos de instancias compatibles con su imagen de modelo y contenedor.

   En un paso anterior, descargamos un modelo ResNet18 previamente entrenado y lo almacenamos en un bucket de Amazon S3 en un directorio llamado models. Recuperamos una imagen de inferencia del contenedor de aprendizaje profundo de PyTorch (v1.7.1) y almacenamos el URI en una variable llamada image_uri. Use esas variables en el siguiente ejemplo de código para definir un diccionario que se usa como entrada a la 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. Creación de un paquete de modelos

   Utilice la API CreateModelPackage para crear un paquete de modelos. Pase el diccionario de entrada definido en el paso anterior:

   model_package_response = sagemaker_client.create_model_package(**model_package_input_dict)

   Necesita el ARN del paquete de modelos para utilizar Recomendador de inferencias de Amazon SageMaker. Tenga en cuenta el ARN del paquete del modelo o almacénelo en una variable:

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

Opción 2: Crear un modelo y configurar el campo ContainerConfig

Utilice esta opción si desea iniciar un trabajo de recomendaciones de inferencia y no necesita registrar su modelo en el registro de modelos. En los siguientes pasos, creará un modelo en SageMaker AI y configurará el campo ContainerConfig como entrada para el trabajo de recomendaciones.

1. Crear un modelo

   Cree un modelo con la API CreateModel. Para ver un ejemplo que llama a este método al implementar un modelo en SageMaker AI Hosting, consulte Crear un modelo (AWS SDK para Python (Boto3)).

   En un paso anterior, descargamos un modelo ResNet18 previamente entrenado y lo almacenamos en un bucket de Amazon S3 en un directorio llamado models. Recuperamos una imagen de inferencia del contenedor de aprendizaje profundo de PyTorch (v1.7.1) y almacenamos el URI en una variable llamada image_uri. Usamos esas variables en el siguiente ejemplo de código, donde definimos un diccionario que se usa como entrada a la 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. Configure el campo ContainerConfig

   A continuación, debe configurar el campo ContainerConfig con el modelo que acaba de crear y especificar en él los siguientes parámetros:

   • Domain: el dominio de machine learning del modelo y sus componentes, como la visión artificial o el procesamiento del lenguaje natural.

   • Task: la tarea de machine learning que realiza el modelo, como la clasificación de imágenes o la detección de objetos.

   • PayloadConfig: la configuración de la carga útil de un trabajo recomendado. Para obtener más información acerca de los campos, consulte RecommendationJobPayloadConfig.

   • Framework: el marco de machine learning de la imagen del contenedor, como PyTorch.

   • FrameworkVersion: la versión del marco de la imagen del contenedor.

   • (Opcional) SupportedInstanceTypes: una lista de los tipos de instancias que se utilizan para generar inferencias en tiempo real.

   Si utiliza el parámetro SupportedInstanceTypes, el Recomendador de inferencias limita el espacio de búsqueda para los tipos de instancias durante un trabajo Default. Use este parámetro si tiene limitaciones presupuestarias o si sabe que hay un conjunto específico de tipos de instancias compatibles con su imagen de modelo y contenedor.

   En el siguiente ejemplo de código, utilizamos los parámetros previamente definidos junto con NearestModelName, para definir un diccionario que se utiliza como entrada en la 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,
           }