Prérequis

Pour utiliser Amazon SageMaker Inference Recommender, assurez-vous d'abord de remplir les conditions requises dans la liste suivante. À 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 AWS SDK for 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 (TensorFlow 2.6 Python 3.8 CPU optimisé) dans un bloc-notes Amazon SageMaker Studio. Pour plus d'informations sur Studio, consultezAmazon SageMaker Studio.

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

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

Configurez votre environnement.

Importez des dépendances et créez des variables pour vous Région AWS, votre SageMaker IAM rôle (à partir de l'étape 1) et le SageMaker client.


!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 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 utiliserez le domaine, le framework, la version du framework, 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 auprès SageMaker de Model Registry. Ce qui suit montre comment répertorier les métadonnées d'un modèle avec SDK pour Python (Boto3) :


list_model_metadata_response=sagemaker_client.list_model_metadata()

La sortie inclut des résumés de modèles (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 pour 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 d'apprentissage automatique 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 exige que les modèles d'apprentissage automatique préformés soient regroupés sous forme de TAR fichier 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 télécharger votre modèle sur Amazon S3 à l'aide de 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 fournit des conteneurs pour ses algorithmes intégrés et des images Docker prédéfinies pour certains des frameworks d'apprentissage automatique les plus courants, tels qu'ApacheMXNet, TensorFlow PyTorch, et Chainer. Pour une liste complète des SageMaker images disponibles, consultez Available Deep Learning Containers Images.

Si aucun des SageMaker conteneurs existants ne répond à vos besoins et que vous n'avez pas de conteneur existant, créez une nouvelle image Docker. Consultez Utilisation de votre propre code d'inférence pour savoir comment créer votre image Docker.

Ce qui suit montre comment récupérer une image d'inférence de PyTorch la version 1.7.1 à l'aide de 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')
```
Pour obtenir la liste des SageMaker instances disponibles, consultez les SageMakertarifs Amazon.
Créez un exemple d'archive de charge utile.

Créez une archive contenant des fichiers individuels que l'outil de test de charge peut envoyer à vos SageMaker terminaux. Votre code d'inférence doit être capable de lire les formats de fichier à partir de l'exemple de charge utile.

Ce qui suit télécharge une image .jpg que cet exemple utilisera ultérieurement 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 charge utile en tant qu'archive :
```
!tar -cvzf payload.tar.gz flowers-5841251_1280.jpg
```
Téléchargez l'exemple de charge utile sur Amazon S3 et notez l'Amazon S3 URI :
```
!aws s3 cp payload.tar.gz s3://{bucket}/models/
```
Vous aurez besoin de l'Amazon S3 URI ultérieurement, 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 recommandations.

Pour ce dernier prérequis, deux options s'offrent à vous pour préparer votre entrée de modèle. Vous pouvez soit enregistrer votre modèle dans le registre des SageMaker modèles, que vous pouvez utiliser pour cataloguer les modèles destinés à la production, soit créer un SageMaker modèle et le spécifier dans le ContainerConfig champ 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 des 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 SageMaker Model Registry, vous pouvez cataloguer les modèles destinés à la production, gérer les versions des modèles, associer des métadonnées (telles que les indicateurs de formation) à 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èles avec CI/CD.

Lorsque vous utilisez SageMaker Model Registry pour suivre et gérer vos modèles, ceux-ci sont représentés sous la forme d'un package de modèles versionné au sein de groupes de packages de modèles. Les packages de modèles non versionnés 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 un contrôle de version automatique.

Pour utiliser Amazon SageMaker Inference Recommender, vous devez disposer d'un modèle de package versionné. Vous pouvez créer un package de modèle versionné par programmation avec ou AWS SDK for Python (Boto3) avec Amazon SageMaker Studio Classic. Pour créer un package de modèles versionné par programmation, créez d'abord un groupe de packages de modèles avec le. CreateModelPackageGroup API Créez ensuite un modèle de package à l'aide du CreateModelPackageAPI. 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 façon de créer de manière programmatique et interactive un groupe de packages de modèles et sur la manière de créer un package de modèles versionné, respectivement, avec Amazon Studio Classic et AWS SDK for Python (Boto3) Amazon Studio. SageMaker

L'exemple de code suivant montre comment créer un package de modèle versionné à l'aide de AWS SDK for 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éer un groupe de packages de modèle
  
  Créez un groupe de packages modèles avec le CreateModelPackageGroupAPI. 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 SageMaker API référence Amazon pour obtenir la liste complète des arguments facultatifs et obligatoires auxquels vous pouvez passer CreateModelPackageGroup.
  
  Créez un package de modèles en spécifiant une image Docker qui exécute votre code d'inférence et l'emplacement Amazon S3 des artefacts de votre modèle et en fournissant des valeurs pour. InferenceSpecification InferenceSpecificationdoit contenir des informations sur les tâches d'inférence qui peuvent être exécutées avec des modèles basés sur ce package de modèles, notamment les suivantes :
  - Les ECR chemins Amazon des images qui exécutent votre code d'inférence.
  - (Facultatif) Les types d'instances pris en charge par le package de modèles 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èles :
  - Domain : domaine de machine learning de votre package de modèles 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èles. Les tâches de machine learning courantes incluent la détection d'objets et la classification des images. Spécifiez « OTHER » si aucune des tâches répertoriées dans le guide de API référence ne correspond à votre cas d'utilisation. Consultez les descriptions des API champs Tâches pour obtenir la liste des tâches d'apprentissage automatique prises en charge.
  - SamplePayloadUrl: le chemin Amazon Simple Storage Service (Amazon S3) où l'échantillon de charge utile est stocké. Ce chemin doit pointer vers une seule TAR archive GZIP compressée (suffixe .tar.gz).
  - Framework : cadre de machine learning de l'image de conteneur du package de modèles.
  - FrameworkVersion: version framework de l'image du conteneur du package modèle.
  Si vous fournissez une liste autorisée de types d'instances à utiliser pour générer des inférences en temps réel pour le SupportedRealtimeInferenceInstanceTypes, Inference Recommender limite l'espace de recherche pour les types d'instances 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.
  
  Lors d'une étape précédente, nous avons téléchargé un modèle ResNet 18 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 PyTorch (v1.7.1) Deep Learning Container et l'avons stockée 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 dans le 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. Création d'un package modèle
  
  Utilisez le CreateModelPackage API pour créer un modèle de package. 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 du package modèle ARN pour utiliser Amazon SageMaker Inference Recommender. Notez le modèle ARN de package 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 recommandations d'inférence et que vous n'avez pas besoin d'enregistrer votre modèle dans le registre des modèles. Dans les étapes suivantes, vous créez un modèle SageMaker et configurez le ContainerConfig champ comme entrée pour la tâche de recommandation.
1. Création d'un modèle
  
  Créez un modèle avec CreateModelAPI. Pour un exemple qui appelle cette méthode lors du déploiement d'un modèle sur SageMaker Hosting, voir Create a Model (AWS SDK for Python (Boto3)).
  
  Lors d'une étape précédente, nous avons téléchargé un modèle ResNet 18 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 PyTorch (v1.7.1) Deep Learning Container et l'avons stockée 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 dans le CreateModelAPI.
```
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. Configurer le champ ContainerConfig
  
  Ensuite, vous devez configurer le ContainerConfigchamp 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 de la charge utile pour une tâche de recommandations. Pour plus d'informations sur les sous-champs, consultez RecommendationJobPayloadConfig.
  - Framework: le cadre d'apprentissage automatique de l'image du 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 queNearestModelName, pour définir un dictionnaire utilisé comme entrée dans le 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,
        }
```

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

Obtention d'une recommandation d'inférence pour les points de terminaison

Tâches de recommandations