Invocare modelli per l’inferenza in tempo reale

Dopo aver utilizzato Amazon SageMaker AI per implementare un modello in un endpoint, è possibile interagire con il modello inviandogli richieste di inferenza. Per inviare una richiesta di inferenza a un modello, invoca l’endpoint che lo ospita. È possibile invocare gli endpoint utilizzando Amazon SageMaker Studio, gli AWS SDK o l’AWS CLI.

Invocare un modello mediante Amazon SageMaker Studio

Dopo aver implementato il modello in un endpoint, è possibile visualizzare l’endpoint utilizzando Amazon SageMaker Studio e testarlo inviando richieste di inferenza singole.

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

Invocare un modello mediante AWS SDK per Python (Boto3)

Per invocare un endpoint del modello nel codice dell’applicazione, è possibile utilizzare uno degli AWS SDK, incluso AWS SDK per Python (Boto3). Per invocare l’endpoint con questo SDK, utilizza uno dei seguenti metodi Python:

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

import boto3

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

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 per 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 campo Body affinché SageMaker AI li passi al modello. Questi dati devono essere nello stesso formato utilizzato per l'addestramento. L’esempio assegna la risposta alla variabile response.

La variabile response fornisce l'accesso allo stato HTTP, al nome del modello distribuito e ad altri campi. Il seguente frammento di codice mostra il codice di stato HTTP:

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 riceve immediatamente 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. Puoi implementare lo streaming per supportare esperienze interattive veloci, come chatbot, assistenti virtuali e generatori di musica. 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 inferenza, è possibile utilizzare il metodo invoke_endpoint_with_response_stream. 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 . . .

Invocare un modello mediante AWS CLI

È possibile invocare l’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 specificato quando hai creato l’endpoint. Per il parametro --body fornisci i dati di input che SageMaker AI deve 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:// su fileb:// quando si passa il contenuto di un file a un parametro di AWS CLI, consulta Best practice per i parametri dei file locali.

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