Richiama modelli per l'inferenza in tempo reale

Dopo aver distribuito il modello utilizzando i servizi di SageMaker hosting, puoi testarlo su quell'endpoint inviandogli i dati di test. Puoi testare i tuoi endpoint utilizzando Amazon SageMaker Studio, gli AWS SDK o il. AWS CLI

Richiama il tuo endpoint utilizzando Amazon Studio SageMaker

Dopo aver distribuito il modello su un endpoint, puoi visualizzare l'endpoint tramite Amazon SageMaker Studio e testarlo inviando singole richieste di inferenza.

La parte superiore della scheda mostra il tipo di richiesta che è stata inviata all'endpoint (è accettato solo JSON). La scheda mostra i seguenti campi:

Richiama il tuo endpoint utilizzando il AWS SDK for Python (Boto3)

Dopo aver distribuito il modello su un endpoint, puoi controllarlo utilizzando uno degli AWS SDK, incluso come. AWS SDK for Python (Boto3) Per testare l'endpoint con questo SDK, utilizza uno dei seguenti metodi:

Prima di poter utilizzare questi metodi nel codice client, è necessario creare un client SageMaker Runtime e specificare il nome dell'endpoint. L'esempio seguente configura il client e l'endpoint per il resto degli esempi seguenti:

import boto3

# Create a low-level client representing Amazon SageMaker Runtime
sagemaker_runtime = boto3.client(
    "sagemaker-runtime", region_name='aws_region')

# The endpoint name must be unique within 
# an AWS Region in your AWS account. 
endpoint_name='endpoint-name'

Richiamare per ottenere una risposta di inferenza

L'esempio seguente utilizza il metodo invoke_endpoint per richiamare un endpoint con 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'))

Questo esempio fornisce dati di input nel Body campo SageMaker da passare al modello. Questi dati devono essere nello stesso formato utilizzato per l'addestramento. L'esempio memorizza la risposta nella variabile response.

La variabile response fornisce l'accesso allo stato HTTP, al nome del modello distribuito e ad altri campi. Il seguente snippet stampa HTTPStatusCode:

print(response["HTTPStatusCode"])

Richiamare per trasmettere una risposta di inferenza

Se hai distribuito un modello che supporta lo streaming di inferenza, puoi richiamare il modello per ricevere il payload di inferenza sotto forma di flusso di parti. Il modello fornisce queste parti in modo incrementale man mano che il modello le genera. Quando un'applicazione riceve un flusso di inferenza, non deve attendere che il modello generi l'intero payload di risposta. Invece, l'applicazione inizia immediatamente a ricevere parti della risposta non appena diventano disponibili.

Utilizzando un flusso di inferenza nell'applicazione, è possibile creare interazioni in cui gli utenti percepiscono l'inferenza come rapida perché ottengono immediatamente la prima parte. Ad esempio, è possibile creare un chatbot che mostri in modo incrementale il testo generato da un modello di linguaggio di grandi dimensioni (LLM).

Per ottenere un flusso di inference, puoi utilizzare il metodo invoke_endpoint_with_response_stream nell'SDK per Python (Boto3). Nel corpo della risposta, l'SDK fornisce un oggetto EventStream, che fornisce l'inferenza sotto forma di una serie di oggetti 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"]}
. . .

Il seguente esempio di classe Python, SmrInferenceStream, dimostra come è possibile elaborare un flusso di inferenza che invia dati di testo in formato 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]

Questo esempio elabora il flusso di inferenza effettuando le seguenti operazioni:

L'esempio seguente crea e utilizza un oggetto 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='')

Questo esempio passa un corpo della richiesta al metodo stream_inference. Esegue un'iterazione sulla risposta per stampare ogni pezzo restituito dal flusso di inferenza.

L'esempio presuppone che il modello nell'endpoint specificato sia un LLM che genera testo. L'output di questo esempio è un corpo di testo generato che viene stampato in modo incrementale:

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

Invoca il tuo endpoint utilizzando il AWS CLI

Puoi testare il tuo endpoint eseguendo comandi con AWS Command Line Interface ()AWS CLI. AWS CLI supporta richieste di inferenza standard con il comando invoke-endpoint e supporta richieste di inferenza asincrone con il comando invoke-endpoint-async.

L'esempio seguente utilizza il comando invoke-endpoint per inviare una richiesta di inferenza a un endpoint del modello:

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

Per il parametro --endpoint-name, fornisci il nome che hai specificato per EndpointName quando hai creato l'endpoint con CreateEndpoint. Per il --body parametro, fornite i dati di input SageMaker da passare al modello. I dati devono essere nello stesso formato utilizzato per l'addestramento. Questo esempio mostra come inviare dati binari all'endpoint.

Per ulteriori informazioni su quando utilizzare file:// over fileb:// quando si passa il contenuto di un file a un parametro di AWS CLI, consultate Best Practices for Local File Parameters.

Per ulteriori informazioni e per visualizzare i parametri aggiuntivi che è possibile passare, consulta invoke-endpoint nel Riferimento al comando AWS CLI .

Se il comando invoke-endpoint ha esito positivo, restituisce una risposta come la seguente:

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

Se il comando non ha esito positivo, controlla se il payload di input è nel formato corretto.

Visualizza l'output della chiamata controllando il file di output del file (output_file.txt in questo esempio).

more output_file.txt