Rufen Sie Modelle für Inferenz in Echtzeit auf

Nachdem Sie Ihr Modell mithilfe von SageMaker Hosting-Diensten bereitgestellt haben, können Sie Ihr Modell auf diesem Endpunkt testen, indem Sie ihm Testdaten senden. Sie können Ihre Endgeräte mit Amazon SageMaker Studio, den AWS SDKs oder dem testen. AWS CLI

Rufen Sie Ihren Endpunkt mit Amazon SageMaker Studio auf

Nachdem Sie Ihr Modell auf einem Endpunkt bereitgestellt haben, können Sie den Endpunkt über Amazon SageMaker Studio anzeigen und Ihren Endpunkt testen, indem Sie einzelne Inferenzanfragen senden.

Anmerkung

SageMaker unterstützt nur Endpunkttests in Studio für Echtzeit-Endgeräte.

Um eine Test-Inferenzanfrage an Ihren Endpunkt zu senden

1. Starten Sie Amazon SageMaker Studio.

2. Wählen Sie im Navigationsbereich auf der linken Seite Deployments aus.

3. Wählen Sie in der Dropdown-Liste die Option Endpunkte aus.

4. Suchen Sie anhand des Namens nach Ihrem Endpunkt und wählen Sie den Namen in der Tabelle aus. Die im Bereich Endpunkte aufgeführten Endpunktnamen werden bei der Bereitstellung eines Modells definiert. Der Studio-Arbeitsbereich öffnet die Endpunktseite auf einer neuen Registerkarte.

5. Wählen Sie die Registerkarte „Inferenz testen“.

6. Wählen Sie unter Testoptionen eine der folgenden Optionen aus:

   1. Wählen Sie Die Beispielanforderung testen aus, um sofort eine Anfrage an Ihren Endpunkt zu senden. Verwenden Sie den JSON-Editor, um Beispieldaten im JSON-Format bereitzustellen, und wählen Sie Anfrage senden, um die Anfrage an Ihren Endpunkt zu senden. Nach dem Absenden Ihrer Anfrage zeigt Studio die Inferenzausgabe auf einer Karte rechts neben dem JSON-Editor an.

   2. Wählen Sie Python-SDK-Beispielcode verwenden aus, um den Code für das Senden einer Anfrage an den Endpunkt anzuzeigen. Kopieren Sie dann das Codebeispiel aus dem Abschnitt „Beispiel für eine Inferenzanfrage“ und führen Sie den Code in Ihrer Testumgebung aus.

Oben auf der Karte wird die Art der Anfrage angezeigt, die an den Endpunkt gesendet wurde (nur JSON wird akzeptiert). Die Karte enthält die folgenden Felder:

• Status – zeigt einen der folgenden Statustypen an:

  • Success – Die Anforderung war erfolgreich.

  • Failed – Die Anforderung hat fehlgeschlagen. Unter Fehlerursache wird eine Antwort angezeigt.

  • Pending – Solange die Inferenzanforderung noch aussteht, zeigt der Status ein rotierendes, kreisförmiges Symbol an.

• Ausführungsdauer – Wie lange der Aufruf gedauert hat (Endzeit minus Startzeit) in Millisekunden.

• Anforderungszeit – Wie viele Minuten sind vergangen, seit die Anfrage gesendet wurde.

• Ergebniszeit – Wie viele Minuten sind vergangen, seit das Ergebnis zurückgegeben wurde.

Rufen Sie Ihren Endpunkt auf, indem Sie AWS SDK for Python (Boto3) verwenden

Nachdem Sie Ihr Modell auf einem Endpunkt bereitgestellt haben, können Sie Ihren Endpunkt überprüfen, indem Sie eines der AWS SDKs verwenden, unter anderem als. AWS SDK for Python (Boto3) Um Ihren Endpunkt mit diesem SDK zu testen, verwenden Sie eine der folgenden Methoden:

• invoke_endpoint– Sendet eine Inferenzanforderung an einen Modellendpunkt und gibt die Antwort zurück, die das Modell generiert. Diese Methode gibt die Inferenz-Payload als eine Antwort zurück, nachdem das Modell die Generierung abgeschlossen hat. Weitere Informationen finden Sie in invoke_endpoint in der AWS SDK für Python (Boto3) API-Referenz.

• invoke_endpoint_with_response_stream – Sendet eine Inferenzanforderung an einen Modellendpunkt und streamt die Antwort in inkrementellen Teilen, während das Modell die Inferenz generiert. Bei dieser Methode empfängt Ihre Client-Anwendung sofort Teile der Antwort, sobald die Teile verfügbar sind. Ihr Kunde muss nicht warten, bis das Modell die gesamte Antwortnutzlast generiert hat. Sie können Streaming implementieren, um schnelle interaktive Erlebnisse wie Chatbots, virtuelle Assistenten und Musikgeneratoren zu unterstützen.

  Verwenden Sie diese Methode nur, um Modelle aufzurufen, die Inferenzstreaming unterstützen.

  Wenn ein Container eine Streaming-Inferenzanforderung verarbeitet, gibt er die Inferenz des Modells inkrementell als eine Reihe von Teilen zurück, während das Modell sie generiert. Client-Anwendungen erhalten sofort Antworten, wenn sie verfügbar sind. Sie müssen nicht warten, bis das Modell die gesamte Antwort generiert hat. Sie können Streaming implementieren, um schnelle interaktive Erlebnisse wie Chatbots, virtuelle Assistenten und Musikgeneratoren zu unterstützen.

Bevor Sie diese Methoden in Ihrem Client-Code verwenden können, müssen Sie einen SageMaker Runtime-Client erstellen und den Namen Ihres Endpunkts angeben. Im folgenden Beispiel werden der Client und der Endpunkt für die restlichen folgenden Beispiele eingerichtet:

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'

Aufrufen, um eine Inferenzantwort zu erhalten

Im folgenden Beispiel wird die invoke_endpoint Methode verwendet, um einen Endpunkt aufzurufen mit 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'))

In diesem Beispiel werden Eingabedaten in das Body Feld eingegeben SageMaker , die an das Modell übergeben werden sollen. Diese Daten müssen dasselbe Format haben, das für das Training verwendet wurde. Das Beispiel speichert die Antwort in der response Variable.

Die response Variable bietet Zugriff auf den HTTP-Status, den Namen des bereitgestellten Modells und andere Felder. Das folgende Snippet druckt das HTTPStatusCode aus:

print(response["HTTPStatusCode"])

Aufrufen, um eine Inferenzantwort zu streamen

Wenn Sie ein Modell bereitgestellt haben, das Inferenzstreaming unterstützt, können Sie das Modell aufrufen, um seine Inferenz-Payload als Stream von Teilen zu empfangen. Das Modell liefert diese Teile inkrementell, während das Modell sie generiert. Wenn eine Anwendung einen Inferenzstream empfängt, muss die Anwendung nicht darauf warten, dass das Modell die gesamte Antwortnutzlast generiert. Stattdessen empfängt die Anwendung sofort Teile der Antwort, sobald sie verfügbar sind.

Indem Sie einen Inferenzstream in Ihrer Anwendung verwenden, können Sie Interaktionen erzeugen, bei denen Ihre Benutzer die Inferenz als schnell wahrnehmen, weil sie den ersten Teil sofort erhalten. Sie könnten beispielsweise einen Chatbot erstellen, der den von einem großem Sprachmodel (LLM) generierten Text inkrementell anzeigt.

Um einen Inferenzstream zu erhalten, können Sie die invoke_endpoint_with_response_stream Methode im SDK für Python (Boto3) verwenden. Im Antworttext stellt das SDK ein EventStream Objekt bereit, das die Inferenz als eine Reihe von PayloadPart Objekten wiedergibt.

Beispiel Inferenzstream

Das folgende Beispiel ist ein Stream von PayloadPart Objekten:

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

In jedem Nutzdatenteil stellt das Bytes Feld einen Teil der Inferenzantwort des Modells bereit. Bei diesem Teil kann es sich um einen beliebigen Inhaltstyp handeln, den ein Modell generiert, z. B. Text-, Bild- oder Audiodaten. In diesem Beispiel handelt es sich bei den Teilen um JSON-Objekte, die generierten Text aus einem LLM enthalten.

Normalerweise enthält der Payload-Teil einen diskreten Datenblock aus dem Modell. In diesem Beispiel sind die diskreten Blocks ganze JSON-Objekte. Gelegentlich teilt die Streaming-Antwort die BLocks auf mehrere Payload-Teile auf oder kombiniert mehrere Blocks zu einem Payload-Teil. Das folgende Beispiel zeigt einen Datenblock im JSON-Format, der auf zwei Nutzlastteile aufgeteilt ist:

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

Wenn Sie Anwendungscode schreiben, der einen Inferenzstream verarbeitet, sollten Sie Logik einbeziehen, die diese gelegentlichen Aufteilungen und Kombinationen von Daten verarbeitet. Als eine Strategie könnten Sie Code schreiben, der den Inhalt von Bytes verkettet, während Ihre Anwendung die Nutzdaten empfängt. Wenn Sie die JSON-Beispieldaten hier verketten, würden Sie die Daten zu einem durch Zeilenumbruch getrennten JSON-Hauptteil kombinieren. Dann könnte Ihr Code den Stream verarbeiten, indem er das gesamte JSON-Objekt in jeder Zeile analysiert.

Das folgende Beispiel zeigt das durch Zeilenumbrüche getrennte JSON, das Sie erstellen würden, wenn Sie den Beispielinhalt von Bytes verketten würden:

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

Beispiel Code zur Verarbeitung eines Inferenz-Streams

Die folgende Python-Beispielklasse, SmrInferenceStream, zeigt, wie Sie einen Inferenzstream verarbeiten können, der Textdaten im JSON-Format sendet:

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]

In diesem Beispiel wird der Inferenzstream wie folgt verarbeitet:

• Wird mit einem SageMaker Runtime-Client und dem Namen eines Modellendpunkts initialisiert. Bevor Sie einen Inferenzstream abrufen können, muss das Modell, das der Endpunkt hostet, Inferenzstreaming unterstützen.

• In der stream_inference Beispielmethode empfängt es einen Anforderungstext und übergibt ihn an die invoke_endpoint_with_response_stream Methode des SDK.

• Iteriert jedes Ereignis im EventStream Objekt, das das SDK zurückgibt.

• Ruft aus jedem Ereignis den Inhalt des Bytes Objekts im PayloadPart Objekt ab.

• In der _write Beispielmethode wird in einen Puffer geschrieben, um den Inhalt der Bytes Objekte zu verketten. Die kombinierten Inhalte bilden einen durch Zeilenumbrüche getrennten JSON-Hauptteil.

• Verwendet die _readlines Beispielmethode, um eine iterierbare Reihe von JSON-Objekten abzurufen.

• Ruft in jedem JSON-Objekt einen Teil der Inferenz ab.

• Gibt zusammen mit dem yield Ausdruck die Teile inkrementell zurück.

Im folgenden Beispiel wird ein SmrInferenceStream Objekt erstellt und verwendet:

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='')

In diesem Beispiel wird ein Anforderungstext an die stream_inference Methode übergeben. Es iteriert über die Antwort, um jedes Stück zu drucken, das der Inferenzstream zurückgibt.

Das Beispiel geht davon aus, dass es sich bei dem Modell am angegebenen Endpunkt um ein LLM handelt, das Text generiert. Die Ausgabe dieses Beispiels ist ein generierter Textkörper, der inkrementell gedruckt wird:

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

Rufen Sie Ihren Endpunkt auf, indem Sie den AWS CLI

Sie können Ihren Endpunkt testen, indem Sie Befehle mit dem AWS Command Line Interface (AWS CLI) ausführen. Der AWS CLI unterstützt standardmäßige Inferenzanfragen mit dem invoke-endpoint Befehl und asynchrone Inferenzanfragen mit dem invoke-endpoint-async Befehl.

Anmerkung

Der unterstützt AWS CLI keine Streaming-Inferenzanfragen.

Im folgenden Beispiel wird der invoke-endpoint Befehl verwendet, um eine Inferenzanforderung an einen Modellendpunkt zu senden:

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

Geben Sie für den --endpoint-name Parameter den Namen für EndpointName an, den Sie bei der Erstellung Ihres Endpunkts mit CreateEndpoint angegeben haben. Geben Sie für den --body Parameter Eingabedaten an, die SageMaker an das Modell übergeben werden sollen. Die Daten müssen dasselbe Format haben, das für das Training verwendet wurde. Dieses Beispiel zeigt, wie Sie Binärdaten an Ihren Endpunkt senden.

Weitere Informationen darüber, wann file:// Over verwendet werden sollte, fileb:// wenn der Inhalt einer Datei an einen Parameter von übergeben wird AWS CLI, finden Sie unter Bewährte Methoden für lokale Dateiparameter.

Weitere Informationen und zusätzliche Parameter, die Sie übergeben können, finden Sie in invoke-endpoint in der AWS CLI -Befehlsreferenz.

Wenn der invoke-endpoint Befehl erfolgreich ist, wird eine Antwort wie die folgende zurückgegeben:

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

Wenn der Befehl nicht erfolgreich ist, überprüfen Sie, ob die Eingabe-Payload das richtige Format hat.

Sehen Sie sich die Ausgabe des Aufrufs an, indem Sie die Dateiausgabedatei überprüfen (output_file.txt in diesem Beispiel).

more output_file.txt