Invoquez des modèles pour une inférence en temps réel

Après avoir utilisé Amazon SageMaker AI pour déployer un modèle sur un point de terminaison, vous pouvez interagir avec le modèle en lui envoyant des demandes d'inférence. Pour envoyer une demande d'inférence à un modèle, vous appelez le point de terminaison qui l'héberge. Vous pouvez appeler vos points de terminaison à l'aide d'Amazon SageMaker Studio, du AWS SDKs, ou du AWS CLI.

Invoquez votre modèle à l'aide d'Amazon SageMaker Studio

Après avoir déployé votre modèle sur un point de terminaison, vous pouvez consulter le point de terminaison via Amazon SageMaker Studio et tester votre point de terminaison en envoyant des demandes d'inférence uniques.

Le haut de la carte affiche le type de demande qui a été envoyée au point de terminaison (seul JSON est accepté). La carte affiche les champs suivants :

Invoquez votre modèle à l'aide du AWS SDK for Python (Boto3)

Si vous souhaitez invoquer un point de terminaison modèle dans le code de votre application, vous pouvez utiliser l'un des AWS SDKs, notamment le AWS SDK for Python (Boto3). Pour appeler votre point de terminaison avec ce SDK, vous devez utiliser l'une des méthodes Python suivantes :

Avant de pouvoir utiliser ces méthodes dans le code de votre application, vous devez initialiser un client SageMaker AI Runtime et spécifier le nom de votre point de terminaison. L'exemple suivant configure le client et le point de terminaison pour les autres exemples suivants :

import boto3

sagemaker_runtime = boto3.client(
    "sagemaker-runtime", region_name='aws_region')

endpoint_name='endpoint-name'

Invocation pour obtenir une réponse d'inférence

L'exemple suivant utilise la méthode invoke_endpoint pour invoquer un point de terminaison avec le kit AWS SDK for Python (Boto3) :

# Gets inference from the model hosted at the specified endpoint:
response = sagemaker_runtime.invoke_endpoint(
    EndpointName=endpoint_name, 
    Body=bytes('{"features": ["This is great!"]}', 'utf-8')
    )

# Decodes and prints the response body:
print(response['Body'].read().decode('utf-8'))

Cet exemple fournit des données d'entrée dans le Body champ pour que l' SageMaker IA les transmette au modèle. Ces données doivent être dans le même format que celui utilisé pour l'entraînement. L'exemple attribue la réponse à la response variable.

La variable response permet d'accéder au statut HTTP, au nom du modèle déployé et à d'autres champs. L'extrait suivant imprime le code d'état HTTP :

print(response["HTTPStatusCode"])

Invoquer pour diffuser une réponse d'inférence

Si vous avez déployé un modèle qui prend en charge le streaming d'inférence, vous pouvez invoquer le modèle pour recevoir sa charge utile d'inférence sous forme de flux de pièces. Le modèle fournit ces pièces progressivement au fur et à mesure qu'il les génère. Lorsqu'une application reçoit un flux d'inférence, elle n'a pas besoin d'attendre que le modèle génère la totalité de la charge utile de réponse. Au lieu de cela, l'application reçoit immédiatement certaines parties de la réponse dès qu'elles sont disponibles.

En consommant un flux d'inférence dans votre application, vous pouvez créer des interactions dans lesquelles vos utilisateurs perçoivent l'inférence comme étant rapide, car ils obtiennent immédiatement la première partie. Vous pouvez mettre en œuvre le streaming pour prendre en charge des expériences interactives rapides, telles que les chatbots, les assistants virtuels et les générateurs de musique. Par exemple, vous pouvez créer un chatbot qui affiche progressivement le texte généré par un grand modèle de langage (LLM).

Pour obtenir un flux d'inférence, vous pouvez utiliser la invoke_endpoint_with_response_stream méthode. Dans le corps de la réponse, le kit SDK fournit un objet EventStream, qui donne l'inférence sous la forme d'une série d'objets PayloadPart.

{'PayloadPart': {'Bytes': b'{"outputs": [" a"]}\n'}}
{'PayloadPart': {'Bytes': b'{"outputs": [" challenging"]}\n'}}
{'PayloadPart': {'Bytes': b'{"outputs": [" problem"]}\n'}}
. . .

{'PayloadPart': {'Bytes': b'{"outputs": '}}
{'PayloadPart': {'Bytes': b'[" problem"]}\n'}}

{"outputs": [" a"]}
{"outputs": [" challenging"]}
{"outputs": [" problem"]}
. . .

L'exemple de classe Python suivant, SmrInferenceStream, montre comment traiter un flux d'inférence qui envoie des données texte au format JSON :

import io
import json

# Example class that processes an inference stream:
class SmrInferenceStream:
    
    def __init__(self, sagemaker_runtime, endpoint_name):
        self.sagemaker_runtime = sagemaker_runtime
        self.endpoint_name = endpoint_name
        # A buffered I/O stream to combine the payload parts:
        self.buff = io.BytesIO() 
        self.read_pos = 0
        
    def stream_inference(self, request_body):
        # Gets a streaming inference response 
        # from the specified model endpoint:
        response = self.sagemaker_runtime\
            .invoke_endpoint_with_response_stream(
                EndpointName=self.endpoint_name, 
                Body=json.dumps(request_body), 
                ContentType="application/json"
        )
        # Gets the EventStream object returned by the SDK:
        event_stream = response['Body']
        for event in event_stream:
            # Passes the contents of each payload part
            # to be concatenated:
            self._write(event['PayloadPart']['Bytes'])
            # Iterates over lines to parse whole JSON objects:
            for line in self._readlines():
                resp = json.loads(line)
                part = resp.get("outputs")[0]
                # Returns parts incrementally:
                yield part
    
    # Writes to the buffer to concatenate the contents of the parts:
    def _write(self, content):
        self.buff.seek(0, io.SEEK_END)
        self.buff.write(content)

    # The JSON objects in buffer end with '\n'.
    # This method reads lines to yield a series of JSON objects:
    def _readlines(self):
        self.buff.seek(self.read_pos)
        for line in self.buff.readlines():
            self.read_pos += len(line)
            yield line[:-1]

Cet exemple traite le flux d'inférence en procédant comme suit :

L'exemple suivant crée et utilise un objet SmrInferenceStream :

request_body = {"inputs": ["Large model inference is"],
                "parameters": {"max_new_tokens": 100,
                               "enable_sampling": "true"}}
smr_inference_stream = SmrInferenceStream(
    sagemaker_runtime, endpoint_name)
stream = smr_inference_stream.stream_inference(request_body)
for part in stream:
    print(part, end='')

Cet exemple transmet un corps de demande à la méthode stream_inference. Il itère la réponse pour imprimer chaque élément renvoyé par le flux d'inférence.

L'exemple suppose que le modèle au point de terminaison spécifié est un LLM qui génère du texte. Le résultat de cet exemple est un corps de texte généré qui s'imprime de manière incrémentielle :

a challenging problem in machine learning. The goal is to . . .

Invoquez votre modèle à l'aide du AWS CLI

Vous pouvez appeler le point de terminaison de votre modèle en exécutant des commandes avec le AWS Command Line Interface (AWS CLI). L' AWS CLI prend en charge les demandes d'inférence standard avec la commande invoke-endpoint et prend en charge les demandes d'inférence asynchrones avec la commande invoke-endpoint-async.

L'exemple suivant utilise la commande invoke-endpoint pour envoyer une demande d'inférence à un point de terminaison du modèle :

aws sagemaker-runtime invoke-endpoint \
    --endpoint-name endpoint_name \
    --body fileb://$file_name \
    output_file.txt

Pour le --endpoint-name paramètre, indiquez le nom du point de terminaison que vous avez spécifié lors de sa création. Pour le --body paramètre, fournissez les données d'entrée que l' SageMaker IA doit transmettre au modèle. Les données doivent être dans le même format que celui utilisé pour l'entraînement. Cet exemple montre comment envoyer des données binaires à votre point de terminaison.

Pour plus d'informations sur les circonstances dans lesquelles utiliser le file:// over fileb:// lors du transfert du contenu d'un fichier à un paramètre du AWS CLI, consultez la section Meilleures pratiques relatives aux paramètres de fichiers locaux.

Pour plus d'informations et pour voir les paramètres supplémentaires que vous pouvez transmettre, consultez invoke-endpoint dans la Référence des commandes de l'AWS CLI .

Si la commande invoke-endpoint réussit, elle renvoie une réponse telle que la suivante :

{
    "ContentType": "<content_type>; charset=utf-8",
    "InvokedProductionVariant": "<Variant>"
}

Si la commande échoue, vérifiez si le format de la charge utile d'entrée est correct.

Affichez la sortie de l'appel en vérifiant le fichier de sortie du fichier (output_file.txt dans cet exemple).

more output_file.txt