Conditions préalables pour utiliser Amazon SageMaker Inference Recommender

Avant de pouvoir utiliser Amazon SageMaker Inference Recommender, vous devez effectuer les étapes des conditions préalables. À titre d’exemple, nous montrons comment utiliser un modèle pré-entraîné PyTorch (v1.7.1) ResNet-18 pour les deux types de tâches de recommandation Amazon SageMaker Inference Recommender. Les exemples présentés utilisent le kit AWS SDK pour Python (Boto3).

Note

Les exemples de code suivants utilisent Python. Supprimez le caractère de préfixe ! si vous exécutez l’un des exemples de code suivants dans votre terminal ou AWS CLI.
Vous pouvez exécuter les exemples suivants avec le noyau Python 3 (optimisé pour le CPU TensorFlow 2.6 Python 3.8) dans un bloc-notes Amazon SageMaker Studio. Pour plus d’informations sur Studio, consultez Amazon SageMaker Studio.

Créez un rôle IAM pour Amazon SageMaker AI.

Créez un rôle IAM pour Amazon SageMaker AI auquel est attachée la politique gérée IAM AmazonSageMakerFullAccess.

Configurez votre environnement.

Importez des dépendances et créez des variables pour votre Région AWS, votre rôle IAM pour SageMaker AI (à partir de l’étape 1) et le 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()

(Facultatif) Examinez les modèles existants évalués par Inference Recommender.

Inference Recommender compare les modèles de zoos de modèles populaires. Inference Recommender prend en charge votre modèle même s’il n’est pas déjà étalonné.

Utilisez ListModelMetaData pour obtenir un objet de réponse qui répertorie le domaine, le cadre, la tâche et le nom de modèle des modèles de machine learning trouvés dans les zoos de modèles courants.

Vous utilisez le domaine, le cadre, la version du cadre, la tâche et le nom du modèle dans les étapes ultérieures pour sélectionner une image Docker d’inférence et enregistrer votre modèle dans le registre de modèles SageMaker. Voici comment répertorier les métadonnées de modèle avec le kit SDK Python (Boto3) :


list_model_metadata_response=sagemaker_client.list_model_metadata()

La sortie comprend des résumés de modèle (ModelMetadataSummaries) et des métadonnées de réponse (ResponseMetadata) similaires à l’exemple suivant :


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

Pour cette démonstration, nous utilisons un modèle PyTorch (v1.7.1) ResNet-18 afin d’effectuer la classification des images. L’exemple de code Python suivant stocke le framework, la version du framework, le domaine et la tâche dans des variables pour une utilisation ultérieure :


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

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

Chargez votre modèle de machine learning sur Amazon S3.

Utilisez ce modèle PyTorch (v1.7.1) ResNet-18 si vous ne disposez pas d’un modèle de machine learning pré-entraîné :
```
# 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')
```
Téléchargez un exemple de script d’inférence inference.py. Créez un répertoire code et déplacez le script d’inférence vers le répertoire 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 nécessite que les modèles de machine learning pré-entraînés soient conditionnés sous forme de fichier TAR compressé (*.tar.gz). Compressez votre modèle et votre script d’inférence pour répondre à cette exigence :
```
!tar -czf test.tar.gz model.pth code/inference.py
```
Lorsque votre point de terminaison est approvisionné, les fichiers de l’archive sont extraits dans /opt/ml/model/ sur le point de terminaison.

Après avoir compressé votre modèle et les artefacts de modèle en tant que fichier .tar.gz, chargez-les dans votre compartiment Amazon S3. L’exemple suivant montre comment charger votre modèle sur Amazon S3 à l’aide de l’AWS CLI :
```
!aws s3 cp test.tar.gz s3://{your-bucket}/models/
```
Sélectionnez une image d’inférence Docker prédéfinie ou créez votre propre image Docker d’inférence.

SageMaker AI fournit des conteneurs pour ses algorithmes intégrés et des images Docker préconçues pour certains des cadres de machine learning les plus courants, tels qu’Apache MXNet, TensorFlow, PyTorch et Chainer. Pour obtenir la liste complète des images SageMaker AI disponibles, consultez Images Deep Learning Containers disponibles.

Si aucun des conteneurs SageMaker AI existants ne répond à vos besoins et que vous n’avez pas de conteneur existant personnel, créez une image Docker. Consultez Conteneurs avec code d’inférence personnalisé pour savoir comment créer votre image Docker.

Ce qui suit montre comment récupérer une image d’inférence PyTorch version 1.7.1 à l’aide du kit 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')
```
Pour connaître la liste des instances SageMaker AI disponibles, consultez Tarification d’Amazon SageMaker AI.
Créez un exemple d’archive de données utiles.

Créez une archive contenant des fichiers individuels que l’outil de test de charge peut envoyer à vos points de terminaison SageMaker AI. Votre code d’inférence doit être capable de lire les formats de fichier à partir de l’exemple de données utiles.

Ce qui suit télécharge une image .jpg que cet exemple utilise dans une étape ultérieure pour le modèle ResNet-18.
```
!wget https://cdn.pixabay.com/photo/2020/12/18/05/56/flowers-5841251_1280.jpg
```
Compressez l’exemple de données utiles en tant qu’archive :
```
!tar -cvzf payload.tar.gz flowers-5841251_1280.jpg
```
Chargez l’exemple de données utiles sur Amazon S3 et notez l’URI Amazon S3 :
```
!aws s3 cp payload.tar.gz s3://{bucket}/models/
```
Vous aurez besoin de l’URI Amazon S3 dans une étape ultérieure, alors stockez-le dans une 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}"
```
Préparez l’entrée de votre modèle pour la tâche de recommandation.

Pour ce dernier prérequis, deux options s’offrent à vous pour préparer votre entrée de modèle. Vous pouvez enregistrer votre modèle avec le registre de modèles SageMaker, que vous pouvez utiliser pour cataloguer les modèles pour la production, ou vous pouvez créer un modèle SageMaker AI et le spécifier dans le champ ContainerConfig lors de la création d’une tâche de recommandation. La première option est la meilleure si vous souhaitez tirer parti des fonctionnalités fournies par le registre de modèles, telles que la gestion des versions de modèle et l’automatisation du déploiement de modèle. La deuxième option est idéale si vous souhaitez commencer rapidement. Pour la première option, passez à l’étape 7. Pour la deuxième option, ignorez l’étape 7 et passez à l’étape 8.
Option 1 : enregistrez votre modèle dans le registre de modèles.

Avec le registre de modèles SageMaker, vous pouvez cataloguer des modèles pour la production, gérer les versions de modèle, associer des métadonnées (telles que des métriques d’entraînement) à un modèle, gérer le statut d’approbation d’un modèle, déployer des modèles en production et automatiser le déploiement de modèle avec CI/CD.

Lorsque vous utilisez SageMaker Model Registry pour suivre et gérer vos modèles, ils sont représentés en tant que package de modèle versionné au sein des groupes de packages de modèle. Les packages de modèle non versionné ne font pas partie d’un groupe de modèles. Les groupes de packages de modèle contiennent plusieurs versions ou itérations d’un modèle. Bien qu’il ne soit pas obligatoire de les créer pour chaque modèle du registre, ils aident à organiser divers modèles qui ont tous le même objectif et fournissent la gestion automatique des versions.

Pour utiliser Amazon SageMaker Inference Recommender, vous devez disposer d’un package de modèle versionné. Vous pouvez créer un package de modèle versionné par programmation avec le kit AWS SDK pour Python (Boto3) ou avec Amazon SageMaker Studio Classic. Pour créer un package de modèle versionné par programmation, créez d’abord un groupe de packages de modèle avec l’API CreateModelPackageGroup. Ensuite, créez un package de modèle à l’aide de l’API CreateModelPackage. L’appel de cette méthode crée un package de modèle versionné.

Consultez Création d’un groupe de modèles et Enregistrement d’une version de modèle pour obtenir des instructions détaillées sur la création par programmation et de manière interactive d’un groupe de packages de modèle et sur la création d’un package de modèle versionné, respectivement, avec le kit AWS SDK pour Python (Boto3) et Amazon SageMaker Studio Classic.

L’exemple de code suivant montre comment créer un package de modèle versionné à l’aide du kit AWS SDK pour Python (Boto3).

Note
Vous n’avez pas besoin d’approuver le package de modèle pour créer une tâche Inference Recommender.
1. Création d’un groupe de packages de modèle
  
  Créez un groupe de packages de modèle avec l’API CreateModelPackageGroup. Fournissez un nom au groupe de package de modèle pour le ModelPackageGroupName et fournissez éventuellement une description du package de modèle dans le champ 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)
```
  Consultez le Guide de Référence des API Amazon SageMaker pour connaître la liste complète des arguments facultatifs et obligatoires que vous pouvez transmettre à CreateModelPackageGroup.
  
  Créez un package de modèle en spécifiant une image Docker qui exécute votre code d’inférence et l’emplacement Amazon S3 de vos artefacts de modèle, et fournissez des valeurs pour InferenceSpecification. InferenceSpecification doit contenir des informations sur les tâches d’inférence pouvant être exécutées avec des modèles basés sur ce package de modèle, notamment :
  - Chemins Amazon ECR des images qui exécutent votre code d’inférence.
  - (Facultatif) Les types d’instances pris en charge par le package de modèle pour les tâches de transformation et les points de terminaison en temps réel utilisés pour l’inférence.
  - Les formats de contenu d’entrée et de sortie que le package de modèle prend en charge pour l’inférence.
  En outre, vous devez spécifier les paramètres suivants lorsque vous créez un package de modèle :
  - Domain : domaine de machine learning de votre package de modèle et de ses composants. Les domaines de machine learning courants incluent la reconnaissance d’image et le traitement du langage naturel.
  - Task : tâche de machine learning effectuée par votre package de modèle. Les tâches de machine learning courantes incluent la détection d’objets et la classification des images. Indiquez « OTHER » (AUTRE) si aucune des tâches répertoriées dans le Guide de référence des API ne correspond à votre cas d’utilisation. Consultez les descriptions des champs de l’API Task (Tâche) pour obtenir une liste des tâches de machine learning prises en charge.
  - SamplePayloadUrl : chemin Amazon Simple Storage Service (Amazon S3) où est stocké l’exemple de données utiles. Ce chemin doit pointer vers une seule archive TAR compressée GZIP (suffixe .tar.gz).
  - Framework : cadre de machine learning de l’image de conteneur du package de modèle.
  - FrameworkVersion : version du cadre de l’image de conteneur du package de modèle.
  Si vous fournissez une liste d’autorisation des types d’instances à utiliser pour générer des inférences en temps réel pour SupportedRealtimeInferenceInstanceTypes, Inference Recommender limite l’espace de recherche pour les types d’instances pendant une tâche Default. Utilisez ce paramètre si vous avez des contraintes budgétaires ou si vous savez qu’un ensemble spécifique de types d’instances peut prendre en charge votre modèle et votre image de conteneur.
  
  Dans une étape précédente, nous avons téléchargé un modèle ResNet18 pré-entraîné et l’avons stocké dans un compartiment Amazon S3 dans un répertoire appelé models. Nous avons récupéré une image d’inférence du conteneur deep learning PyTorch (v1.7.1) et stocké l’URI dans une variable appelée image_uri. Utilisez ces variables dans l’exemple de code suivant pour définir un dictionnaire utilisé comme entrée de 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. Création d’un package de modèle
  
  Utilisez l’API CreateModelPackage pour créer un package de modèle. Transmettez le dictionnaire d’entrée défini à l’étape précédente :
```
model_package_response = sagemaker_client.create_model_package(**model_package_input_dict)
```
  Vous avez besoin de l’ARN du package de modèle pour utiliser Amazon SageMaker Inference Recommender. Notez l’ARN du package de modèle ou stockez-le dans une variable :
```
model_package_arn = model_package_response["ModelPackageArn"]

print('ModelPackage Version ARN : {}'.format(model_package_arn))
```
Option 2 : créez un modèle et configurez le champ ContainerConfig

Utilisez cette option si vous souhaitez démarrer une tâche de recommandation d’inférence et que vous n’avez pas besoin d’enregistrer votre modèle dans le registre de modèles. Au cours des étapes suivantes, vous allez créer un modèle dans SageMaker AI et configurer le champ ContainerConfig en tant qu’entrée pour la tâche de recommandation.
1. Création d’un modèle
  
  Créez un modèle avec l’API CreateModel. Pour voir un exemple qui appelle cette méthode lors du déploiement d’un modèle dans l’hébergement SageMaker AI, consultez Création d’un modèle (AWS SDK pour Python (Boto3)).
  
  Dans une étape précédente, nous avons téléchargé un modèle ResNet18 pré-entraîné et l’avons stocké dans un compartiment Amazon S3 dans un répertoire appelé models. Nous avons récupéré une image d’inférence du conteneur deep learning PyTorch (v1.7.1) et stocké l’URI dans une variable appelée image_uri. Nous utilisons ces variables dans l’exemple de code suivant où nous définissons un dictionnaire utilisé comme entrée de 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. Configuration du champ ContainerConfig
  
  Ensuite, vous devez configurer le champ ContainerConfig avec le modèle que vous venez de créer et y spécifier les paramètres suivants :
  - Domain : domaine de machine learning du modèle et de ses composants, tels que la vision par ordinateur ou le traitement du langage naturel.
  - Task : tâche de machine learning exécutée par le modèle, telle que la classification d’images ou la détection d’objets.
  - PayloadConfig : configuration des données utiles pour une tâche de recommandation. Pour plus d’informations sur les sous-champs, consultez RecommendationJobPayloadConfig.
  - Framework : cadre de machine learning de l’image de conteneur, tel que PyTorch.
  - FrameworkVersion : version du cadre de l’image de conteneur.
  - (Facultatif) SupportedInstanceTypes : liste des types d’instance utilisés pour générer des inférences en temps réel.
  Si vous utilisez le paramètre SupportedInstanceTypes, Inference Recommender limite l’espace de recherche pour les types d’instance au cours d’une tâche Default. Utilisez ce paramètre si vous avez des contraintes budgétaires ou si vous savez qu’un ensemble spécifique de types d’instances peut prendre en charge votre modèle et votre image de conteneur.
  
  Dans l’exemple de code suivant, nous utilisons les paramètres définis précédemment, ainsi que NearestModelName, pour définir un dictionnaire utilisé comme entrée de 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,
        }
```

Avertissement JavaScript est désactivé ou n'est pas disponible dans votre navigateur.

Pour que vous puissiez utiliser la documentation AWS, Javascript doit être activé. Vous trouverez des instructions sur les pages d'aide de votre navigateur.

Conventions de rédaction

Inference Recommender

Tâches de recommandation