Anpassen Ihres eigenen Inferenzcontainers für Amazon SageMaker AI

Anpassen Ihres Inferenzcontainers

Gehen Sie wie folgt vor, um Ihren eigenen Inferenzcontainer an das Hosting auf SageMaker AI anzupassen. Das in den folgenden Schritten gezeigte Beispiel verwendet ein vortrainiertes Named Entity Recognition (NER)-Modell, das die Natural Language Processing (NLP)-Bibliothek spaCy für Python und Folgendes verwendet:

Wenn Sie dieses Beispiel für Ihren Anwendungsfall anpassen, müssen Sie eine Dockerfile und Inferenzskripte verwenden, die für die Bereitstellung und Ausführung Ihres Modells erforderlich sind.

1. Erstellen Sie eine JupyterLab-Umgebung mit Amazon SageMaker Studio Classic (optional).

   Sie können jedes Notebook verwenden, um Skripte auszuführen, um Ihren Inferenzcontainer an das Hosting auf SageMaker AI anzupassen. Dieses Beispiel zeigt Ihnen, wie Sie eine JupyterLab-Umgebung 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.

2. Laden Sie eine Docker-Datei und Inferenzskripte hoch.

   1. Erstellen Sie einen neuen Ordner in Ihrem Home-Verzeichnis. Wenn Sie JupyterLab verwenden, wählen Sie in der oberen linken Ecke das Symbol Neuer Ordner und geben Sie einen Ordnernamen ein, in dem Ihre Dockerfile abgelegt werden soll. In diesem Beispiel heißt der Ordner docker_test_folder.

   2. Laden Sie eine Dockerfile-Textdatei in Ihren neuen Ordner hoch. Im Folgenden finden Sie eine Beispiel-Dockerfile, die 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 verhindert die Umgebungsvariable PYTHONUNBUFFERED, dass Pythonden Standardausgabestream puffert, was eine schnellere Übermittlung von Protokollen an den Benutzer ermöglicht. Die Umgebungsvariable PYTHONDONTWRITEBYTECODE verhindert, dass Python kompilierte .pyc-Bytecode-Dateien schreibt, die für diesen Anwendungsfall unnötig sind. Die Umgebungsvariable PATH wird verwendet, um den Speicherort der serve- und train-Programme und zu identifizieren, wenn der Container aufgerufen wird.

   3. Erstellen Sie in Ihrem neuen Ordner ein neues Verzeichnis, das Skripte für Ihr Modell enthält. In diesem Beispiel wird ein Verzeichnis namens NER verwendet, das die folgenden Skripte 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 Ausführung 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.

   4. Laden Sie ein Skript hoch, um Ihr Modell für Inferenzen verfügbar zu machen. Im Folgenden finden Sie ein Beispielskript mit dem Namen predictor.py, das Flask zur Bereitstellung der /invocations- und /ping-Endpunkte und verwendet:

      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 den Statuscode 200 zurück, wenn das Modell korrekt geladen wurde, und 404, wenn das Modell falsch geladen wurde. Der /invocations-Endpunkt verarbeitet eine in JSON formatierte Anforderung, 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 Zustandsanfragen finden Sie unter So sollte Ihr Container auf Zustandsprüfungsanforderungen (Ping-Anforderungen) reagieren.

   5. Laden Sie ein Skript hoch, um einen Inferenzserver zu starten. Das folgende Skriptbeispiel ruft serve auf und verwendet dabei 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 die Signal-Handler-Funktion sigterm_handler, die Nginx- und Gunicorn-Unterprozesse herunterfährt, wenn sie ein SIGTERM-Signal empfängt. Eine start_server-Funktion startet den Signal-Handler, startet und überwacht die Nginx- und Gunicorn-Unterprozesse und erfasst Protokollstreams.

   6. Laden Sie ein Skript hoch, um Ihren Webserver zu konfigurieren. Das folgende Skriptbeispiel namens nginx.conf konfiguriert einen Nginx-Webserver, der Gunicorn als Anwendungsserver verwendet, um Ihr Modell als Inferenz auszuführen:

      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 ausgeführt zu werden, legt den Speicherort für die error_log-Erfassung fest und definiert upstream als Socket-Sock des Gunicorn-Servers. Der Server konfiguriert den Serverblock so, dass er den Port 8080 abhört, und legt Grenzwerte für die Textgröße der Client-Anfrage und die Timeout-Werte fest. Der Serverblock leitet Anforderungen, die entweder /invocations- oder /ping-Pfade enthalten, an den Gunicorn server http://gunicorn weiter und gibt bei anderen Pfaden einen 404-Fehler zurück.

   7. Laden Sie alle anderen Skripte hoch, die für Ihr Modell erforderlich sind. In diesem Beispiel ist das folgende Beispielskript namens wsgi.py erforderlich, damit Gunicorn Ihre Anwendung findet:

      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

   Unter dem Ordner docker_test_folder sollte Ihre Verzeichnisstruktur eine Dockerfile und den Ordner NER enthalten. Der NER-Ordner sollte wie folgt die Dateien nginx.conf, predictor.py, serve und wsgi.py enthalten:

   

3. Erstellen Sie Ihren eigenen Container.

   Erstellen Sie unter dem Ordner docker_test_folder Ihren Docker-Container. Der folgende Beispielbefehl erstellt den Docker-Container, der in Ihrer Dockerfile konfiguriert ist:

   ! docker build -t byo-container-test .

   Der vorherige Befehl erstellt einen Container namens byo-container-test im aktuellen Arbeitsverzeichnis. Weitere Informationen zu den Docker-Build-Parametern finden Sie unter Build arguments.

   Anmerkung

   Wenn Sie die folgende Fehlermeldung erhalten, dass Docker die Dockerfile nicht finden kann, stellen Sie sicher, dass die Dockerfile den richtigen Namen hat und im Verzeichnis gespeichert wurde.

   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 im aktuellen Verzeichnis spezifisch nach einer Datei namens Dockerfile ohne Erweiterung. Wenn Sie sie anders benannt haben, können Sie den Dateinamen manuell mit dem -f-Flag übergeben. Wenn Sie Ihre Dockerfile beispielsweise Dockerfile-text.txt genannt haben, erstellen Sie wie folgt Ihren Docker-Container mit dem -f-Flag, gefolgt von Ihrer Datei:

   ! docker build -t byo-container-test -f Dockerfile-text.txt .

4. Verschieben Sie Ihr Docker-Image in ein Amazon Elastic Container Registry (Amazon ECR).

   Übertragen Sie Ihr Docker-Image in einer Notebook-Zelle auf eine ECR. Das folgende Codebeispiel zeigt Ihnen, wie Sie Ihren Container lokal erstellen, sich anmelden und ihn an eine 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 an eine ECR zu übertragen:

   1. Verwenden Sie als Algorithmusnamen sm-pretrained-spacy.

   2. Machen Sie die serve-Datei im NER-Ordner ausführbar.

   3. Legen Sie die AWS-Region fest.

   4. Erstellen Sie eine ECR, falls noch nicht vorhanden.

   5. Melden Sie sich bei der ECR an.

   6. Erstellen Sie den Docker-Container lokal.

   7. Verschieben Sie das Docker-Image in die ECR.

5. Richten Sie den SageMaker-AI-Client ein.

   Wenn Sie die Hosting-Dienste von SageMaker AI für Inferenzen verwenden möchten, müssen Sie ein Modell, eine Endpunktkonfiguration und einen Endpunkt erstellen. Um Inferenzen von Ihrem Endpunkt abzurufen, können Sie den boto3-Laufzeit-Client von SageMaker AI verwenden, um Ihren Endpunkt aufzurufen. Der folgende Code zeigt Ihnen, wie Sie sowohl den SageMaker-AI-Client als auch den SageMaker-Laufzeit-Client mit dem boto3-Client von SageMaker AI 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-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 unter Verwaltete AWS-Richtlinien für Amazon SageMaker AI.

6. Erstellen Sie Ihr Modell.

   Wenn Sie die Hosting-Dienste von SageMaker AI für Inferenzen verwenden möchten, müssen Sie ein Modell in SageMaker AI erstellen. Das folgende Codebeispiel zeigt Ihnen, wie Sie das spaCy-NER-Modell in 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, wie Sie mit dem s3_bucket eine model_url definieren, wenn Sie den Amazon-S3-Bucket aus den Kommentaren in Schritt 5 verwenden. Außerdem wird der ECR-URI für das Container-Image definiert. In den vorherigen Codebeispielen wird ml.c5d.18xlarge als Instance-Typ definiert. Sie können auch einen anderen Instance-Typ auswählen. Weitere Informationen über verfügbare Instance-Typen finden Sie unter Amazon-EC2-Instance-Typen.

   Im vorherigen Codebeispiel verweist der Image-Schlüssel 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.

   Hier 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

7. 1. Einen Endpunkt konfigurieren und erstellen

      Um SageMaker-AI-Hosting für Inferenzen zu verwenden, müssen Sie auch einen Endpunkt konfigurieren und erstellen. SageMaker AI verwendet diesen Endpunkt für Inferenzen. Das folgende Konfigurationsbeispiel zeigt, wie Sie einen Endpunkt mit dem zuvor definierten Instance-Typ 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'])

      Im vorherigen Konfigurationsbeispiel verknüpft create_endpoint_config_response den model_name mit einem eindeutigen Endpunktkonfigurationsnamen endpoint_config_name, der mit einem Zeitstempel erstellt wurde.

      Hier 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-Endpunkt in den Status „Fehlgeschlagen“, wenn ich einen Endpunkt erstelle oder aktualisiere?

   2. Erstellen Sie einen Endpunkt und warten Sie, bis der Endpunkt betriebsbereit 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 gibt den Amazon-Ressourcennamen des Endpunkts aus. Die describe_endpoint-Methode gibt Informationen über den Endpunkt und seinen Status zurück. Ein SageMaker AI Waiter wartet darauf, dass der Endpunkt betriebsbereit ist.

8. Testen Sie Ihren Endpunkt.

   Sobald Ihr Endpunkt in Betrieb ist, senden Sie eine Aufrufanfrage an Ihren Endpunkt. Das folgende Codebeispiel zeigt, wie man eine Testanforderung an Ihren Endpunkt sendet.

   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 serialisiert die Methode json.dumps den request_body in eine in JSON formatierte Zeichenfolge und speichert sie in der variablen Nutzlast. Anschließend verwendet der Laufzeit-Client von SageMaker AI die Methode Endpunkt 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']]

9. Löschen Sie Ihren Endpunkt.

   Nachdem Sie Ihre Aufrufe abgeschlossen haben, löschen Sie Ihren Endpunkt, um Ressourcen zu schonen. Das folgende Codebeispiel zeigt, 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 Notebook, das den Code in diesem Beispiel enthält, finden Sie unter BYOC-Single-Model.