Invoque modelos para realizar inferencias en tiempo real

Después de implementar el modelo mediante los servicios de SageMaker alojamiento, puede probarlo en ese punto final enviándole datos de prueba. Puede probar sus puntos de enlace con Amazon SageMaker Studio, los AWS SDK o el. AWS CLI

Invoque su terminal con Amazon Studio SageMaker

Después de implementar el modelo en un punto final, puede ver el punto final a través de Amazon SageMaker Studio y probarlo enviando solicitudes de inferencia únicas.

La parte superior de la tarjeta muestra el tipo de solicitud que se envió al punto de conexión (solo se acepta JSON). La tarjeta muestra los campos siguientes:

Invocar un punto de conexión mediante AWS SDK for Python (Boto3)

Después de implementar el modelo en un punto final, puede comprobarlo mediante uno de los AWS SDK, como el. AWS SDK for Python (Boto3) Para probar el punto de conexión con este SDK, utilice uno de los siguientes métodos:

Antes de poder utilizar estos métodos en el código de su cliente, debe crear un cliente SageMaker Runtime y especificar el nombre de su punto final. En el siguiente ejemplo, se configuran el cliente y el punto de conexión para el resto de los ejemplos:

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'

Invocar para obtener una respuesta de inferencia

En el siguiente ejemplo se utiliza el método invoke_endpoint para invocar un punto de conexión 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'))

En este ejemplo, se proporcionan datos de entrada en el Body campo SageMaker para pasarlos al modelo. Estos datos deben tener el mismo formato que se utilizó para el entrenamiento. El ejemplo almacena la respuesta en la variable response.

La variable response proporciona acceso al estado HTTP, al nombre del modelo implementado y a otros campos. El siguiente fragmento de código imprime HTTPStatusCode:

print(response["HTTPStatusCode"])

Invocar para transmitir una respuesta de inferencia

Si implementó un modelo que admite streaming de inferencias, puede invocar el modelo para recibir su carga útil de inferencia como un flujo de partes. El modelo entrega estas partes de forma incremental a medida que las genera. Cuando una aplicación recibe un flujo de inferencia, no necesita esperar a que el modelo genere toda la carga útil de respuesta. Por el contrario, la aplicación comienza a recibir inmediatamente partes de la respuesta a medida que están disponibles.

Al consumir un flujo de inferencia en la aplicación, puede crear interacciones en las que los usuarios perciban que la inferencia es rápida, ya que obtienen la primera parte de forma inmediata. Por ejemplo, puede crear un chatbot que muestre de forma incremental el texto generado por un modelo de lenguaje grande (LLM).

Para obtener un flujo de inferencia, puede emplear el método invoke_endpoint_with_response_stream del SDK para Python (Boto3). En el cuerpo de la respuesta, el SDK proporciona un objeto EventStream, que proporciona la inferencia en forma de una serie de objetos 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"]}
. . .

El siguiente ejemplo de clase de Python, SmrInferenceStream, demuestra cómo se puede procesar un flujo de inferencia que envía datos de texto en 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]

En este ejemplo se procesa el flujo de inferencia de la siguiente manera:

El siguiente ejemplo crea y utiliza un objeto 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='')

Este ejemplo pasa un cuerpo de solicitud al método stream_inference. Itera la respuesta para imprimir cada parte que devuelve el flujo de inferencia.

En el ejemplo se da por sentado que el modelo del punto de conexión especificado es un LLM que genera texto. El resultado de este ejemplo es un cuerpo de texto generado que se imprime de forma incremental:

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

Invoque su punto final mediante el AWS CLI

Puede probar su punto final ejecutando comandos con la tecla AWS Command Line Interface (AWS CLI). AWS CLI admite solicitudes de inferencia estándar con el comando invoke-endpoint y admite solicitudes de inferencia asincrónicas con el comando invoke-endpoint-async.

En el siguiente ejemplo se utiliza el comando invoke-endpoint para enviar una solicitud de inferencia a un punto de conexión del modelo:

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

Para el parámetro --endpoint-name, proporcione el nombre que especificó para EndpointName cuando creó el punto de conexión con CreateEndpoint. Para el --body parámetro, proporcione los datos de entrada SageMaker para pasarlos al modelo. Los datos deben tener el mismo formato que se utilizó para el entrenamiento. En este ejemplo se muestra cómo enviar datos binarios a su punto de conexión.

Para obtener más información sobre cuándo usar file:// Over fileb:// al pasar el contenido de un archivo a un parámetro del AWS CLI, consulte Prácticas recomendadas para los parámetros de archivos locales.

Para obtener más información y ver parámetros adicionales que puede pasar, consulte invoke-endpoint en la Referencia de comandos de AWS CLI .

Si el comando invoke-endpoint se ejecuta correctamente, devuelve una respuesta similar a la siguiente:

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

Si el comando no se ejecuta correctamente, compruebe si la carga útil de entrada tiene el formato correcto.

Vea el resultado de la invocación comprobando el archivo de salida del archivo (output_file.txt en este ejemplo).

more output_file.txt