Exécutez des charges de travail d'inférence de machine learning sur des instances basées sur AWS Graviton avec Amazon SageMaker PlatoBlockchain Data Intelligence. Recherche verticale. Aï.

Exécutez des charges de travail d'inférence d'apprentissage automatique sur des instances basées sur AWS Graviton avec Amazon SageMaker

Horodatage: 14 novembre 2022 3:08

Aujourd'hui, nous lançons Amazon Sage Maker inférence sur AWS Graviton pour vous permettre de profiter des avantages en termes de prix, de performances et d'efficacité des puces Graviton.

Des instances basées sur Graviton sont disponibles pour l'inférence de modèle dans SageMaker. Cet article vous aide à migrer et à déployer une charge de travail d'inférence d'apprentissage automatique (ML) de x86 vers des instances basées sur Graviton dans SageMaker. Nous fournissons un guide étape par étape pour déployer votre modèle formé SageMaker sur des instances basées sur Graviton, couvrir les meilleures pratiques lorsque vous travaillez avec Graviton, discuter des avantages en termes de rapport qualité-prix et montrer comment déployer un modèle TensorFlow sur une instance SageMaker Graviton.

Bref aperçu de Graviton

AWS Graviton est une famille de processeurs conçus par AWS qui offrent le meilleur rapport qualité-prix et sont plus économes en énergie que leurs homologues x86. Les processeurs AWS Graviton 3 sont les derniers de la famille de processeurs Graviton et sont optimisés pour les charges de travail ML, y compris la prise en charge de bfloat16 et deux fois la bande passante SIMD (Single Instruction Multiple Data). Lorsque ces deux fonctionnalités sont combinées, Graviton 3 peut offrir des performances jusqu'à trois fois supérieures à celles des instances Graviton 2. Graviton 3 utilise également jusqu'à 60 % d'énergie en moins pour les mêmes performances que des appareils comparables Cloud de calcul élastique Amazon (Amazon EC2). C'est une fonctionnalité intéressante si vous souhaitez réduire votre empreinte carbone et atteindre vos objectifs de développement durable.

Vue d'ensemble de la solution

Pour déployer vos modèles sur des instances Graviton, vous utilisez soit Conteneurs AWS Deep Learning or apportez vos propres contenants compatible avec l'architecture Arm v8.2.

La migration (ou le nouveau déploiement) de vos modèles d'instances alimentées par x86 vers des instances Graviton est simple car AWS fournit des conteneurs pour héberger des modèles avec PyTorch, TensorFlow, Scikit-learn et XGBoost, et les modèles sont indépendants de l'architecture. Néanmoins, si vous souhaitez apporter vos propres bibliothèques, vous pouvez également le faire, assurez-vous simplement que votre conteneur est construit avec un environnement prenant en charge l'architecture Arm64. Pour plus d'informations, voir Construire votre propre conteneur d'algorithmes.

Vous devez suivre trois étapes pour déployer votre modèle :

  1. Créer un modèle SageMaker : il contiendra, entre autres paramètres, les informations sur l'emplacement du fichier de modèle, le conteneur qui sera utilisé pour le déploiement et l'emplacement du script d'inférence. (Si vous avez un modèle existant déjà déployé dans une instance d'inférence basée sur x86, vous pouvez ignorer cette étape.)
  2. Créez une configuration de point de terminaison : elle contiendra des informations sur le type d'instance que vous souhaitez pour le point de terminaison (par exemple, ml.c7g.xlarge pour Graviton3), le nom du modèle que vous avez créé à l'étape 1 et le nombre d'instances par point final.
  3. Lancez le point de terminaison avec la configuration de point de terminaison créée à l'étape 2.

Pré-requis

Avant de commencer, considérez les prérequis suivants :

  1. Remplir les conditions préalables comme indiqué dans Pré-requis.
  2. Votre modèle doit être un modèle basé sur PyTorch, TensorFlow, XGBoost ou Scikit-learn. Le tableau suivant récapitule les versions actuellement prises en charge au moment de la rédaction de cet article. Pour les dernières mises à jour, consultez Conteneurs SageMaker Framework (prise en charge SM uniquement).
    . Python TensorFlow PyTorch Scikit-apprendre XGBoost
    Versions prises en charge 3.8 2.9.1 1.12.1 1.0-1 1.3-1 au 1.5-1
  3. Le script d'inférence est stocké dans Service de stockage simple Amazon (Amazon S3).

Dans les sections suivantes, nous vous expliquons les étapes de déploiement.

Créer un modèle SageMaker

Si vous avez un modèle existant déjà déployé dans une instance d'inférence basée sur x86, vous pouvez ignorer cette étape. Sinon, suivez les étapes suivantes pour créer un modèle SageMaker :

  1. Localisez le modèle que vous avez stocké dans un compartiment S3. Copiez l'URI.
    Vous utilisez l'URI du modèle plus tard dans le MODEL_S3_LOCATION.
  2. Identifiez la version du framework et la version Python qui ont été utilisées lors de la formation du modèle.
    Vous devez sélectionner un conteneur dans la liste des conteneurs AWS Deep Learning disponibles selon votre framework et votre version de Python. Pour plus d'informations, reportez-vous à Présentation des images de conteneur multi-architecture pour Amazon ECR.
  3. Localisez l'URI du script Python d'inférence dans le compartiment S3 (le nom de fichier commun est inference.py).
    L'URI du script d'inférence est nécessaire dans le INFERENCE_SCRIPT_S3_LOCATION.
  4. Avec ces variables, vous pouvez ensuite appeler l'API SageMaker avec la commande suivante : 
    client = boto3.client("sagemaker")

client.create_model(
    ModelName="Your model name",
    PrimaryContainer={
        "Image": ,
        "ModelDataUrl": ,
        "Environment": {
        "SAGEMAKER_PROGRAM": "inference.py",
        "SAGEMAKER_SUBMIT_DIRECTORY": ,
        "SAGEMAKER_CONTAINER_LOG_LEVEL": "20",
        "SAGEMAKER_REGION": 
        }
    },
    ExecutionRoleArn= 
)

Vous pouvez également créer des images multi-architectures et utiliser la même image mais avec des balises différentes. Vous pouvez indiquer sur quelle architecture votre instance sera déployée. Pour plus d'informations, reportez-vous à Présentation des images de conteneur multi-architecture pour Amazon ECR.

Créer une configuration de point de terminaison

Après avoir créé le modèle, vous devez créer une configuration de point de terminaison en exécutant la commande suivante (notez le type d'instance que nous utilisons) :

client.create_endpoint_config(
    EndpointConfigName= ,
    ProductionVariants=[
        {
         "VariantName": "v0",
         "ModelName": "Your model name",
         "InitialInstanceCount": 1,
         "InstanceType": "ml.c7g.xlarge",
        },
    ]
)

La capture d'écran suivante montre les détails de configuration du point de terminaison sur la console SageMaker.

Lancer le point de terminaison

Avec la configuration du point de terminaison créée à l'étape précédente, vous pouvez déployer le point de terminaison :

client.create_endpoint(
    EndpointName = "",
    EndpointConfigName = ""
    )

Attendez que votre point de terminaison de modèle soit déployé. Les prédictions peuvent être demandées de la même manière que vous demandez des prédictions pour vos points de terminaison déployés dans des instances x86.

La capture d'écran suivante montre votre point de terminaison sur la console SageMaker.

Point de terminaison SageMaker à partir de la configuration

Ce qui est pris en charge

SageMaker fournit des conteneurs profonds Graviton aux performances optimisées pour les frameworks TensorFlow et PyTorch. Ces conteneurs prennent en charge la vision par ordinateur, le traitement du langage naturel, les recommandations et les cas d'utilisation génériques d'inférence basée sur un modèle profond et large. En plus des conteneurs d'apprentissage en profondeur, SageMaker fournit également des conteneurs pour les frameworks ML classiques tels que XGBoost et Scikit-learn. Les conteneurs sont compatibles en binaire sur les instances c6g/m6g et c7g, donc la migration de l'application d'inférence d'une génération à l'autre est transparente.

C6g/m6g prend en charge fp16 (flotteur de demi-précision) et pour les modèles compatibles, fournit des performances équivalentes ou meilleures par rapport aux instances c5. C7g augmente considérablement les performances ML en doublant la largeur SIMD et en prenant en charge bfloat-16 (bf16), qui est la plate-forme la plus rentable pour exécuter vos modèles.

C6g/m6g et c7g offrent de bonnes performances pour le ML classique (par exemple, XGBoost) par rapport aux autres instances de CPU dans SageMaker. La prise en charge de Bfloat-16 sur c7g permet un déploiement efficace de modèles formés bf16 ou formés AMP (Automatic Mixed Precision). Le backend Arm Compute Library (ACL) sur Graviton fournit des noyaux bfloat-16 qui peuvent accélérer même les opérateurs fp32 via le mode mathématique rapide, sans la quantification du modèle.

Bonnes pratiques recommandées

Sur les instances Graviton, chaque vCPU est un cœur physique. Il n'y a pas de conflit pour les ressources CPU communes (contrairement à SMT), et la mise à l'échelle des performances de la charge de travail est linéaire avec chaque ajout de vCPU. Par conséquent, il est recommandé d'utiliser l'inférence par lots chaque fois que le cas d'utilisation le permet. Cela permettra une utilisation efficace des vCPU en traitant en parallèle le lot sur chaque cœur physique. Si l'inférence par lots n'est pas possible, la taille d'instance optimale pour une charge utile donnée est requise pour garantir que la surcharge de planification des threads du système d'exploitation ne dépasse pas la puissance de calcul fournie avec les vCPU supplémentaires.

TensorFlow est livré avec les noyaux Eigen par défaut, et il est recommandé de passer à OneDNN avec ACL pour obtenir le backend d'inférence le plus optimisé. Le backend OneDNN et le mode mathématique rapide bfloat-16 peuvent être activés lors du lancement du service de conteneur :

docker run -p 8501:8501 --name tfserving_resnet 
--mount type=bind,source=/tmp/resnet,target=/models/resnet 
-e MODEL_NAME=resnet -e TF_ENABLE_ONEDNN_OPTS=1 
-e DNNL_DEFAULT_FPMATH_MODE=BF16 -e -t tfs:mkl_aarch64

La commande de service précédente héberge un modèle resnet50 standard avec deux configurations importantes :

-e TF_ENABLE_ONEDNN_OPTS=1
-e DNNL_DEFAULT_FPMATH_MODE=BF16

Ceux-ci peuvent être transmis au conteneur d'inférence de la manière suivante :

client.create_model(
    ModelName="Your model name",
    PrimaryContainer={
    "Image": ,
    "ModelDataUrl": ,
    "Environment": {
        "SAGEMAKER_PROGRAM": "inference.py",
        "SAGEMAKER_SUBMIT_DIRECTORY": "",
        "SAGEMAKER_CONTAINER_LOG_LEVEL": "20",
        "SAGEMAKER_REGION": ,
        "TF_ENABLE_ONEDNN_OPTS": "1",
        "DNNL_DEFAULT_FPMATH_MODE": "BF16"
         }
     },
     ExecutionRoleArn='ARN for AmazonSageMaker-ExecutionRole'
)

Exemple de déploiement

Dans cet article, nous vous montrons comment déployer un modèle TensorFlow, formé dans SageMaker, sur une instance d'inférence SageMaker alimentée par Graviton.

Vous pouvez exécuter l'exemple de code dans une instance de bloc-notes SageMaker, un Amazon SageMakerStudio notebook ou un notebook Jupyter en mode local. Vous devez récupérer le rôle d'exécution SageMaker si vous utilisez un notebook Jupyter en mode local.

L'exemple suivant considère l'ensemble de données CIFAR-10. Vous pouvez suivre l'exemple de bloc-notes à partir des exemples SageMaker GitHub repo pour reproduire le modèle qui est utilisé dans ce post. Nous utilisons le modèle formé et le cifar10_keras_main.py Script Python pour l'inférence.

Le modèle est stocké dans un bucket S3 : s3://aws-ml-blog/artifacts/run-ml-inference-on-graviton-based-instances-with-amazon-sagemaker/model.tar.gz

La cifar10_keras_main.py script, qui peut être utilisé pour l'inférence, est stocké dans :s3://aws-ml-blog/artifacts/run-ml-inference-on-graviton-based-instances-with-amazon-sagemaker/script/cifar10_keras_main.py

Nous utilisons les us-east-1 Régionez et déployez le modèle sur une instance ml.c7g.xlarge basée sur Graviton. Sur cette base, l'URI de notre AWS Deep Learning Container est 763104351884.dkr.ecr.us-east-1.amazonaws.com/tensorflow-inference-graviton:2.9.1-cpu-py38-ubuntu20.04-sagemaker

  1. Configurez avec le code suivant : 
    import sagemaker
import boto3
import datetime
import json
import gzip
import os

sagemaker_session = sagemaker.Session()
bucket = sagemaker_session.default_bucket()
role = sagemaker.get_execution_role()
region = sagemaker_session.boto_region_name

  2. Téléchargez l'ensemble de données pour les tests de point de terminaison : 
    from keras.datasets import cifar10
(x_train, y_train), (x_test, y_test) = cifar10.load_data()

  3. Créez le modèle et la configuration du point de terminaison, puis déployez le point de terminaison : 
    timestamp = "{:%Y-%m-%d-%H-%M-%S}".format(datetime.datetime.now())

client = boto3.client("sagemaker")

MODEL_NAME = f"graviton-model-{timestamp}"
ENDPOINT_NAME = f"graviton-endpoint-{timestamp}"
ENDPOINT_CONFIG_NAME = f"graviton-endpoint-config-{timestamp}"

# create sagemaker model
create_model_response = client.create_model(
    ModelName=MODEL_NAME,
    PrimaryContainer={
    "Image":  "763104351884.dkr.ecr.us-east-1.amazonaws.com/tensorflow-inference-graviton:2.9.1-cpu-py38-ubuntu20.04-sagemaker ",
    "ModelDataUrl":  "s3://aws-ml-blog/artifacts/run-ml-inference-on-graviton-based-instances-with-amazon-sagemaker/model.tar.gz",
    "Environment": {
        "SAGEMAKER_CONTAINER_LOG_LEVEL": "20",
        "SAGEMAKER_REGION": region
        }
    },
    ExecutionRoleArn=role
)
print ("create_model API response", create_model_response)

  4. Vous pouvez éventuellement ajouter votre script d'inférence à Environment in create_model si vous ne l'avez pas initialement ajouté en tant qu'artefact à votre modèle SageMaker lors de la formation : 
    "SAGEMAKER_PROGRAM": "inference.py",
"SAGEMAKER_SUBMIT_DIRECTORY": ,
		
# create sagemaker endpoint config
create_endpoint_config_response = client.create_endpoint_config(
    EndpointConfigName=ENDPOINT_CONFIG_NAME,
    ProductionVariants=[
        {
         "VariantName": "v0",
         "ModelName": MODEL_NAME,
         "InitialInstanceCount": 1,
         "InstanceType": "ml.c7g.xlarge" 
        },
    ]
)
print ("ncreate_endpoint_config API response", create_endpoint_config_response)

# create sagemaker endpoint
create_endpoint_response = client.create_endpoint(
    EndpointName = ENDPOINT_NAME,
    EndpointConfigName = ENDPOINT_CONFIG_NAME,
)
print ("ncreate_endpoint API response", create_endpoint_response)

    Vous devez attendre quelques minutes pour que le déploiement ait lieu.

  5. Vérifiez l'état du point de terminaison avec le code suivant : 
    describe_response = client.describe_endpoint(EndpointName=ENDPOINT_NAME)
print(describe_response["EndpointStatus"]

    Vous pouvez également vérifier le Console de gestion AWS pour voir quand votre modèle est déployé.

  6. Configurez l'environnement d'exécution pour appeler les points de terminaison : 
    runtime = boto3.Session().client(service_name="runtime.sagemaker")

    Nous préparons maintenant la charge utile pour appeler le point de terminaison. Nous utilisons le même type d'images que celles utilisées pour l'entraînement du modèle. Ceux-ci ont été téléchargés dans les étapes précédentes.

  7. Diffusez la charge utile sur les tenseurs et définissez le format correct attendu par le modèle. Pour cet exemple, nous ne demandons qu'une seule prédiction. 
    input_image = x_test[0].reshape(1,32,32,3)

    Nous obtenons la sortie du modèle sous forme de tableau.

  8. Nous pouvons transformer cette sortie en probabilités si nous lui appliquons un softmax : 
    CONTENT_TYPE = 'application/json'
ACCEPT = 'application/json'
PAYLOAD = json.dumps(input_image.tolist())

response = runtime.invoke_endpoint(
    EndpointName=ENDPOINT_NAME, 
    ContentType=CONTENT_TYPE,
    Accept=ACCEPT,
    Body=PAYLOAD
)
    
print(response['Body'].read().decode())

Nettoyer les ressources

Les services impliqués dans cette solution entraînent des coûts. Lorsque vous avez terminé d'utiliser cette solution, nettoyez les ressources suivantes :

client.delete_endpoint(EndpointName=ENDPOINT_NAME)
client.delete_endpoint_config(EndpointConfigName=ENDPOINT_CONFIG_NAME)
client.delete_model(ModelName=MODEL_NAME)

Comparaison prix-performance

Les instances basées sur Graviton offrent le prix le plus bas et le meilleur rapport qualité-prix par rapport aux instances basées sur x86. Semblables aux instances EC2, les points de terminaison d'inférence SageMaker avec des instances ml.c6g (Graviton 2) offrent un prix inférieur de 20 % par rapport à ml.c5, et les instances Graviton 3 ml.c7g sont 15 % moins chères que les instances ml.c6. Pour plus d'informations, reportez-vous à Tarification d'Amazon SageMaker.

Conclusion

Dans cet article, nous avons présenté la capacité SageMaker récemment lancée pour déployer des modèles dans des instances d'inférence alimentées par Graviton. Nous vous avons donné des conseils sur les meilleures pratiques et discuté brièvement des avantages en termes de rapport qualité-prix du nouveau type d'instances d'inférence.

Pour en savoir plus sur Graviton, consultez Processeur AWS Graviton. Vous pouvez démarrer avec les instances EC2 basées sur AWS Graviton sur la console Amazon EC2 et en vous référant à Guide technique AWS Graviton. Vous pouvez déployer un point de terminaison de modèle Sagemaker pour l'inférence sur Graviton avec l'exemple de code dans cet article de blog.

À propos des auteurs

Victor JaramilloVictor Jaramillo, PhD, est un ingénieur principal en apprentissage machine dans les services professionnels AWS. Avant AWS, il était professeur d'université et chercheur en maintenance prédictive. Dans ses temps libres, il aime conduire sa moto et faire de la mécanique de moto bricoleur.

Zmnako AwrahmanZmnako Awrahman, PhD, est responsable de pratique, ML SME et membre de la communauté technique de terrain (TFC) Machine Learning chez Amazon Web Services. Il aide les clients à tirer parti de la puissance du cloud pour extraire la valeur de leurs données grâce à l'analyse de données et à l'apprentissage automatique.

Sunita NadampalliSunita Nadampalli est responsable du développement logiciel chez AWS. Elle dirige les optimisations des performances du logiciel Graviton pour les charges de travail d'apprentissage machine, HPC et multimédia. Elle est passionnée par le développement open source et la fourniture de solutions logicielles rentables avec les SoC Arm.

Johna LiuJohna Liu est ingénieur en développement logiciel au sein de l'équipe Amazon SageMaker. Son travail actuel vise à aider les développeurs à héberger efficacement des modèles d'apprentissage automatique et à améliorer les performances d'inférence. Elle est passionnée par l'analyse de données spatiales et l'utilisation de l'IA pour résoudre des problèmes de société.

Alan TanAlan Tan est chef de produit senior chez SageMaker, dirigeant les efforts sur l'inférence de grands modèles. Il est passionné par l'application de l'apprentissage automatique au domaine de l'analyse. En dehors du travail, il aime le plein air.

Horodatage:

Plus de Apprentissage automatique AWS