Requisitos previos para usar Amazon SageMaker Inference Recommender

Crea un IAM rol para Amazon SageMaker.

Crea un IAM rol para Amazon SageMaker que tenga la política AmazonSageMakerFullAccess IAM gestionada adjunta.

Configure su entorno.

Importe las dependencias y cree variables para usted Región de AWS, su SageMaker IAM función (desde el paso 1) y el 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) 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.

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

list_model_metadata_response=sagemaker_client.list_model_metadata()

El resultado incluye resúmenes del 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 PyTorch (v1.7.1) ResNet -18 si no tiene un modelo de aprendizaje automático 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 requiere que los modelos de aprendizaje automático previamente entrenados se empaqueten como un TAR archivo comprimido (*.tar.gz). Comprima el modelo y el script de inferencia para cumplir 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. El siguiente ejemplo muestra cómo cargar el modelo en Amazon S3 mediante 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 proporciona contenedores para sus algoritmos integrados e imágenes de Docker prediseñadas para algunos de los marcos de aprendizaje automático más comunes, como ApacheMXNet, TensorFlow PyTorch, y Chainer. Para obtener una lista completa de las SageMaker imágenes disponibles, consulte Imágenes disponibles de Deep Learning Containers.

Si ninguno de los SageMaker contenedores existentes satisface tus necesidades y no tienes uno propio, crea 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 la PyTorch versión 1.7.1 mediante 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 ver una lista de las SageMaker instancias disponibles, consulta los SageMakerprecios de Amazon.

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 SageMaker puntos de conexión. 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 Amazon S3URI:

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

Necesitará Amazon S3 URI en un paso posterior, así que guárdelo 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 su modelo en Model Registry, que puede utilizar para catalogar los modelos para su producción, o puede crear un SageMaker modelo y especificarlo en el ContainerConfig campo al crear un trabajo de recomendaciones. SageMaker 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 SageMaker Model Registry, puede catalogar modelos para su producción, administrar las versiones de los modelos, asociar metadatos (como las métricas de entrenamiento) a un modelo, administrar el estado de aprobación de un modelo, implementar modelos en producción y automatizar el despliegue del modelo con CI/CD.

Cuando usa SageMaker Model Registry para rastrear y administrar sus modelos, se representan como un paquete de modelos versionado dentro de los grupos de paquetes de modelos. Los paquetes de modelos no versionados 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 Amazon SageMaker Inference Recommender, debe tener un paquete de modelos versionado. Puede crear un paquete de modelos versionados mediante programación con o AWS SDK for Python (Boto3) con Amazon SageMaker Studio Classic. Para crear un paquete de modelos versionados mediante programación, primero cree un grupo de paquetes de modelos con. CreateModelPackageGroup API A continuación, cree un paquete de modelos con. CreateModelPackage API 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 un grupo de paquetes modelo de forma programática e interactiva y cómo crear un paquete modelo versionado, respectivamente, con Amazon Studio Classic y AWS SDK for Python (Boto3) Amazon Studio. SageMaker

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

1. Crear un grupo de paquetes de modelos

   Cree un grupo de paquetes modelo con. CreateModelPackageGroup API 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)

   Consulta la Guía de SageMaker API referencia de Amazon para ver una lista completa de los argumentos opcionales y obligatorios a los que puedes pasárselos 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 InferenceSpecificationdebe contener información sobre los trabajos de inferencia que se pueden ejecutar con modelos basados en este paquete de modelos, incluida la siguiente información:

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

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

   • Los formatos de contenido de entrada y salida que el paquete del modelo 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 "» si ninguna de las tareas enumeradas en la Guía de API referencia satisface su caso de uso. Consulte las descripciones de los API campos de tareas para obtener una lista de las tareas de aprendizaje automático compatibles.

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

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

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

   Si proporciona una lista de tipos de instancias permitidos para generar inferencias en tiempo real SupportedRealtimeInferenceInstanceTypes, Inference Recommender 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 un paso anterior, descargamos un modelo ResNet 18 previamente entrenado y lo almacenamos en un bucket de Amazon S3 en un directorio llamadomodels. Recuperamos una imagen de inferencia de Deep Learning Container PyTorch (versión 1.7.1) y la almacenamos URI en una variable llamada. image_uri Utilice esas variables en el siguiente ejemplo de código para definir un diccionario que se utilice como entrada para. 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. Cree un paquete modelo

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

   model_package_response = sagemaker_client.create_model_package(**model_package_input_dict)

   Necesita el paquete modelo ARN para utilizar Amazon SageMaker Inference Recommender. Anote el paquete ARN del modelo o guárdelo 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, se crea un modelo SageMaker y se configura el ContainerConfig campo como entrada para el trabajo de recomendaciones.

1. Crear un modelo

   Cree un modelo con CreateModelAPI. Para ver un ejemplo que utiliza este método al implementar un modelo en SageMaker Hosting, consulte Create a Model (AWS SDK for Python (Boto3)).

   En un paso anterior, descargamos un modelo ResNet 18 previamente entrenado y lo almacenamos en un bucket de Amazon S3 en un directorio llamadomodels. Recuperamos una imagen de inferencia de Deep Learning Container PyTorch (versión 1.7.1) y la almacenamos URI en una variable llamada. image_uri Usamos esas variables en el siguiente ejemplo de código, en el que definimos un diccionario que se usa como entrada para. 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. Configure el campo ContainerConfig

   A continuación, debe configurar el ContainerConfigcampo 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 aprendizaje automático 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 conNearestModelName, para definir un diccionario que se utiliza como entrada para 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,
           }