Terjemahan disediakan oleh mesin penerjemah. Jika konten terjemahan yang diberikan bertentangan dengan versi bahasa Inggris aslinya, utamakan versi bahasa Inggris.
# Sesuaikan wadah inferensi Anda sendiri untuk Amazon AI SageMaker
Jika Anda tidak dapat menggunakan gambar apa pun yang tercantum di [Gambar SageMaker AI Docker yang sudah dibuat sebelumnya](docker-containers-prebuilt.md) Amazon SageMaker AI untuk kasus penggunaan Anda, Anda dapat membuat wadah Docker Anda sendiri dan menggunakannya di dalam SageMaker AI untuk pelatihan dan inferensi. Agar kompatibel dengan SageMaker AI, wadah Anda harus memiliki karakteristik sebagai berikut:
+ Container Anda harus memiliki daftar server web di port`8080`.
+ Container Anda harus menerima `POST` permintaan ke titik akhir `/invocations` dan `/ping` real-time. Permintaan yang Anda kirim ke titik akhir ini harus dikembalikan dengan 60 detik untuk respons reguler dan 8 menit untuk respons streaming, dan memiliki ukuran maksimum 25 MB.
Untuk informasi selengkapnya dan contoh cara membuat wadah Docker Anda sendiri untuk pelatihan dan inferensi dengan SageMaker AI, lihat [Membangun wadah algoritme Anda sendiri](https://github.com/aws/amazon-sagemaker-examples/blob/main/advanced_functionality/scikit_bring_your_own/scikit_bring_your_own.ipynb).
Panduan berikut menunjukkan cara menggunakan `JupyterLab` ruang dengan Amazon SageMaker Studio Classic untuk mengadaptasi wadah inferensi agar berfungsi dengan hosting SageMaker AI. Contohnya menggunakan server NGINX web, Gunicorn sebagai antarmuka gateway server Python web, dan Flask sebagai kerangka kerja aplikasi web. Anda dapat menggunakan aplikasi yang berbeda untuk menyesuaikan wadah Anda selama memenuhi persyaratan yang tercantum sebelumnya. Untuk informasi selengkapnya tentang menggunakan kode inferensi Anda sendiri, lihat[Kode Inferensi Kustom dengan Layanan Hosting](your-algorithms-inference-code.md).
**Sesuaikan wadah inferensi Anda**
Gunakan langkah-langkah berikut untuk menyesuaikan wadah inferensi Anda sendiri agar berfungsi dengan hosting SageMaker AI. Contoh yang ditunjukkan dalam langkah-langkah berikut menggunakan [model Dinamakan Entity Recognition (NER)](https://spacy.io/universe/project/video-spacys-ner-model-alt) pra-terlatih yang menggunakan pustaka pemrosesan bahasa alami (NLP) [SPacy](https://spacy.io/) untuk `Python` dan berikut ini:
+ A Dockerfile untuk membangun wadah yang berisi NER model.
+ Skrip inferensi untuk melayani model. NER
Jika Anda mengadaptasi contoh ini untuk kasus penggunaan Anda, Anda harus menggunakan skrip a Dockerfile dan inferensi yang diperlukan untuk menerapkan dan melayani model Anda.
1. Buat JupyterLab ruang dengan Amazon SageMaker Studio Classic (opsional).
Anda dapat menggunakan notebook apa pun untuk menjalankan skrip guna menyesuaikan wadah inferensi Anda dengan hosting SageMaker AI. Contoh ini menunjukkan kepada Anda cara menggunakan JupyterLab ruang dalam Amazon SageMaker Studio Classic untuk meluncurkan JupyterLab aplikasi yang dilengkapi dengan gambar Distribusi SageMaker AI. Untuk informasi selengkapnya, lihat [SageMaker JupyterLab](studio-updated-jl.md).
1. Unggah Docker file dan skrip inferensi.
1. Buat folder baru di direktori home Anda. Jika Anda menggunakanJupyterLab, di pojok kiri atas, pilih ikon **Folder Baru**, dan masukkan nama folder untuk memuat. Dockerfile Dalam contoh ini, folder dipanggil`docker_test_folder`.
1. Unggah file Dockerfile teks ke folder baru Anda. Berikut ini adalah contoh Dockerfile yang membuat Docker wadah dengan [model Named Entity Recognition (NER)](https://spacy.io/universe/project/video-spacys-ner-model) yang telah dilatih sebelumnya dari [SPacy](https://spacy.io/), aplikasi dan variabel lingkungan yang diperlukan untuk menjalankan contoh:
```
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
```
Dalam contoh kode sebelumnya, variabel lingkungan `PYTHONUNBUFFERED` Python mencegah buffering aliran output standar, yang memungkinkan pengiriman log lebih cepat ke pengguna. Variabel lingkungan `PYTHONDONTWRITEBYTECODE` Python mencegah penulisan `.pyc` file bytecode yang dikompilasi, yang tidak diperlukan untuk kasus penggunaan ini. Variabel lingkungan `PATH` digunakan untuk mengidentifikasi lokasi `train` dan `serve` program saat wadah dipanggil.
1. Buat direktori baru di dalam folder baru Anda untuk berisi skrip untuk melayani model Anda. Contoh ini menggunakan direktori yang disebut`NER`, yang berisi skrip berikut yang diperlukan untuk menjalankan contoh ini:
+ `predictor.py`— Python Skrip yang berisi logika untuk memuat dan melakukan inferensi dengan model Anda.
+ `nginx.conf`— Skrip untuk mengkonfigurasi server web.
+ `serve`— Skrip yang memulai server inferensi.
+ `wsgi.py`— Naskah pembantu untuk melayani model.
**penting**
Jika Anda menyalin skrip inferensi ke buku catatan yang diakhiri `.ipynb` dan mengganti namanya, skrip Anda mungkin berisi karakter pemformatan yang akan mencegah titik akhir Anda diterapkan. Sebagai gantinya, buat file teks dan ganti namanya.
1. Unggah skrip untuk membuat model Anda tersedia untuk inferensi. Berikut ini adalah contoh script `predictor.py` yang disebut yang menggunakan Flask untuk menyediakan `/ping` dan `/invocations` endpoint:
```
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')
```
`/ping`Titik akhir dalam contoh skrip sebelumnya mengembalikan kode status `200` jika model dimuat dengan benar, dan `404` jika model dimuat secara tidak benar. `/invocations`Titik akhir memproses permintaan yang diformatJSON, mengekstrak bidang input, dan menggunakan NER model untuk mengidentifikasi dan menyimpan entitas dalam entitas variabel. FlaskAplikasi mengembalikan respon yang berisi entitas ini. Untuk informasi lebih lanjut tentang permintaan kesehatan yang diperlukan ini, lihat[Bagaimana Kontainer Anda Harus Menanggapi Permintaan Pemeriksaan Kesehatan (Ping)](your-algorithms-inference-code.md#your-algorithms-inference-algo-ping-requests).
1. Unggah skrip untuk memulai server inferensi. Contoh skrip berikut memanggil `serve` menggunakan Gunicorn sebagai server aplikasi, dan Nginx sebagai server web:
```
#!/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()
```
Contoh skrip sebelumnya mendefinisikan fungsi penangan sinyal`sigterm_handler`, yang mematikan Nginx dan Gunicorn sub-proses ketika menerima sinyal. `SIGTERM` `start_server`Fungsi memulai penangan sinyal, memulai dan memantau dan Gunicorn sub-proses, Nginx dan menangkap aliran log.
1. Unggah skrip untuk mengkonfigurasi server web Anda. Contoh skrip berikut disebut`nginx.conf`, mengkonfigurasi server Nginx web menggunakan Gunicorn sebagai server aplikasi untuk melayani model Anda untuk inferensi:
```
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 "{}";
}
}
}
```
Contoh skrip sebelumnya mengkonfigurasi Nginx untuk berjalan di latar depan, menetapkan lokasi untuk menangkap`error_log`, dan mendefinisikan `upstream` sebagai kaus kaki soket Gunicorn server. Server mengkonfigurasi blok server untuk mendengarkan pada port`8080`, menetapkan batas pada ukuran badan permintaan klien dan nilai batas waktu. Server memblokir, meneruskan permintaan yang berisi salah satu `/ping` atau `/invocations` jalur ke Gunicorn`server http://gunicorn`, dan mengembalikan `404` kesalahan untuk jalur lain.
1. Unggah skrip lain yang diperlukan untuk melayani model Anda. Contoh ini memerlukan contoh script berikut yang dipanggil `wsgi.py` untuk membantu Gunicorn menemukan aplikasi Anda:
```
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
```
Dari folder`docker_test_folder`, struktur direktori Anda harus berisi Dockerfile dan folderNER. NERFolder harus berisi file`nginx.conf`,`predictor.py`,`serve`, dan `wsgi.py` sebagai berikut:
1. Bangun wadah Anda sendiri.
Dari folder`docker_test_folder`, buat Docker wadah Anda. Perintah contoh berikut akan membangun Docker wadah yang dikonfigurasi dalam AndaDockerfile:
```
! docker build -t byo-container-test .
```
Perintah sebelumnya akan membangun wadah yang disebut `byo-container-test` di direktori kerja saat ini. Untuk informasi selengkapnya tentang parameter Docker build, lihat [Argumen build](https://docs.docker.com/build/guide/build-args/).
**catatan**
Jika Anda mendapatkan pesan kesalahan berikut yang Docker tidak dapat menemukanDockerfile, pastikan Dockerfile memiliki nama yang benar dan telah disimpan ke direktori.
```
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
```
Dockermencari file yang secara khusus dipanggil Dockerfile tanpa ekstensi apa pun dalam direktori saat ini. Jika Anda menamakannya sesuatu yang lain, Anda dapat meneruskan nama file secara manual dengan flag -f. Misalnya, jika Anda menamai Dockerfile asDockerfile-text.txt, buat Docker penampung Anda menggunakan `-f` bendera yang diikuti oleh file Anda sebagai berikut:
```
! docker build -t byo-container-test -f Dockerfile-text.txt .
```
1. Dorong Docker Gambar Anda ke Amazon Elastic Container Registry (Amazon ECR)
Di sel notebook, dorong Docker gambar Anda ke ECR. Contoh kode berikut menunjukkan cara membangun container Anda secara lokal, login dan mendorongnya ke ECR:
```
%%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}
```
Dalam contoh sebelumnya menunjukkan bagaimana melakukan langkah-langkah berikut yang diperlukan untuk mendorong contoh wadah Docker ke ECR:
1. Tentukan nama algoritma sebagai`sm-pretrained-spacy`.
1. Buat `serve` file di dalam NER folder dapat dieksekusi.
1. Mengatur AWS Region.
1. Buat ECR jika belum ada.
1. Login ke ECR.
1. Bangun Docker wadah secara lokal.
1. Dorong Docker gambar ke ECR.
1. Siapkan klien SageMaker AI
Jika Anda ingin menggunakan layanan hosting SageMaker AI untuk inferensi, Anda harus [membuat model](https://boto3.amazonaws.com/v1/documentation/api/latest/reference/services/sagemaker/client/create_model.html), membuat [konfigurasi titik akhir, dan [membuat](https://boto3.amazonaws.com/v1/documentation/api/latest/reference/services/sagemaker/client/create_endpoint.html#) titik akhir](https://boto3.amazonaws.com/v1/documentation/api/latest/reference/services/sagemaker/client/create_endpoint_config.html#). Untuk mendapatkan kesimpulan dari titik akhir Anda, Anda dapat menggunakan klien SageMaker AI boto3 Runtime untuk memanggil titik akhir Anda. Kode berikut menunjukkan kepada Anda cara mengatur klien SageMaker AI dan klien SageMaker Runtime menggunakan klien [SageMaker AI boto3](https://boto3.amazonaws.com/v1/documentation/api/latest/reference/services/sagemaker.html):
```
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 = ''
role = get_execution_role()
```
Dalam contoh kode sebelumnya, bucket Amazon S3 tidak digunakan, tetapi dimasukkan sebagai komentar untuk menunjukkan cara menyimpan artefak model.
Jika Anda menerima kesalahan izin setelah menjalankan contoh kode sebelumnya, Anda mungkin perlu menambahkan izin ke peran IAM Anda. Untuk informasi selengkapnya tentang peran IAM, lihat[Manajer SageMaker Peran Amazon](role-manager.md). Untuk informasi selengkapnya tentang menambahkan izin ke peran Anda saat ini, lihat[AWS kebijakan terkelola untuk Amazon SageMaker AI](security-iam-awsmanpol.md).
1. Buat model Anda.
Jika Anda ingin menggunakan layanan hosting SageMaker AI untuk inferensi, Anda harus membuat model di SageMaker AI. Contoh kode berikut menunjukkan cara membuat spaCy NER model di dalam SageMaker AI:
```
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'])
```
Contoh kode sebelumnya menunjukkan cara mendefinisikan penggunaan `s3_bucket` jika Anda `model_url` menggunakan bucket Amazon S3 dari komentar di Langkah 5, dan mendefinisikan URI ECR untuk image container. Contoh kode sebelumnya mendefinisikan `ml.c5d.18xlarge` sebagai tipe instance. Anda juga dapat memilih jenis instance yang berbeda. Untuk informasi selengkapnya tentang jenis instans yang tersedia, lihat jenis [instans Amazon EC2](https://aws.amazon.com/ec2/instance-types/).
Dalam contoh kode sebelumnya, Poin `Image` utama ke URI gambar kontainer. `create_model_response`Definisi menggunakan `create_model method` untuk membuat model, dan mengembalikan nama model, peran dan daftar yang berisi informasi kontainer.
Contoh output dari script sebelumnya berikut:
```
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.
1.
**Konfigurasikan dan buat titik akhir**
Untuk menggunakan hosting SageMaker AI untuk inferensi, Anda juga harus mengonfigurasi dan membuat titik akhir. SageMaker AI akan menggunakan titik akhir ini untuk inferensi. Contoh konfigurasi berikut menunjukkan cara membuat dan mengonfigurasi titik akhir dengan jenis instans dan nama model yang Anda tentukan sebelumnya:
```
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'])
```
Dalam contoh konfigurasi sebelumnya, `create_endpoint_config_response` mengaitkan `model_name` dengan nama konfigurasi titik akhir unik `endpoint_config_name` yang dibuat dengan stempel waktu.
Contoh output dari script sebelumnya berikut:
```
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
```
Untuk informasi selengkapnya tentang kesalahan titik akhir, lihat [Mengapa titik akhir Amazon SageMaker AI saya masuk ke status gagal saat saya membuat atau memperbarui](https://repost.aws/knowledge-center/sagemaker-endpoint-creation-fail) titik akhir?
1.
**Buat titik akhir dan tunggu titik akhir dalam layanan.**
Contoh kode berikut membuat titik akhir menggunakan konfigurasi dari contoh konfigurasi sebelumnya dan menerapkan model:
```
%%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)
```
Dalam contoh kode sebelumnya, `create_endpoint` metode membuat titik akhir dengan nama titik akhir yang dihasilkan yang dibuat dalam contoh kode sebelumnya, dan mencetak Nama Sumber Daya Amazon dari titik akhir. `describe_endpoint`Metode mengembalikan informasi tentang endpoint dan statusnya. Seorang pelayan SageMaker AI menunggu titik akhir dalam pelayanan.
1. Uji titik akhir Anda.
Setelah titik akhir Anda dalam layanan, kirim [permintaan pemanggilan](https://boto3.amazonaws.com/v1/documentation/api/1.9.42/reference/services/sagemaker-runtime.html#SageMakerRuntime.Client.invoke_endpoint) ke titik akhir Anda. Contoh kode berikut menunjukkan cara mengirim permintaan pengujian ke titik akhir Anda:
```
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
```
Dalam contoh kode sebelumnya, metode ini `json.dumps` membuat serial `request_body` menjadi string yang diformat dalam JSON dan menyimpannya dalam payload variabel. Kemudian klien SageMaker AI Runtime menggunakan metode [titik akhir pemanggilan untuk mengirim muatan ke titik akhir](https://boto3.amazonaws.com/v1/documentation/api/latest/reference/services/sagemaker-runtime/client/invoke_endpoint.html) Anda. Hasilnya berisi respons dari titik akhir Anda setelah mengekstraksi bidang output.
Contoh kode sebelumnya harus mengembalikan output berikut:
```
[['NER', 'ORG'],
['America', 'GPE'],
['Amazon', 'ORG'],
['Microsoft', 'ORG'],
['Seattle', 'GPE']]
```
1. Hapus titik akhir Anda
Setelah Anda menyelesaikan pemanggilan, hapus titik akhir Anda untuk menghemat sumber daya. Contoh kode berikut menunjukkan cara menghapus titik akhir Anda:
```
sm_client.delete_endpoint(EndpointName=endpoint_name)
sm_client.delete_endpoint_config(EndpointConfigName=endpoint_config_name)
sm_client.delete_model(ModelName=model_name)
```
Untuk buku catatan lengkap yang berisi kode dalam contoh ini, lihat [BYOC-Single-model](https://github.com/aws-samples/sagemaker-hosting/tree/main/Bring-Your-Own-Container/BYOC-Single-Model).