Optimisez le coût de déploiement des modèles de base Amazon SageMaker JumpStart avec les points de terminaison asynchrones Amazon SageMaker | Services Web Amazon

Le succès des applications d’IA générative dans un large éventail de secteurs a attiré l’attention et l’intérêt des entreprises du monde entier qui cherchent à reproduire et surpasser les réalisations de leurs concurrents ou à résoudre de nouveaux cas d’utilisation passionnants. Ces clients se tournent vers des modèles de base, tels que TII Falcon, Stable Diffusion XL ou GPT-3.5 d'OpenAI, comme moteurs qui alimentent l'innovation en matière d'IA générative.

Les modèles de base sont une classe de modèles d'IA génératifs capables de comprendre et de générer du contenu de type humain, grâce aux grandes quantités de données non structurées sur lesquelles ils ont été formés. Ces modèles ont révolutionné diverses tâches de vision par ordinateur (CV) et de traitement du langage naturel (NLP), notamment la génération d'images, la traduction et la réponse aux questions. Ils servent de base à de nombreuses applications d’IA et sont devenus un élément crucial dans le développement de systèmes intelligents avancés.

Cependant, le déploiement de modèles de fondation peut s’accompagner de défis importants, notamment en termes de coûts et de ressources nécessaires. Ces modèles sont connus pour leur taille, allant souvent de centaines de millions à des milliards de paramètres. Leur grande taille nécessite des ressources informatiques étendues, notamment un matériel puissant et une capacité de mémoire importante. En fait, le déploiement de modèles de base nécessite généralement au moins un (souvent plusieurs) GPU pour gérer efficacement la charge de calcul. Par exemple, le modèle TII Falcon-40B Instruct nécessite au moins une instance ml.g5.12xlarge pour être chargée avec succès en mémoire, mais fonctionne mieux avec des instances plus volumineuses. Par conséquent, le retour sur investissement (ROI) du déploiement et de la maintenance de ces modèles peut être trop faible pour prouver la valeur commerciale, en particulier pendant les cycles de développement ou pour les charges de travail pointues. Cela est dû aux coûts de fonctionnement liés aux instances alimentées par GPU pour de longues sessions, potentiellement 24h/7 et XNUMXj/XNUMX.

Plus tôt cette année, nous avons annoncé Socle amazonien, une API sans serveur pour accéder aux modèles de base d'Amazon et de nos partenaires d'IA générative. Bien qu'elle soit actuellement en version Private Preview, son API sans serveur vous permet d'utiliser les modèles de base d'Amazon, Anthropic, Stability AI et AI21, sans avoir à déployer vous-même des points de terminaison. Cependant, les modèles open source de communautés telles que Hugging Face se sont beaucoup développés, et tous n'ont pas été mis à disposition via Amazon Bedrock.

Dans cet article, nous ciblons ces situations et résolvons le problème du risque de coûts élevés en déployant de grands modèles de fondations pour Amazon Sage Maker points de terminaison asynchrones De Amazon SageMaker JumpStart. Cela peut contribuer à réduire les coûts de l'architecture, en permettant au point final de s'exécuter uniquement lorsque les demandes sont dans la file d'attente et pendant une courte durée de vie, tout en réduisant à zéro lorsqu'aucune demande n'est en attente d'être traitée. Cela semble idéal pour de nombreux cas d’utilisation ; cependant, un point final réduit à zéro introduira un temps de démarrage à froid avant de pouvoir servir d'inférences.

Vue d'ensemble de la solution

Le diagramme suivant illustre notre architecture de solution.

L'architecture que nous déployons est très simple :

• L'interface utilisateur est un ordinateur portable, qui peut être remplacé par une interface utilisateur Web basée sur Streamlit ou une technologie similaire. Dans notre cas, le carnet est un Amazon SageMakerStudio notebook, exécuté sur une instance ml.m5.large avec le noyau CPU PyTorch 2.0 Python 3.10.
• Le bloc-notes interroge le point de terminaison de trois manières : le SDK SageMaker Python, le SDK AWS pour Python (Boto3) et LangChain.
• Le point de terminaison s'exécute de manière asynchrone sur SageMaker et sur le point de terminaison, nous déployons le modèle Falcon-40B Instruct. Il s'agit actuellement de l'état de l'art en termes de modèles d'instructions et est disponible dans SageMaker JumpStart. Un seul appel API nous permet de déployer le modèle sur le point final.

Qu'est-ce que l'inférence asynchrone SageMaker

L'inférence asynchrone SageMaker est l'une des quatre options de déploiement de SageMaker, avec les points de terminaison en temps réel, l'inférence par lots et l'inférence sans serveur. Pour en savoir plus sur les différentes options de déploiement, reportez-vous à Déployer des modèles pour l'inférence.

L'inférence asynchrone de SageMaker met en file d'attente les requêtes entrantes et les traite de manière asynchrone, ce qui rend cette option idéale pour les requêtes avec des charges utiles importantes allant jusqu'à 1 Go, des temps de traitement longs et des exigences de latence en temps quasi réel. Cependant, le principal avantage qu'il offre lorsqu'il s'agit de modèles de base volumineux, en particulier lors d'une preuve de concept (POC) ou pendant le développement, est la possibilité de configurer l'inférence asynchrone pour évoluer jusqu'à un nombre d'instances de zéro lorsqu'il n'y a aucune demande de processus, économisant ainsi des coûts. Pour plus d'informations sur l'inférence asynchrone SageMaker, reportez-vous à Inférence asynchrone. Le schéma suivant illustre cette architecture.

Pour déployer un point de terminaison d'inférence asynchrone, vous devez créer un AsyncInferenceConfig objet. Si vous créez AsyncInferenceConfig sans préciser ses arguments, la valeur par défaut S3OutputPath sera s3://sagemaker-{REGION}-{ACCOUNTID}/async-endpoint-outputs/{UNIQUE-JOB-NAME} ainsi que S3FailurePath sera s3://sagemaker-{REGION}-{ACCOUNTID}/async-endpoint-failures/{UNIQUE-JOB-NAME}.

Qu'est-ce que SageMaker JumpStart

Notre modèle provient de SageMaker JumpStart, une fonctionnalité de SageMaker qui accélère le parcours d'apprentissage automatique (ML) en proposant des modèles pré-entraînés, des modèles de solution et des exemples de blocs-notes. Il donne accès à une large gamme de modèles pré-entraînés pour différents types de problèmes, vous permettant de démarrer vos tâches de ML avec une base solide. SageMaker JumpStart propose également des modèles de solution pour les cas d'utilisation courants et des exemples de blocs-notes pour l'apprentissage. Avec SageMaker JumpStart, vous pouvez réduire le temps et les efforts nécessaires au démarrage de vos projets de ML grâce à des lancements de solutions en un clic et à des ressources complètes pour une expérience pratique du ML.

La capture d'écran suivante montre un exemple de quelques-uns des modèles disponibles sur l'interface utilisateur de SageMaker JumpStart.

Déployer le modèle

Notre première étape consiste à déployer le modèle sur SageMaker. Pour ce faire, nous pouvons utiliser l'interface utilisateur de SageMaker JumpStart ou le SDK SageMaker Python, qui fournit une API que nous pouvons utiliser pour déployer le modèle sur le point de terminaison asynchrone :

%%time
from sagemaker.jumpstart.model import JumpStartModel, AsyncInferenceConfig
from sagemaker.serializers import JSONSerializer
from sagemaker.deserializers import JSONDeserializer model_id, model_version = "huggingface-llm-falcon-40b-instruct-bf16", "*"
my_model = JumpStartModel(model_id=model_id)
predictor = my_model.deploy( initial_instance_count=0, instance_type="ml.g5.12xlarge", async_inference_config=AsyncInferenceConfig()
)

Cet appel peut prendre environ 10 minutes. Pendant ce temps, le point de terminaison est lancé, le conteneur ainsi que les artefacts de modèle sont téléchargés sur le point de terminaison, la configuration du modèle est chargée à partir de SageMaker JumpStart, puis le point de terminaison asynchrone est exposé via un point de terminaison DNS. Pour nous assurer que notre point de terminaison peut être réduit à zéro, nous devons configurer la mise à l'échelle automatique sur le point de terminaison asynchrone à l'aide d'Application Auto Scaling. Vous devez d'abord enregistrer votre variante de point de terminaison auprès d'Application Auto Scaling, définir une stratégie de mise à l'échelle, puis appliquer la stratégie de mise à l'échelle. Dans cette configuration, nous utilisons une métrique personnalisée utilisant CustomizedMetricSpecification, appelée ApproximateBacklogSizePerInstance, comme indiqué dans le code suivant. Pour une liste détaillée de Amazon Cloud Watch métriques disponibles avec votre point de terminaison d'inférence asynchrone, reportez-vous à Surveillance avec CloudWatch.

import boto3 client = boto3.client("application-autoscaling")
resource_id = "endpoint/" + my_model.endpoint_name + "/variant/" + "AllTraffic" # Configure Autoscaling on asynchronous endpoint down to zero instances
response = client.register_scalable_target( ServiceNamespace="sagemaker", ResourceId=resource_id, ScalableDimension="sagemaker:variant:DesiredInstanceCount", MinCapacity=0, # Miminum number of instances we want to scale down to - scale down to 0 to stop incurring in costs MaxCapacity=1, # Maximum number of instances we want to scale up to - scale up to 1 max is good enough for dev
) response = client.put_scaling_policy( PolicyName="Invocations-ScalingPolicy", ServiceNamespace="sagemaker", # The namespace of the AWS service that provides the resource. ResourceId=resource_id, # Endpoint name ScalableDimension="sagemaker:variant:DesiredInstanceCount", # SageMaker supports only Instance Count PolicyType="TargetTrackingScaling", # 'StepScaling'|'TargetTrackingScaling' TargetTrackingScalingPolicyConfiguration={ "TargetValue": 5.0, # The target value for the metric. - here the metric is - SageMakerVariantInvocationsPerInstance "CustomizedMetricSpecification": { "MetricName": "ApproximateBacklogSizePerInstance", "Namespace": "AWS/SageMaker", "Dimensions": [{"Name": "EndpointName", "Value": my_model.endpoint_name}], "Statistic": "Average", }, "ScaleInCooldown": 600, # The amount of time, in seconds, after a scale in activity completes before another scale in activity can start. "ScaleOutCooldown": 300, # ScaleOutCooldown - The amount of time, in seconds, after a scale out activity completes before another scale out activity can start. # 'DisableScaleIn': True|False - indicates whether scale in by the target tracking policy is disabled. # If the value is true, scale in is disabled and the target tracking policy won't remove capacity from the scalable resource. },
)

Vous pouvez vérifier que cette stratégie a été définie avec succès en accédant à la console SageMaker et en choisissant Endpoints sous Inférence dans le volet de navigation et recherchez le point de terminaison que nous venons de déployer.

Appeler le point de terminaison asynchrone

Pour appeler le point de terminaison, vous devez placer la charge utile de la requête dans Service de stockage simple Amazon (Amazon S3) et fournissez un pointeur vers cette charge utile dans le cadre du InvokeEndpointAsync demande. Lors de l'appel, SageMaker met la demande en file d'attente pour traitement et renvoie un identifiant et un emplacement de sortie en réponse. Lors du traitement, SageMaker place le résultat dans l'emplacement Amazon S3. Vous pouvez éventuellement choisir de recevoir des notifications de réussite ou d'erreur avec Service de notification simple d'Amazon (Amazon SNS).

Kit de développement logiciel (SDK) SageMaker Python

Une fois le déploiement terminé, il renverra un AsyncPredictor objet. Pour effectuer une inférence asynchrone, vous devez télécharger des données sur Amazon S3 et utiliser l'outil predict_async() méthode avec l’URI S3 comme entrée. Il renverra un AsyncInferenceResponse objet, et vous pouvez vérifier le résultat en utilisant le get_response() méthode.

Alternativement, si vous souhaitez vérifier périodiquement un résultat et le renvoyer lors de la génération, utilisez le predict() méthode. Nous utilisons cette deuxième méthode dans le code suivant :

import time # Invoking the asynchronous endpoint with the SageMaker Python SDK
def query_endpoint(payload): """Query endpoint and print the response""" response = predictor.predict_async( data=payload, input_path="s3://{}/{}".format(bucket, prefix), ) while True: try: response = response.get_result() break except: print("Inference is not ready ...") time.sleep(5) print(f"33[1m Input:33[0m {payload['inputs']}") print(f"33[1m Output:33[0m {response[0]['generated_text']}") query_endpoint(payload)

Boto3

Explorons maintenant le invoke_endpoint_async méthode de Boto3 sagemaker-runtime client. Il permet aux développeurs d'appeler de manière asynchrone un point de terminaison SageMaker, fournissant ainsi un jeton pour le suivi de la progression et la récupération ultérieure de la réponse. Boto3 n'offre pas de moyen d'attendre que l'inférence asynchrone soit terminée comme le SDK SageMaker Python get_result() opération. Par conséquent, nous profitons du fait que Boto3 stockera la sortie d'inférence dans Amazon S3 dans le response["OutputLocation"]. Nous pouvons utiliser la fonction suivante pour attendre que le fichier d'inférence soit écrit sur Amazon S3 :

import json
import time
import boto3
from botocore.exceptions import ClientError s3_client = boto3.client("s3") # Wait until the prediction is generated
def wait_inference_file(bucket, prefix): while True: try: response = s3_client.get_object(Bucket=bucket, Key=prefix) break except ClientError as ex: if ex.response['Error']['Code'] == 'NoSuchKey': print("Waiting for file to be generated...") time.sleep(5) next else: raise except Exception as e: print(e.__dict__) raise return response

Avec cette fonction, nous pouvons désormais interroger le point final :

# Invoking the asynchronous endpoint with the Boto3 SDK
import boto3 sagemaker_client = boto3.client("sagemaker-runtime") # Query the endpoint function
def query_endpoint_boto3(payload): """Query endpoint and print the response""" response = sagemaker_client.invoke_endpoint_async( EndpointName=my_model.endpoint_name, InputLocation="s3://{}/{}".format(bucket, prefix), ContentType="application/json", Accept="application/json" ) output_url = response["OutputLocation"] output_prefix = "/".join(output_url.split("/")[3:]) # Read the bytes of the file from S3 in output_url with Boto3 output = wait_inference_file(bucket, output_prefix) output = json.loads(output['Body'].read())[0]['generated_text'] # Emit output print(f"33[1m Input:33[0m {payload['inputs']}") print(f"33[1m Output:33[0m {output}") query_endpoint_boto3(payload)

LangChaîne

LangChain est un framework open source lancé en octobre 2022 par Harrison Chase. Il simplifie le développement d'applications utilisant de grands modèles de langage (LLM) en fournissant des intégrations avec divers systèmes et sources de données. LangChain permet l'analyse de documents, la synthèse, la création de chatbot, l'analyse de code, etc. Il a gagné en popularité, grâce aux contributions de centaines de développeurs et à un financement important de sociétés de capital-risque. LangChain permet la connexion des LLM avec des sources externes, permettant de créer des applications dynamiques et sensibles aux données. Il propose des bibliothèques, des API et de la documentation pour rationaliser le processus de développement.

LangChain fournit des bibliothèques et des exemples pour utiliser les points de terminaison SageMaker avec son framework, facilitant ainsi l'utilisation des modèles ML hébergés sur SageMaker en tant que « cerveau » de la chaîne. Pour en savoir plus sur la façon dont LangChain s'intègre à SageMaker, reportez-vous au Point de terminaison SageMaker dans la documentation LangChain.

L’une des limites de l’implémentation actuelle de LangChain est qu’elle ne prend pas en charge de manière native les points de terminaison asynchrones. Pour utiliser un point de terminaison asynchrone pour LangChain, nous devons définir une nouvelle classe, SagemakerAsyncEndpoint, qui prolonge la SagemakerEndpoint classe déjà disponible dans LangChain. De plus, nous fournissons les informations suivantes :

• Le compartiment S3 et le préfixe où l'inférence asynchrone stockera les entrées (et les sorties)
• Un nombre maximum de secondes à attendre avant l'expiration du délai
• An updated _call() fonction pour interroger le point de terminaison avec invoke_endpoint_async() au lieu de invoke_endpoint()
• Un moyen de réveiller le point de terminaison asynchrone s'il est en démarrage à froid (réduit à zéro)

Pour examiner le nouveau créé SagemakerAsyncEndpoint, Vous pouvez consulter la sagemaker_async_endpoint.py filet disponible sur GitHub.

from typing import Dict
from langchain import PromptTemplate
from langchain.llms.sagemaker_endpoint import LLMContentHandler
from langchain.chains import LLMChain
from sagemaker_async_endpoint import SagemakerAsyncEndpoint class ContentHandler(LLMContentHandler): content_type:str = "application/json" accepts:str = "application/json" len_prompt:int = 0 def transform_input(self, prompt: str, model_kwargs: Dict) -> bytes: self.len_prompt = len(prompt) input_str = json.dumps({"inputs": prompt, "parameters": {"max_new_tokens": 100, "do_sample": False, "repetition_penalty": 1.1}}) return input_str.encode('utf-8') def transform_output(self, output: bytes) -> str: response_json = output.read() res = json.loads(response_json) ans = res[0]['generated_text'] return ans chain = LLMChain( llm=SagemakerAsyncEndpoint( input_bucket=bucket, input_prefix=prefix, endpoint_name=my_model.endpoint_name, region_name=sagemaker.Session().boto_region_name, content_handler=ContentHandler(), ), prompt=PromptTemplate( input_variables=["query"], template="{query}", ),
) print(chain.run(payload['inputs']))

Nettoyer

Lorsque vous avez terminé de tester la génération d'inférences à partir du point de terminaison, n'oubliez pas de supprimer le point de terminaison pour éviter d'encourir des frais supplémentaires :

predictor.delete_endpoint()

Conclusion

Lors du déploiement de grands modèles de base comme TII Falcon, l'optimisation des coûts est cruciale. Ces modèles nécessitent un matériel puissant et une capacité de mémoire importante, ce qui entraîne des coûts d'infrastructure élevés. L'inférence asynchrone SageMaker, une option de déploiement qui traite les demandes de manière asynchrone, réduit les dépenses en ramenant le nombre d'instances à zéro lorsqu'il n'y a aucune demande en attente. Dans cet article, nous avons montré comment déployer de grands modèles de fondation SageMaker JumpStart sur des points de terminaison asynchrones SageMaker. Nous avons fourni des exemples de code utilisant le SDK SageMaker Python, Boto3 et LangChain pour illustrer différentes méthodes d'appel de points de terminaison asynchrones et de récupération des résultats. Ces techniques permettent aux développeurs et aux chercheurs d'optimiser les coûts tout en utilisant les capacités des modèles de base pour les systèmes avancés de compréhension du langage.

Pour en savoir plus sur l'inférence asynchrone et SageMaker JumpStart, consultez les articles suivants :

A propos de l'auteure

David Gallitelli est un architecte de solutions spécialisé pour l'IA/ML dans la région EMEA. Il est basé à Bruxelles et travaille en étroite collaboration avec des clients dans tout le Benelux. Il est développeur depuis qu'il est très jeune et a commencé à coder à l'âge de 7 ans. Il a commencé à apprendre l'IA/ML à l'université et en est tombé amoureux depuis.

• Contenu propulsé par le référencement et distribution de relations publiques. Soyez amplifié aujourd'hui.
• PlatoData.Network Ai générative verticale. Autonomisez-vous. Accéder ici.
• PlatoAiStream. Intelligence Web3. Connaissance Amplifiée. Accéder ici.
• PlatonESG. Automobile / VE, Carbone, Technologie propre, Énergie, Environnement, Solaire, La gestion des déchets. Accéder ici.
• PlatoHealth. Veille biotechnologique et essais cliniques. Accéder ici.
• GraphiquePrime. Élevez votre jeu de trading avec ChartPrime. Accéder ici.
• Décalages de bloc. Modernisation de la propriété des compensations environnementales. Accéder ici.
• La source: https://aws.amazon.com/blogs/machine-learning/optimize-deployment-cost-of-amazon-sagemaker-jumpstart-foundation-models-with-amazon-sagemaker-asynchronous-endpoints/