Anpassung Ihres eigenen Inferenz-Containers

Wenn Sie keines der in Verwenden Sie vorgefertigte Docker-Images SageMaker Amazon aufgelisteten Images SageMaker für Ihren Anwendungsfall verwenden können, können Sie Ihren eigenen Docker-Container erstellen und ihn darin SageMaker für Schulungen und Inferenzen verwenden. Damit Ihr Container kompatibel ist SageMaker, muss er die folgenden Eigenschaften aufweisen:

Ihr Container muss über einen Webserver verfügen, der den Port auflistet8080.
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 erstellen können SageMaker, 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 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 unterVerwenden eigenen Inferenzcodes mit Hosting-Services.

Passen Sie Ihren Inferenzcontainer an

Gehen Sie wie folgt vor, um Ihren eigenen Inferenzcontainer an das Hosting anzupassen. SageMaker Das in den folgenden Schritten gezeigte Beispiel verwendet ein vortrainiertes NER-Modell (Named Entity Recognition), das die SpacY-Bibliothek für die Verarbeitung natürlicher Sprache (NLP) 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 Skripts auszuführen, um Ihren Inferenzcontainer an das SageMaker 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 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 Beispielskriptpredictor.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 Client SageMaker ein

Wenn Sie SageMaker 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 boto3 Runtime-Client verwenden, um Ihren Endpunkt aufzurufen. Der folgende Code zeigt Ihnen, wie Sie sowohl den SageMaker Client als auch den SageMaker Runtime-Client mit dem SageMaker boto3-Client 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 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.
Erstellen Sie Ihr Modell.

Wenn Sie SageMaker Hosting-Dienste für Inferenzen verwenden möchten, müssen Sie ein Modell in SageMaker erstellen. Das folgende Codebeispiel zeigt Ihnen, wie Sie das spaCy NER Modell innerhalb von SageMaker 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 und den ECR-URI für das Container-Image definieren. 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 Amazon EC2 EC2-Instance-Typen.

Im vorherigen Codebeispiel verweist The Image key auf den 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 Hosting für Inferenzen zu verwenden, müssen Sie auch einen Endpunkt konfigurieren und erstellen. SageMaker wird diesen Endpunkt für Inferenzen verwenden. Das folgende Konfigurationsbeispiel zeigt, wie ein Endpunkt mit dem Instanztyp und Modellnamen generiert und konfiguriert wird, 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 SageMaker Amazon-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 Kellner wartet darauf, dass der Endpunkt in Betrieb genommen wird.
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. Anschließend verwendet der SageMaker 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.

Problembehandlung bei Ihrer Container-Bereitstellung

Wenn Ihr Endpunkt nicht bereitgestellt wurde, überprüfen Sie die Amazon CloudWatch Events-Protokolle wie folgt:

Wählen Sie im Navigationsbereich der https://console.aws.amazon.com/sagemaker/ SageMaker -Konsole die Option Inference aus.
Wählen Sie unter Inferenz die Option Endpunkte aus.
Suchen Sie Ihren Endpunkt unter Name und klicken Sie auf den Namen des Endpunkts. In diesem Beispiel würde der Name der Namenskonvention folgenspacy-ner-configYYYY-MM-DD-HH-MM-SS.
Wählen Sie unter Endpunktzusammenfassung den Link unter Container-Logs modellieren aus.
Wählen Sie im Feld Protokollstreams den neuesten Protokollstream aus.

Verwenden Sie die folgende Liste, um Fehler bei der Bereitstellung Ihres Endpunkts zu beheben. Wenn Sie weitere Unterstützung benötigen, wenden Sie sich an den AWS Support oder die AWS Entwicklerforen von Amazon SageMaker.

Topics

Fehler beim Namen
Unzureichende Quote
Upstream-Fehler beim Timeout

Fehler beim Namen

Falls in den Protokollen angegebenNameError: name 'null' is not defined, stellen Sie sicher, dass Ihre Skripts nicht in einem Notizbuch mit der Endung erstellt .ipnyb und dann in einen anderen Dateinamen umbenannt wurden, z. Dockerfile B. Wenn Sie ein Notizbuch erstellen, kann das Formatieren von Zeichen die Bereitstellung Ihres Endpunkts verhindern. Wenn Sie diesen Fehler erhalten und Ihre Skripts ändern, um ihn zu beheben, müssen Sie möglicherweise Ihren Kernel neu starten, damit die Änderungen wirksam werden.

Unzureichende Quote

Wenn Sie eine ResourceLimitExceeded Fehlermeldung erhalten, müssen Sie wie folgt ein zusätzliches Kontingent beantragen:

Eine Erhöhung der AWS Service Quotas beantragen

Rufen Sie den Instanznamen, das aktuelle Kontingent und das erforderliche Kontingent anhand der Fehlermeldung auf dem Bildschirm ab. Zum Beispiel im folgenden Beispielfehler:
- Der Instanzname istml.c5d.18xlarge.
- Das aktuelle Kontingent aus der folgenden Zahl current utilization ist1 instances.
- Das zusätzlich erforderliche Kontingent aus der folgenden Zahl request delta lautet1 instances.
Der Beispielfehler folgt:
```
ResourceLimitExceeded: An error occurred (ResourceLimitExceeded) 
when calling the CreateEndpoint operation: The account-level service limit
'ml.c5d.18xlarge for endpoint usage' is 1 Instances, with current utilization 
of 1 Instances and a request delta of 1 Instances. Please use AWS Service Quotas
to request an increase for this quota. If AWS Service Quotas is not available, 
contact AWS support to request an increase for this quota.
```
Melden Sie sich bei der Service Quotas Quotas-Konsole an AWS Management Console und öffnen Sie sie.
Geben Sie im Navigationsbereich unter Kontingente verwalten Amazon ein SageMaker.
Wählen Sie Kontingente anzeigen aus.
Geben Sie in der Suchleiste unter Dienstkontingente den Namen der Instanz aus Schritt 1 ein. Verwenden Sie beispielsweise die Informationen, die in der Fehlermeldung aus Schritt 1 enthalten sind, und geben Sie einml.c5d.18xlarge.
Wählen Sie den Kontingentnamen, der neben Ihrem Instanznamen angezeigt wird und mit for endpoint usage endet. Wählen Sie beispielsweise anhand der in der Fehlermeldung aus Schritt 1 enthaltenen Informationen die Option ml.g5.12xlarge Endpunktnutzung aus.
Wählen Sie Erhöhung auf Kontoebene beantragen aus.
Geben Sie unter Kontingentwert erhöhen das erforderliche Kontingent aus den Informationen in der Fehlermeldung aus Schritt 1 ein. Geben Sie die Summe von current utilization und einrequest delta. Im vorherigen Beispiel current utilization ist der Fehler „ist1 Instances“ und „request deltaist1 Instances“. Fordern Sie in diesem Beispiel ein Kontingent von 2 an, um das erforderliche Kontingent bereitzustellen.
Wählen Sie Request (Anfrage).
Wählen Sie im Navigationsbereich die Option Kontingentanforderungsverlauf aus.
Wenn sich der Status von Ausstehend in Genehmigt ändert, führen Sie Ihren Job erneut aus. Möglicherweise müssen Sie Ihren Browser aktualisieren, um die Änderung zu sehen.

Weitere Informationen zur Beantragung einer Erhöhung Ihres Kontingents finden Sie unter Eine Erhöhung Ihres Kontingents beantragen.

Upstream-Fehler beim Timeout

Wenn Sie eine upstream timed out (110: Connection timed out) Fehlermeldung erhalten, können Sie Folgendes versuchen:

Reduzieren Sie die Latenz des Containers oder erhöhen Sie das Timeout-Limit des Containers. SageMaker erfordert, dass Ihr Container innerhalb von 60 Sekunden auf eine Anfrage reagiert.
Erhöhen Sie die Zeit, bis Ihr Webserver auf eine Antwort vom Modell wartet.

Weitere Informationen zu Timeoutfehlern finden Sie unter Wie kann ich den SageMaker Amazon-Inferenzfehler „Upstream timed out (110: Connection timed out) while reading Response Header from Upstream“ beheben?

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 ein Docker-Verzeichnis, für die eine Authentifizierung für das Training erforderlich ist

Erstellen Sie einen Container mit Ihren eigenen Algorithmen und Modellen

Anpassung Ihres eigenen Inferenz-Containers

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.

Problembehandlung bei Ihrer Container-Bereitstellung

Fehler beim Namen

Unzureichende Quote

Eine Erhöhung der AWS Service Quotas beantragen

Upstream-Fehler beim Timeout