Requisitos previos para usar Amazon SageMaker Inference Recommender

Modo de enfoque

Requisitos previos para usar Amazon SageMaker Inference Recommender - Amazon SageMaker AI

Antes de poder utilizar Amazon SageMaker Inference Recommender, debe completar los pasos previos. A modo de ejemplo, mostramos cómo utilizar un modelo PyTorch (v1.7.1) ResNet -18 previamente entrenado para ambos tipos de trabajos de recomendación de Amazon SageMaker Inference Recommender. Los ejemplos que se muestran utilizan el AWS SDK para Python (Boto3).

nota

Los siguientes ejemplos de código utilizan Python. Elimine el carácter de prefijo ! si ejecuta alguno de los siguientes ejemplos de código en su terminal o AWS CLI.
Puede ejecutar los siguientes ejemplos con el núcleo de Python 3 (TensorFlow 2.6 Python 3.8 optimizado para CPU) en un bloc de notas de Amazon SageMaker Studio. Para obtener más información sobre Studio, consulte Amazon SageMaker Studio.

Cree un rol de IAM para Amazon SageMaker AI.

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

Configure el entorno.

Importe las dependencias y cree variables para usted Región de AWS, su función de IAM de SageMaker IA (desde el paso 1) y el cliente de IA. SageMaker


!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 siguientes pasos, debe utilizar el dominio, el marco, 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 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 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 AI requiere que los modelos de aprendizaje automático previamente entrenados se empaqueten como un 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 La IA 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 Apache, MXNet TensorFlow PyTorch, y Chainer. Para ver una lista completa de las imágenes de SageMaker IA disponibles, consulte Imágenes de Deep Learning Containers disponibles.

Si ninguno de los contenedores de SageMaker IA 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 el SDK de SageMaker Python:
```
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 instancias de SageMaker IA disponibles, consulta los 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 finales de SageMaker IA. 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 en este ejemplo se 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 su modelo en Model Registry, que puede utilizar para catalogar modelos para su producción, o puede crear un modelo de SageMaker IA 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 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 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 para 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 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 de forma programática e interactiva un grupo de paquetes modelo y cómo crear un paquete modelo versionado, respectivamente, con Amazon Studio Classic y AWS SDK para 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 para Python (Boto3).

nota
No es necesario aprobar el paquete de modelos para crear un trabajo de recomendación de inferencias.
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)
```
  Consulta la Guía de referencia de las SageMaker API de Amazon para obtener 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. 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 del Amazon Simple Storage Service (Amazon S3) donde se almacena la carga útil 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 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 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 modelo para utilizar Amazon SageMaker Inference Recommender. 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 IA y configurará el ContainerConfig campo como entrada para el trabajo de recomendaciones.
1. Crear un modelo
  
  Cree un modelo con la API CreateModel. Para ver un ejemplo en el que se utiliza este método al implementar un modelo en SageMaker AI Hosting, consulte Create a Model (AWS SDK para 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 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 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 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,
        }
```