Passen Sie Ihren eigenen Inferenzcontainer für Amazon SageMaker AI an

Wenn Sie keines der in Vorgefertigte KI-Docker-Images SageMaker Amazon SageMaker AI aufgelisteten Images für Ihren Anwendungsfall verwenden können, können Sie Ihren eigenen Docker-Container erstellen und ihn innerhalb von SageMaker AI für Schulungen und Inferenzen verwenden. Um mit SageMaker KI kompatibel zu sein, muss Ihr Container die folgenden Eigenschaften aufweisen:

Ihr Container muss über einen Webserver verfügen, auf dem der Port aufgeführt ist8080.
Ihr Container muss POST Anfragen an die Endpunkte /invocations und /ping in Echtzeit akzeptieren. Die Anfragen, die Sie an diese Endpunkte senden, müssen innerhalb von 60 Sekunden zurückgegeben werden und eine maximale Größe von 6 MB haben.

Weitere Informationen und ein Beispiel dafür, wie Sie Ihren eigenen Docker-Container für Training und Inferenz mit SageMaker KI erstellen, finden Sie unter Erstellen eines eigenen Algorithmus-Containers.

Die folgende Anleitung zeigt Ihnen, wie Sie einen JupyterLab Space mit Amazon SageMaker Studio Classic verwenden, um einen Inferenzcontainer an die Arbeit mit SageMaker KI-Hosting anzupassen. Das Beispiel verwendet eine NGINX Webserver, Gunicorn als Python Webserver-Gateway-Schnittstelle und Flask als Framework für Webanwendungen. Sie können verschiedene Anwendungen verwenden, um Ihren Container anzupassen, sofern er die zuvor aufgeführten Anforderungen erfüllt. Weitere Informationen zur Verwendung Ihres eigenen Inferenzcodes finden Sie unterBenutzerdefinierter Inferenzcode mit Hosting-Diensten.

Passen Sie Ihren Inferenzcontainer an

Verwenden Sie die folgenden Schritte, um Ihren eigenen Inferenzcontainer so anzupassen, dass er mit SageMaker KI-Hosting funktioniert. Das in den folgenden Schritten gezeigte Beispiel verwendet ein vortrainiertes Named Entity Recognition (NER) -Modell, das die SpacY Natural Language Processing (NLP) -Bibliothek für Python folgende Zwecke verwendet:

A Dockerfile um den Container zu erstellen, der Folgendes enthält NER Modell.
Inferenzskripte für NER Modell.

Wenn Sie dieses Beispiel für Ihren Anwendungsfall anpassen, müssen Sie ein verwenden Dockerfile und Inferenzskripten, die für die Bereitstellung und Bereitstellung Ihres Modells erforderlich sind.

Schaffen Sie JupyterLab Speicherplatz mit Amazon SageMaker Studio Classic (optional).

Sie können jedes Notizbuch verwenden, um Skripte auszuführen, um Ihren Inferenzcontainer mit SageMaker KI-Hosting anzupassen. Dieses Beispiel zeigt Ihnen, wie Sie a verwenden JupyterLab Platz in Amazon SageMaker Studio Classic zum Starten eines JupyterLab Anwendung, die mit einem SageMaker AI Distribution-Image geliefert wird. Weitere Informationen finden Sie unter SageMaker JupyterLab.

Laden Sie eine hoch Docker Datei- und Inferenzskripte.

Erstellen Sie einen neuen Ordner in Ihrem Home-Verzeichnis. Wenn du verwendest JupyterLab, wählen Sie in der oberen linken Ecke das Symbol „Neuer Ordner“ und geben Sie einen Ordnernamen ein, der Ihren Ordner enthalten soll Dockerfile. In diesem Beispiel wird der Ordner aufgerufendocker_test_folder.
Laden Sie eine hoch Dockerfile Textdatei in Ihren neuen Ordner. Das Folgende ist ein Beispiel Dockerfile das erzeugt eine Docker Container mit einem vortrainierten Named Entity Recognition (NER) -Modell von SpacY, den Anwendungen und Umgebungsvariablen, die zur Ausführung des Beispiels benötigt werden:
```
FROM python:3.8

RUN apt-get -y update && apt-get install -y --no-install-recommends \
         wget \
         python3 \
         nginx \
         ca-certificates \
    && rm -rf /var/lib/apt/lists/*

RUN wget https://bootstrap.pypa.io/get-pip.py && python3 get-pip.py && \
    pip install flask gevent gunicorn && \
        rm -rf /root/.cache

#pre-trained model package installation
RUN pip install spacy
RUN python -m spacy download en


# Set environment variables
ENV PYTHONUNBUFFERED=TRUE
ENV PYTHONDONTWRITEBYTECODE=TRUE
ENV PATH="/opt/program:${PATH}"

COPY NER /opt/program
WORKDIR /opt/program
```
Im vorherigen Codebeispiel behält die Umgebungsvariable PYTHONUNBUFFERED Python von der Pufferung des Standardausgabestroms, was eine schnellere Übermittlung von Protokollen an den Benutzer ermöglicht. Die Umgebungsvariable behält PYTHONDONTWRITEBYTECODE Python vom Schreiben kompilierter .pyc Bytecode-Dateien, die für diesen Anwendungsfall unnötig sind. Die Umgebungsvariable PATH wird verwendet, um den Speicherort der serve Programme train und zu identifizieren, wenn der Container aufgerufen wird.
Erstellen Sie in Ihrem neuen Ordner ein neues Verzeichnis, das Skripten für Ihr Modell enthält. In diesem Beispiel wird ein Verzeichnis namens verwendetNER, das die folgenden Skripten enthält, die für die Ausführung dieses Beispiels erforderlich sind:
- predictor.py— Ein Python Skript, das die Logik zum Laden und Durchführen von Inferenzen mit Ihrem Modell enthält.
- nginx.conf— Ein Skript zur Konfiguration eines Webservers.
- serve— Ein Skript, das einen Inferenzserver startet.
- wsgi.py— Ein Hilfsskript zur Bereitstellung eines Modells.
Wichtig
Wenn Sie Ihre Inferenzskripten in ein Notizbuch mit der Endung kopieren .ipynb und sie umbenennen, kann Ihr Skript Formatierungszeichen enthalten, die verhindern, dass Ihr Endpunkt bereitgestellt wird. Erstellen Sie stattdessen eine Textdatei und benennen Sie sie um.

Laden Sie ein Skript hoch, um Ihr Modell für Inferenzen verfügbar zu machen. Das Folgende ist ein Beispielskript namenspredictor.py, das verwendet Flask um die /invocations Endpunkte /ping und bereitzustellen:


from flask import Flask
import flask
import spacy
import os
import json
import logging

#Load in model
nlp = spacy.load('en_core_web_sm') 
#If you plan to use a your own model artifacts, 
#your model artifacts should be stored in /opt/ml/model/ 


# The flask app for serving predictions
app = Flask(__name__)
@app.route('/ping', methods=['GET'])
def ping():
    # Check if the classifier was loaded correctly
    health = nlp is not None
    status = 200 if health else 404
    return flask.Response(response= '\n', status=status, mimetype='application/json')


@app.route('/invocations', methods=['POST'])
def transformation():
    
    #Process input
    input_json = flask.request.get_json()
    resp = input_json['input']
    
    #NER
    doc = nlp(resp)
    entities = [(X.text, X.label_) for X in doc.ents]

    # Transform predictions to JSON
    result = {
        'output': entities
        }

    resultjson = json.dumps(result)
    return flask.Response(response=resultjson, status=200, mimetype='application/json')

Der /ping Endpunkt im vorherigen Skriptbeispiel gibt einen Statuscode zurück, der 200 angibt, ob das Modell korrekt geladen wurde und 404 ob das Modell falsch geladen wurde. Der /invocations Endpunkt verarbeitet eine Anfrage, formatiert in JSON, extrahiert das Eingabefeld und verwendet NER Modell zur Identifizierung und Speicherung von Entitäten in den variablen Entitäten. Das Tool Flask Die Anwendung gibt die Antwort zurück, die diese Entitäten enthält. Weitere Informationen zu diesen erforderlichen Integritätsanfragen finden Sie unterSo sollte Ihr Container auf Zustandsprüfungsanforderungen (Ping-Anforderungen) reagieren.

Laden Sie ein Skript hoch, um einen Inferenzserver zu starten. Das folgende Skriptbeispiel ruft serve mit Gunicorn als Anwendungsserver und Nginx als Webserver:


#!/usr/bin/env python

# This file implements the scoring service shell. You don't necessarily need to modify it for various
# algorithms. It starts nginx and gunicorn with the correct configurations and then simply waits until
# gunicorn exits.
#
# The flask server is specified to be the app object in wsgi.py
#
# We set the following parameters:
#
# Parameter                Environment Variable              Default Value
# ---------                --------------------              -------------
# number of workers        MODEL_SERVER_WORKERS              the number of CPU cores
# timeout                  MODEL_SERVER_TIMEOUT              60 seconds

import multiprocessing
import os
import signal
import subprocess
import sys

cpu_count = multiprocessing.cpu_count()

model_server_timeout = os.environ.get('MODEL_SERVER_TIMEOUT', 60)
model_server_workers = int(os.environ.get('MODEL_SERVER_WORKERS', cpu_count))

def sigterm_handler(nginx_pid, gunicorn_pid):
    try:
        os.kill(nginx_pid, signal.SIGQUIT)
    except OSError:
        pass
    try:
        os.kill(gunicorn_pid, signal.SIGTERM)
    except OSError:
        pass

    sys.exit(0)

def start_server():
    print('Starting the inference server with {} workers.'.format(model_server_workers))


    # link the log streams to stdout/err so they will be logged to the container logs
    subprocess.check_call(['ln', '-sf', '/dev/stdout', '/var/log/nginx/access.log'])
    subprocess.check_call(['ln', '-sf', '/dev/stderr', '/var/log/nginx/error.log'])

    nginx = subprocess.Popen(['nginx', '-c', '/opt/program/nginx.conf'])
    gunicorn = subprocess.Popen(['gunicorn',
                                 '--timeout', str(model_server_timeout),
                                 '-k', 'sync',
                                 '-b', 'unix:/tmp/gunicorn.sock',
                                 '-w', str(model_server_workers),
                                 'wsgi:app'])

    signal.signal(signal.SIGTERM, lambda a, b: sigterm_handler(nginx.pid, gunicorn.pid))

    # Exit the inference server upon exit of either subprocess
    pids = set([nginx.pid, gunicorn.pid])
    while True:
        pid, _ = os.wait()
        if pid in pids:
            break

    sigterm_handler(nginx.pid, gunicorn.pid)
    print('Inference server exiting')

# The main routine to invoke the start function.

if __name__ == '__main__':
    start_server()

Das vorherige Skriptbeispiel definiert eine Signal-Handler-Funktionsigterm_handler, die das herunterfährt Nginx and Gunicorn Unterprozesse, wenn sie ein SIGTERM Signal empfängt. Eine start_server Funktion startet den Signalhandler, startet und überwacht den Nginx and Gunicorn unterverarbeitet und erfasst Log-Streams.

Laden Sie ein Skript hoch, um Ihren Webserver zu konfigurieren. Das folgende Skriptbeispiel mit dem Namennginx.conf, konfiguriert ein Nginx Webserver mit Gunicorn als Anwendungsserver, der Ihrem Modell als Inferenz dient:
```
worker_processes 1;
daemon off; # Prevent forking


pid /tmp/nginx.pid;
error_log /var/log/nginx/error.log;

events {
  # defaults
}

http {
  include /etc/nginx/mime.types;
  default_type application/octet-stream;
  access_log /var/log/nginx/access.log combined;
  
  upstream gunicorn {
    server unix:/tmp/gunicorn.sock;
  }

  server {
    listen 8080 deferred;
    client_max_body_size 5m;

    keepalive_timeout 5;
    proxy_read_timeout 1200s;

    location ~ ^/(ping|invocations) {
      proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
      proxy_set_header Host $http_host;
      proxy_redirect off;
      proxy_pass http://gunicorn;
    }

    location / {
      return 404 "{}";
    }
  }
}
```
Das vorherige Skriptbeispiel konfiguriert Nginx um im Vordergrund zu laufen, legt den Ort fest, an dem erfasst werden sollerror_log, und definiert upstream als Gunicorn Socket-Socke des Servers. Der Server konfiguriert den Serverblock so, dass er den Port abhört8080, und legt Grenzwerte für die Größe des Hauptteils der Client-Anfrage und die Timeout-Werte fest. Der Serverblock leitet Anfragen, die entweder /ping oder /invocations -Pfade enthalten, an Gunicorn server http://gunicorn, und gibt einen 404 Fehler für andere Pfade zurück.
Laden Sie alle anderen Skripten hoch, die für Ihr Modell erforderlich sind. Für dieses Beispiel wird das folgende Beispielskript benötigt, das als Hilfe aufgerufen wird wsgi.py Gunicorn finde deine Anwendung:
```
import predictor as myapp

# This is just a simple wrapper for gunicorn to find your app.
# If you want to change the algorithm file, simply change "predictor" above to the
# new file.

app = myapp.app
```

Aus dem Ordner docker_test_folder sollte Ihre Verzeichnisstruktur eine enthalten Dockerfile und der Ordner NER. Das NER Der Ordner sollte die Dateiennginx.conf, predictor.pyserve, und wsgi.py wie folgt enthalten:

The Dockerfile structure has inference scripts under the NER directory next to the Dockerfile.

Baue deinen eigenen Container.

Erstellen Sie aus docker_test_folder dem Ordner Ihren Docker Behälter. Der folgende Beispielbefehl erstellt den Docker Container, der in Ihrem konfiguriert ist Dockerfile:
```
! docker build -t byo-container-test .
```
Der vorherige Befehl erstellt einen Container, der byo-container-test im aktuellen Arbeitsverzeichnis aufgerufen wird. Für weitere Informationen über Docker Build-Parameter finden Sie unter Build-Argumente.
Anmerkung
Wenn Sie die folgende Fehlermeldung erhalten Docker kann das nicht finden Dockerfile, stellen Sie sicher, dass Dockerfile hat den richtigen Namen und wurde im Verzeichnis gespeichert.
```
unable to prepare context: unable to evaluate symlinks in Dockerfile path:
lstat /home/ec2-user/SageMaker/docker_test_folder/Dockerfile: no such file or directory
```
Docker sucht nach einer Datei mit dem speziellen Namen Dockerfile ohne Erweiterung innerhalb des aktuellen Verzeichnisses. Wenn Sie es anders benannt haben, können Sie den Dateinamen manuell mit dem Flag -f übergeben. Wenn Sie zum Beispiel Ihren Namen gegeben haben Dockerfile als Dockerfile-text.txt, baue dein Docker Container, der das -f Flag gefolgt von Ihrer Datei wie folgt verwendet:
```
! docker build -t byo-container-test -f Dockerfile-text.txt .
```

Drücken Sie Ihre Docker Bild in eine Amazon Elastic Container Registry (Amazon ECR)

Drücken Sie in einer Notebookzelle Ihren Docker Bild auf ein ECR. Das folgende Codebeispiel zeigt Ihnen, wie Sie Ihren Container lokal erstellen, sich anmelden und ihn in einen ECR übertragen:


%%sh
# Name of algo -> ECR
algorithm_name=sm-pretrained-spacy

#make serve executable
chmod +x NER/serve
account=$(aws sts get-caller-identity --query Account --output text)
# Region, defaults to us-west-2
region=$(aws configure get region)
region=${region:-us-east-1}
fullname="${account}.dkr.ecr.${region}.amazonaws.com/${algorithm_name}:latest"
# If the repository doesn't exist in ECR, create it.
aws ecr describe-repositories --repository-names "${algorithm_name}" > /dev/null 2>&1
if [ $? -ne 0 ]
then
    aws ecr create-repository --repository-name "${algorithm_name}" > /dev/nullfi
# Get the login command from ECR and execute it directly
aws ecr get-login-password --region ${region}|docker login --username AWS --password-stdin ${fullname}
# Build the docker image locally with the image name and then push it to ECR
# with the full name.

docker build  -t ${algorithm_name} .
docker tag ${algorithm_name} ${fullname}

docker push ${fullname}

Im vorherigen Beispiel wird gezeigt, wie Sie die folgenden Schritte ausführen, die erforderlich sind, um den Docker-Beispielcontainer in einen ECR zu übertragen:

Definieren Sie den Namen des Algorithmus als. sm-pretrained-spacy
Erstellen Sie die serve Datei in NER Ordner ausführbar.
Stellen Sie das ein AWS-Region.
Erstellen Sie einen ECR, falls er noch nicht existiert.
Loggen Sie sich in den ECR ein.
Baue das Docker Container lokal.
Drücken Sie den Docker Bild zum ECR.

Richten Sie den SageMaker KI-Client ein

Wenn Sie SageMaker KI-Hosting-Dienste für Inferenzen verwenden möchten, müssen Sie ein Modell, eine Endpunktkonfiguration und einen Endpunkt erstellen. Um Rückschlüsse von Ihrem Endpunkt zu erhalten, können Sie die KI verwenden SageMaker boto3 Runtime-Client zum Aufrufen Ihres Endpunkts. Der folgende Code zeigt Ihnen, wie Sie sowohl den SageMaker AI-Client als auch den SageMaker Runtime-Client mithilfe des SageMaker AI-Boto3-Clients einrichten:
```
import boto3
from sagemaker import get_execution_role

sm_client = boto3.client(service_name='sagemaker')
runtime_sm_client = boto3.client(service_name='sagemaker-runtime')

account_id = boto3.client('sts').get_caller_identity()['Account']
region = boto3.Session().region_name

#used to store model artifacts which SageMaker AI will extract to /opt/ml/model in the container, 
#in this example case we will not be making use of S3 to store the model artifacts
#s3_bucket = '<S3Bucket>'

role = get_execution_role()
```
Im vorherigen Codebeispiel wird der Amazon S3 S3-Bucket nicht verwendet, sondern als Kommentar eingefügt, um zu zeigen, wie Modellartefakte gespeichert werden.

Wenn Sie nach der Ausführung des vorherigen Codebeispiels einen Berechtigungsfehler erhalten, müssen Sie Ihrer IAM-Rolle möglicherweise Berechtigungen hinzufügen. Weitere Informationen zu IAM-Rollen finden Sie unter Amazon SageMaker Rollenmanager. Weitere Informationen zum Hinzufügen von Berechtigungen zu Ihrer aktuellen Rolle finden Sie unterAWS verwaltete Richtlinien für Amazon SageMaker AI.

Erstellen Sie Ihr Modell.

Wenn Sie SageMaker KI-Hosting-Dienste für Inferenzen verwenden möchten, müssen Sie ein Modell in SageMaker KI erstellen. Das folgende Codebeispiel zeigt Ihnen, wie Sie das erstellen spaCy NER Modell innerhalb von SageMaker KI:


from time import gmtime, strftime

model_name = 'spacy-nermodel-' + strftime("%Y-%m-%d-%H-%M-%S", gmtime())
# MODEL S3 URL containing model atrifacts as either model.tar.gz or extracted artifacts. 
# Here we are not  
#model_url = 's3://{}/spacy/'.format(s3_bucket) 

container = '{}.dkr.ecr.{}.amazonaws.com/sm-pretrained-spacy:latest'.format(account_id, region)
instance_type = 'ml.c5d.18xlarge'

print('Model name: ' + model_name)
#print('Model data Url: ' + model_url)
print('Container image: ' + container)

container = {
'Image': container
}

create_model_response = sm_client.create_model(
    ModelName = model_name,
    ExecutionRoleArn = role,
    Containers = [container])

print("Model Arn: " + create_model_response['ModelArn'])

Das vorherige Codebeispiel zeigt model_url anhand der Kommentare in Schritt 5, wie Sie mit dem Bucket „s3_bucketWenn Sie den Amazon S3 S3-Bucket verwenden würden“ definieren. Außerdem wird der ECR-URI für das Container-Image definiert. In den vorherigen Codebeispielen wird der Instance-Typ ml.c5d.18xlarge als definiert. Sie können auch einen anderen Instanztyp wählen. Weitere Informationen zu verfügbaren Instance-Typen finden Sie unter EC2 Amazon-Instance-Typen.

Im vorherigen Codebeispiel verweist The Image key auf die Container-Image-URI. Die create_model_response Definition verwendet die, create_model method um ein Modell zu erstellen und den Modellnamen, die Rolle und eine Liste mit den Containerinformationen zurückzugeben.

Es folgt eine Beispielausgabe aus dem vorherigen Skript:


Model name: spacy-nermodel-YYYY-MM-DD-HH-MM-SS
Model data Url: s3://spacy-sagemaker-us-east-1-bucket/spacy/
Container image: 123456789012.dkr.ecr.us-east-2.amazonaws.com/sm-pretrained-spacy:latest
Model Arn: arn:aws:sagemaker:us-east-2:123456789012:model/spacy-nermodel-YYYY-MM-DD-HH-MM-SS

1. Einen Endpunkt konfigurieren und erstellen
  
  Um SageMaker KI-Hosting für Inferenz zu verwenden, müssen Sie auch einen Endpunkt konfigurieren und erstellen. SageMaker KI wird diesen Endpunkt für Inferenzen verwenden. Das folgende Konfigurationsbeispiel zeigt, wie Sie einen Endpunkt mit dem zuvor definierten Instanztyp und Modellnamen generieren und konfigurieren:
```
endpoint_config_name = 'spacy-ner-config' + strftime("%Y-%m-%d-%H-%M-%S", gmtime())
print('Endpoint config name: ' + endpoint_config_name)

create_endpoint_config_response = sm_client.create_endpoint_config(
    EndpointConfigName = endpoint_config_name,
    ProductionVariants=[{
        'InstanceType': instance_type,
        'InitialInstanceCount': 1,
        'InitialVariantWeight': 1,
        'ModelName': model_name,
        'VariantName': 'AllTraffic'}])
        
print("Endpoint config Arn: " + create_endpoint_config_response['EndpointConfigArn'])
```
  Verknüpft im vorherigen Konfigurationsbeispiel den model_name mit einem eindeutigen Endpunktkonfigurationsnamenendpoint_config_name, der mit einem Zeitstempel erstellt wurde. create_endpoint_config_response
  
  Es folgt eine Beispielausgabe aus dem vorherigen Skript:
```
Endpoint config name: spacy-ner-configYYYY-MM-DD-HH-MM-SS
Endpoint config Arn: arn:aws:sagemaker:us-east-2:123456789012:endpoint-config/spacy-ner-config-MM-DD-HH-MM-SS
```
  Weitere Informationen zu Endpunktfehlern finden Sie unter Warum wechselt mein Amazon SageMaker AI-Endpunkt in den Status „Fehlgeschlagen“, wenn ich einen Endpunkt erstelle oder aktualisiere?
2. Erstellen Sie einen Endpunkt und warten Sie, bis der Endpunkt in Betrieb ist.
  
  Das folgende Codebeispiel erstellt den Endpunkt mithilfe der Konfiguration aus dem vorherigen Konfigurationsbeispiel und stellt das Modell bereit:
```
%%time

import time

endpoint_name = 'spacy-ner-endpoint' + strftime("%Y-%m-%d-%H-%M-%S", gmtime())
print('Endpoint name: ' + endpoint_name)

create_endpoint_response = sm_client.create_endpoint(
    EndpointName=endpoint_name,
    EndpointConfigName=endpoint_config_name)
print('Endpoint Arn: ' + create_endpoint_response['EndpointArn'])

resp = sm_client.describe_endpoint(EndpointName=endpoint_name)
status = resp['EndpointStatus']
print("Endpoint Status: " + status)

print('Waiting for {} endpoint to be in service...'.format(endpoint_name))
waiter = sm_client.get_waiter('endpoint_in_service')
waiter.wait(EndpointName=endpoint_name)
```
  Im vorherigen Codebeispiel erstellt die create_endpoint Methode den Endpunkt mit dem generierten Endpunktnamen, der im vorherigen Codebeispiel erstellt wurde, und druckt den Amazon-Ressourcennamen des Endpunkts. Die describe_endpoint Methode gibt Informationen über den Endpunkt und seinen Status zurück. Ein SageMaker KI-Kellner wartet darauf, dass der Endpunkt betriebsbereit ist.
Testen Sie Ihren Endpunkt.

Sobald Ihr Endpunkt in Betrieb ist, senden Sie eine Aufrufanfrage an Ihren Endpunkt. Das folgende Codebeispiel zeigt, wie Sie eine Testanfrage an Ihren Endpunkt senden:
```
import json
content_type = "application/json"
request_body = {"input": "This is a test with NER in America with \
    Amazon and Microsoft in Seattle, writing random stuff."}

#Serialize data for endpoint
#data = json.loads(json.dumps(request_body))
payload = json.dumps(request_body)

#Endpoint invocation
response = runtime_sm_client.invoke_endpoint(
EndpointName=endpoint_name,
ContentType=content_type,
Body=payload)

#Parse results
result = json.loads(response['Body'].read().decode())['output']
result
```
Im vorherigen Codebeispiel json.dumps serialisiert die Methode das request_body in eine in JSON formatierte Zeichenfolge und speichert sie in der variablen Payload. Dann verwendet der SageMaker AI Runtime-Client die Methode „Endpoint aufrufen“, um Nutzdaten an Ihren Endpunkt zu senden. Das Ergebnis enthält die Antwort von Ihrem Endpunkt nach dem Extrahieren des Ausgabefeldes.

Das vorherige Codebeispiel sollte die folgende Ausgabe zurückgeben:
```
[['NER', 'ORG'],
 ['America', 'GPE'],
 ['Amazon', 'ORG'],
 ['Microsoft', 'ORG'],
 ['Seattle', 'GPE']]
```
Löschen Sie Ihren Endpunkt

Nachdem Sie Ihre Aufrufe abgeschlossen haben, löschen Sie Ihren Endpunkt, um Ressourcen zu schonen. Das folgende Codebeispiel zeigt Ihnen, wie Sie Ihren Endpunkt löschen:
```
sm_client.delete_endpoint(EndpointName=endpoint_name)
sm_client.delete_endpoint_config(EndpointConfigName=endpoint_config_name)
sm_client.delete_model(ModelName=model_name)
```
Ein vollständiges Notizbuch, das den Code in diesem Beispiel enthält, finden Sie unter BYOC-Single-Model.

Warnung JavaScript ist in Ihrem Browser nicht verfügbar oder deaktiviert.

Zur Nutzung der AWS-Dokumentation muss JavaScript aktiviert sein. Weitere Informationen finden auf den Hilfe-Seiten Ihres Browsers.

Dokumentkonventionen

Verwenden Sie eine Docker-Registry, für die eine Authentifizierung für das Training erforderlich ist

Erstellung von Containern mit Ihren eigenen Algorithmen und Modellen

Passen Sie Ihren eigenen Inferenzcontainer für Amazon SageMaker AI an

Passen Sie Ihren Inferenzcontainer an

Wichtig

Anmerkung

Einen Endpunkt konfigurieren und erstellen

Erstellen Sie einen Endpunkt und warten Sie, bis der Endpunkt in Betrieb ist.