Invoque modelos para inferência em tempo real

Depois de implantar seu modelo usando serviços de SageMaker hospedagem, você pode testar seu modelo nesse endpoint enviando dados de teste. Você pode testar seus endpoints usando o Amazon SageMaker Studio, os AWS SDKs ou o. AWS CLI

Invoque seu endpoint usando o Amazon Studio SageMaker

Depois de implantar seu modelo em um endpoint, você pode visualizar o endpoint por meio do Amazon SageMaker Studio e testar seu endpoint enviando solicitações de inferência únicas.

nota

SageMaker só oferece suporte a testes de endpoint no Studio para endpoints em tempo real.

Para enviar uma solicitação de inferência de teste para seu endpoint

1. Inicie o Amazon SageMaker Studio.

2. No painel de navegação à esquerda, escolha Implantações.

3. No menu suspenso, escolha Endpoints.

4. Encontre seu endpoint pelo nome e escolha o nome na tabela. Os nomes dos endpoints listados no painel Endpoints são definidos quando você implanta um modelo. O espaço de trabalho do Studio abre a página Endpoint em uma nova guia.

5. Escolha a guia Testar inferência.

6. Para Opções de teste, selecione uma das seguintes opções:

   1. Selecione Testar a solicitação de amostra para enviar imediatamente uma solicitação ao seu endpoint. Use o editor JSON para fornecer dados de amostra no formato JSON e escolha Enviar solicitação para enviar a solicitação ao seu endpoint. Depois de enviar sua solicitação, o Studio mostra a saída da inferência em um cartão à direita do editor JSON.

   2. Selecione Usar código de exemplo do Python SDK para visualizar o código para enviar uma solicitação ao endpoint. Em seguida, copie o exemplo de código da seção Exemplo de solicitação de inferência e execute o código em seu ambiente de teste.

A parte superior do cartão mostra o tipo de solicitação que foi enviada ao endpoint (somente JSON é aceito). O cartão mostra os seguintes campos:

• Status — exibe um dos seguintes tipos de status:

  • Success – a solicitação foi bem-sucedida.

  • Failed – A solicitação falhou. Uma resposta aparece em Motivo da falha.

  • Pending – Enquanto a solicitação de inferência está pendente, o status mostra um ícone circular giratório.

• Duração da execução – Quanto tempo demorou a invocação (hora de término menos a hora de início) em milissegundos.

• Tempo da solicitação – Quantos minutos se passaram desde que a solicitação foi enviada.

• Tempo do resultado – Quantos minutos se passaram desde que o resultado foi devolvido.

Invoque seu endpoint usando o AWS SDK for Python (Boto3)

Depois de implantar seu modelo em um endpoint, você pode verificar seu endpoint usando um dos AWS SDKs, inclusive como o. AWS SDK for Python (Boto3) Para testar seu endpoint com esse SDK, use um dos seguintes métodos:

• invoke_endpoint – Envia uma solicitação de inferência para um endpoint do modelo e retorna a resposta que o modelo gera. Esse método retorna a carga de inferência como uma resposta após o modelo terminar de gerá-la. Para mais informações, consulte a invoke_endpoint no AWS SDK para Referência API Python (Boto3).

• invoke_endpoint_with_response_stream – Envia uma solicitação de inferência para um endpoint do modelo e transmite a resposta em partes incrementais enquanto o modelo gera a inferência. Com esse método, seu aplicativo cliente começa imediatamente a receber partes da resposta à medida que as peças se tornam disponíveis. Seu cliente não precisa esperar que o modelo gere toda a carga útil de resposta. Você pode implementar o streaming para oferecer suporte a experiências interativas rápidas, como chatbots, assistentes virtuais e geradores de música.

  Use esse método somente para invocar modelos que suportem streaming de inferência.

  Quando um contêiner processa uma solicitação de inferência de streaming, ele retorna a inferência do modelo como uma série de partes incrementalmente à medida que o modelo as gera. Os aplicativos cliente começam a receber respostas imediatamente conforme elas ficam disponíveis. Eles não precisam esperar que o modelo gere a resposta completa. Você pode implementar o streaming para oferecer suporte a experiências interativas rápidas, como chatbots, assistentes virtuais e geradores de música.

Antes de usar esses métodos no código do cliente, você deve criar um cliente SageMaker Runtime e especificar o nome do seu endpoint. O exemplo a seguir configura o cliente e o endpoint para os demais exemplos a seguir:

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'

Invoque para obter uma resposta de inferência

O exemplo a seguir usa o método invoke_endpoint para invocar um endpoint com o 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'))

Este exemplo fornece dados de entrada no Body campo SageMaker para serem passados ao modelo. Esses dados devem estar no mesmo formato usado para treinamento. O exemplo armazena a resposta na variável response.

A variável response fornece acesso ao status HTTP, ao nome do modelo implantado e a outros campos. O trecho a seguir imprime o HTTPStatusCode:

print(response["HTTPStatusCode"])

Invoque para obter uma resposta de fluxo

Se você implantou um modelo que suporta streaming de inferência, você pode invocar o modelo para receber sua carga de inferência como um fluxo de partes. O modelo entrega essas peças de forma incremental à medida que o modelo as gera. Quando um aplicativo recebe um fluxo de inferência, o aplicativo não precisa esperar que o modelo gere toda a carga útil da resposta. Em vez disso, o aplicativo cliente começa imediatamente a receber partes da resposta à medida que se tornam disponíveis.

Ao consumir um fluxo de inferência em seu aplicativo, você pode criar interações em que seus usuários percebam que a inferência é rápida porque obtêm a primeira parte imediatamente. Por exemplo, você pode criar um chatbot que mostre incrementalmente o texto gerado por um modelo de linguagem grande (LLM).

Para obter um stream de inferência, use o método invoke_endpoint_with_response_stream no SDK for Python (Boto3). No corpo da resposta, o SDK fornece um objeto EventStream, que fornece a inferência como uma série de objetos PayloadPart.

exemplo Fluxo de inferência

O exemplo a seguir éum fluxo de objetos PayloadPart:

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

Em cada parte da carga útil, o campo Bytes fornece uma parte da resposta de inferência do modelo. Essa parte pode ser qualquer tipo de conteúdo gerado por um modelo, como texto, imagem ou dados de áudio. Neste exemplo, as partes são objetos JSON que contêm texto gerado de um LLM.

Normalmente, a parte da carga útil contém um bloco discreto de dados do modelo. Neste exemplo, os blocos discretos são objetos JSON inteiros. Ocasionalmente, a resposta de streaming divide as partes em várias partes da carga útil ou combina várias partes em uma parte da carga útil. O exemplo a seguir mostra um bloco de dados no formato JSON dividido em duas partes da carga útil:

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

Ao escrever um código de aplicativo que processa um fluxo de inferência, inclua uma lógica que manipule essas divisões e combinações ocasionais de dados. Como uma estratégia, você pode escrever um código que concatene o conteúdo Bytes enquanto seu aplicativo recebe as partes da carga útil. Ao concatenar os dados JSON de exemplo aqui, você combinaria os dados em um corpo JSON delimitado por nova linha. Em seguida, seu código poderia processar o fluxo analisando todo o objeto JSON em cada linha.

O exemplo a seguir mostra o JSON delimitado por nova linha que você criaria ao concatenar o conteúdo de exemplo de Bytes:

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

exemplo Código para processar um fluxo de inferência

O exemplo de classe Python a seguir, SmrInferenceStream, demonstra como você pode processar um fluxo de inferência que envia dados de texto no 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]

Este exemplo processa o fluxo de inferência fazendo o seguinte:

• É inicializado com um cliente SageMaker Runtime e o nome de um endpoint do modelo. Antes de obter um fluxo de inferência, o modelo que o endpoint hospeda deve oferecer suporte ao streaming de inferência.

• No método de exemplo stream_inference, recebe um corpo de solicitação e o passa para o método invoke_endpoint_with_response_stream do SDK.

• Itera sobre cada evento no objeto EventStream que o SDK retorna.

• De cada evento, obtém o conteúdo do objeto Bytes no objeto PayloadPart.

• No método _write de exemplo, grava em um buffer para concatenar o conteúdo dos objetos Bytes. O conteúdo combinado forma um corpo JSON delimitado por nova linha.

• Usa o método _readlines de exemplo para obter uma série iterável de objetos JSON.

• Em cada objeto JSON, obtém uma parte da inferência.

• Com a expressão yield, retorna as peças de forma incremental.

O exemplo a seguir cria e usa um 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 exemplo passa um corpo de solicitação para o método stream_inference. Ele itera sobre a resposta para imprimir cada peça que o fluxo de inferência retorna.

O exemplo pressupõe que o modelo no endpoint especificado é um LLM que gera texto. A saída desse exemplo é um corpo de texto gerado que é impresso de forma incremental:

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

Invoque seu endpoint usando o AWS CLI

Você pode testar seu endpoint executando comandos com o AWS Command Line Interface (AWS CLI). O AWS CLI oferece suporte a solicitações de inferência padrão com o comando invoke-endpoint e oferece suporte a solicitações de inferência assíncronas com o comando invoke-endpoint-async.

nota

O AWS CLI não oferece suporte a solicitações de inferência de streaming.

O exemplo a seguir usa o comando invoke-endpoint para enviar uma solicitação de inferência para um endpoint do modelo:

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

Para o parâmetro --endpoint-name, forneça o nome que você especificou para EndpointName quando criou seu endpoint com CreateEndpoint. Para o --body parâmetro, forneça dados de entrada SageMaker para passar para o modelo. Os dados devem estar no mesmo formato usado para treinamento. Este exemplo mostra como enviar dados binários para o seu endpoint.

Para obter mais informações sobre quando usar file:// over fileb:// ao passar o conteúdo de um arquivo para um parâmetro do AWS CLI, consulte Melhores práticas para parâmetros de arquivos locais.

Para obter mais informações e ver parâmetros adicionais que você pode passar, consulte invoke-endpoint na Referência de Comandos AWS CLI .

Se o comando invoke-endpoint for bem-sucedido, ele retornará uma resposta como a seguinte:

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

Se o comando não for bem-sucedido, verifique se a carga útil de entrada está no formato correto.

Visualize a saída da invocação verificando o arquivo de saída do arquivo (output_file.txt neste exemplo).

more output_file.txt