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 für reguläre Antworten und 8 Minuten für Streaming-Antworten zurückgegeben werden und eine maximale Größe von 25 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 einen NGINX Webserver Gunicorn als Python Webserver-Gateway-Schnittstelle und Flask als Webanwendungs-Framework. 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:

ADockerfile, um den Container zu erstellen, der das Modell enthält. NER
Inferenzskripten zur Bereitstellung des NER Modells.

Wenn Sie dieses Beispiel für Ihren Anwendungsfall anpassen, müssen Sie A Dockerfile - und Inferenzskripten verwenden, 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 einen JupyterLab Bereich in Amazon SageMaker Studio Classic verwenden, um eine JupyterLab Anwendung zu starten, die mit einem SageMaker AI Distribution-Image geliefert wird. Weitere Informationen finden Sie unter SageMaker JupyterLab.

Laden Sie eine Docker Datei und Inferenzskripte hoch.

Erstellen Sie einen neuen Ordner in Ihrem Home-Verzeichnis. Wenn Sie verwendenJupyterLab, 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 heißt der Ordner. docker_test_folder
Laden Sie eine Dockerfile Textdatei in Ihren neuen Ordner hoch. Im Folgenden finden Sie ein BeispielDockerfile, das einen Docker Container mit einem vortrainierten Named Entity Recognition (NER) -Modell von SpaCy sowie den Anwendungen und Umgebungsvariablen erstellt, die für die Ausführung des Beispiels erforderlich sind:
```
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 PYTHONUNBUFFERED Python verhindert die Umgebungsvariable, dass der Standardausgabestream gepuffert wird, was eine schnellere Übermittlung von Protokollen an den Benutzer ermöglicht. Die Umgebungsvariable PYTHONDONTWRITEBYTECODE Python verhindert das 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. Im Folgenden finden Sie ein Beispielskript mit dem Namenpredictor.py, das Flask zur Bereitstellung der /invocations Endpunkte /ping und verwendet wird:


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 in formatierte AnfrageJSON, extrahiert das Eingabefeld und verwendet das NER Modell, um Entitäten in den variablen Entitäten zu identifizieren und zu speichern. Die Flask 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 die serve Verwendung Gunicorn als Anwendungsserver und Nginx als Webserver auf:


#!/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 die Nginx und Gunicorn Unterprozesse herunterfährt, wenn sie ein SIGTERM Signal empfängt. Eine start_server Funktion startet den Signalhandler, startet und überwacht die Gunicorn Unterprozesse Nginx und erfasst Protokollströme.

Laden Sie ein Skript hoch, um Ihren Webserver zu konfigurieren. Das folgende Skriptbeispiel mit dem Namen konfiguriert einen Nginx Webservernginx.conf, der Gunicorn als Anwendungsserver verwendet wird, um Ihr Modell als Inferenz bereitzustellen:
```
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 es so, Nginx dass es im Vordergrund ausgeführt wird, legt den Speicherort für die error_log Erfassung fest und definiert es upstream als Socket-Sock des Gunicorn Servers. Der Server konfiguriert den Serverblock so, dass er den Port abhört8080, und legt Grenzwerte für die Textgröße der Client-Anfrage und die Timeout-Werte fest. Der Serverblock leitet Anfragen, die entweder /invocations Pfade /ping oder enthalten Gunicornserver http://gunicorn, an den weiter und gibt bei anderen Pfaden einen 404 Fehler zurück.

Laden Sie alle anderen Skripts hoch, die für Ihr Modell erforderlich sind. Für dieses Beispiel muss das folgende Beispielskript aufgerufen werdenwsgi.py, um Ihre Anwendung zu Gunicorn finden:


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 einen Dockerfile und den Ordner enthaltenNER. Der NER 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.

Erstellen Sie Ihren eigenen Container.

Erstellen Sie aus docker_test_folder dem Ordner Ihren Docker Container. Der folgende Beispielbefehl erstellt den Docker Container, der in Ihrem konfiguriert istDockerfile:
```
! docker build -t byo-container-test .
```
Der vorherige Befehl erstellt einen Container, der byo-container-test im aktuellen Arbeitsverzeichnis aufgerufen wird. Weitere Informationen zu den Docker Build-Parametern finden Sie unter Build-Argumente.
Anmerkung
Wenn Sie die folgende Fehlermeldung erhalten, in der Sie das Docker nicht finden könnenDockerfile, stellen Sie sicher, dass das den richtigen Namen hat und im Verzeichnis gespeichert wurde. Dockerfile
```
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
```
Dockersucht im aktuellen Verzeichnis nach einer Datei, die speziell Dockerfile ohne Erweiterung aufgerufen wurde. Wenn Sie ihr einen anderen Namen gegeben haben, können Sie den Dateinamen manuell mit dem Flag -f übergeben. Wenn Sie beispielsweise Ihren Namen Dockerfile als angegeben habenDockerfile-text.txt, erstellen Sie Ihren Docker Container mit dem -f Flag, gefolgt von Ihrer Datei, wie folgt:
```
! docker build -t byo-container-test -f Dockerfile-text.txt .
```

Übertragen Sie Ihr Docker Image in eine Amazon Elastic Container Registry (Amazon ECR)

Übertragen Sie Ihr Docker Image in einer Notebook-Zelle auf einen 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
Machen Sie die serve Datei im 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.
Erstellen Sie den Docker Container lokal.
Schieben Sie das Docker Bild auf den 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 den SageMaker AI boto3 Runtime-Client verwenden, um Ihren Endpunkt aufzurufen. 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 spaCy NER Modell innerhalb von SageMaker AI erstellen:
```
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 Instanztyp und Modellnamen generieren und konfigurieren, den Sie zuvor definiert haben:
```
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.