Mengadaptasi Wadah Inferensi Anda Sendiri

Jika Anda tidak dapat menggunakan gambar apa pun yang tercantum di Gunakan gambar SageMaker Docker yang dibuat sebelumnya Amazon SageMaker untuk kasus penggunaan Anda, Anda dapat membuat wadah Docker Anda sendiri dan menggunakannya di dalam SageMaker untuk pelatihan dan inferensi. Agar kompatibel SageMaker, wadah Anda harus memiliki karakteristik sebagai berikut:

Container Anda harus memiliki daftar server web di port8080.
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 dan memiliki ukuran maksimum 6 MB.

Untuk informasi selengkapnya dan contoh cara membuat wadah Docker Anda sendiri untuk pelatihan dan inferensi SageMaker, lihat Membangun wadah algoritme Anda sendiri.

Panduan berikut menunjukkan cara menggunakan JupyterLab ruang dengan Amazon SageMaker Studio Classic untuk mengadaptasi wadah inferensi agar berfungsi dengan SageMaker hosting. 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, lihatGunakan Kode Inferensi Anda Sendiri dengan Layanan Hosting.

Sesuaikan wadah inferensi Anda

Gunakan langkah-langkah berikut untuk menyesuaikan wadah inferensi Anda sendiri untuk bekerja dengan SageMaker hosting. Contoh yang ditunjukkan dalam langkah-langkah berikut menggunakan model Dinamakan Entity Recognition (NER) pra-terlatih yang menggunakan pustaka pemrosesan bahasa alami (NLP) SPacy 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.

Buat JupyterLab ruang dengan Amazon SageMaker Studio Classic (opsional).

Anda dapat menggunakan notebook apa pun untuk menjalankan skrip untuk menyesuaikan wadah inferensi Anda dengan SageMaker hosting. Contoh ini menunjukkan kepada Anda cara menggunakan JupyterLab ruang dalam Amazon SageMaker Studio Classic untuk meluncurkan JupyterLab aplikasi yang dilengkapi dengan gambar SageMaker Distribusi. Untuk informasi selengkapnya, lihat SageMaker JupyterLab.

Unggah Docker file dan skrip inferensi.

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 dipanggildocker_test_folder.
Unggah file Dockerfile teks ke folder baru Anda. Berikut ini adalah contoh Dockerfile yang membuat Docker wadah dengan model Named Entity Recognition (NER) yang telah dilatih sebelumnya dari SPacy, 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.
Buat direktori baru di dalam folder baru Anda untuk berisi skrip untuk melayani model Anda. Contoh ini menggunakan direktori yang disebutNER, 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.

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')

/pingTitik akhir dalam contoh skrip sebelumnya mengembalikan kode status 200 jika model dimuat dengan benar, dan 404 jika model dimuat dengan tidak benar. /invocationsTitik 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, lihatBagaimana Kontainer Anda Harus Menanggapi Permintaan Pemeriksaan Kesehatan (Ping).

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 sinyalsigterm_handler, yang mematikan Nginx dan Gunicorn sub-proses ketika menerima sinyal. SIGTERM start_serverFungsi memulai penangan sinyal, memulai dan memantau dan Gunicorn sub-proses, Nginx dan menangkap aliran log.

Unggah skrip untuk mengkonfigurasi server web Anda. Contoh skrip berikut disebutnginx.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 menangkaperror_log, dan mendefinisikan upstream sebagai kaus kaki soket Gunicorn server. Server mengkonfigurasi blok server untuk mendengarkan pada port8080, menetapkan batas pada ukuran badan permintaan klien dan nilai batas waktu. Server memblokir, meneruskan permintaan yang berisi salah satu /ping atau /invocations jalur ke Gunicornserver http://gunicorn, dan mengembalikan 404 kesalahan untuk jalur lain.

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 folderdocker_test_folder, struktur direktori Anda harus berisi Dockerfile dan folderNER. NERFolder harus berisi filenginx.conf,predictor.py,serve, dan wsgi.py sebagai berikut:

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

Bangun wadah Anda sendiri.

Dari folderdocker_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.
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 .
```

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:

Tentukan nama algoritma sebagaism-pretrained-spacy.
Buat serve file di dalam NER folder dapat dieksekusi.
MengaturWilayah AWS.
Buat ECR jika belum ada.
Login ke ECR.
Bangun Docker wadah secara lokal.
Dorong Docker gambar ke ECR.

Siapkan SageMaker klien

Jika Anda ingin menggunakan layanan SageMaker hosting untuk inferensi, Anda harus membuat model, membuat konfigurasi titik akhir, dan membuat titik akhir. Untuk mendapatkan kesimpulan dari titik akhir Anda, Anda dapat menggunakan klien SageMaker boto3 Runtime untuk memanggil titik akhir Anda. Kode berikut menunjukkan cara mengatur SageMaker klien dan klien SageMaker Runtime menggunakan klien SageMaker boto3:
```
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()
```
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, lihatManajer SageMaker Peran Amazon. Untuk informasi selengkapnya tentang menambahkan izin ke peran Anda saat ini, lihatAWSKebijakan Terkelola untuk Amazon SageMaker.

Buat model Anda.

Jika Anda ingin menggunakan layanan SageMaker hosting untuk inferensi, Anda harus membuat model di SageMaker. Contoh kode berikut menunjukkan cara membuat spaCy NER model di dalam SageMaker:


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.

Dalam contoh kode sebelumnya, Poin Image utama ke URI gambar kontainer. create_model_responseDefinisi 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

Konfigurasikan dan buat titik akhir

Untuk menggunakan SageMaker hosting untuk inferensi, Anda juga harus mengkonfigurasi dan membuat titik akhir. SageMaker 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 SageMaker titik akhir Amazon saya masuk ke status gagal saat saya membuat atau memperbarui titik akhir?

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_endpointMetode mengembalikan informasi tentang endpoint dan statusnya. Seorang SageMaker pelayan menunggu titik akhir dalam pelayanan.

Uji titik akhir Anda.

Setelah titik akhir Anda dalam layanan, kirim permintaan pemanggilan 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 Runtime menggunakan metode titik akhir pemanggilan untuk mengirim payload ke titik akhir 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']]
```
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.

Memecahkan masalah penerapan kontainer

Jika titik akhir Anda tidak diterapkan, periksa log Amazon CloudWatch Events sebagai berikut:

Dari panel navigasi SageMaker konsol https://console.aws.amazon.com/sagemaker/, pilih Inferensi.
Di bawah Inferensi, pilih Endpoints.
Temukan titik akhir Anda di bawah Nama, dan klik pada nama titik akhir. Dalam contoh ini, nama akan mengikuti konvensi penamaanspacy-ner-configYYYY-MM-DD-HH-MM-SS.
Di bawah Ringkasan titik akhir, pilih tautan di bawah Log wadah Model.
Pilih aliran Log terbaru di kotak Aliran log.

Gunakan daftar berikut untuk memecahkan masalah penerapan titik akhir Anda. Jika Anda memerlukan bantuan lebih lanjut, hubungi AWSSupport atau Forum AWS Pengembang untuk Amazon SageMaker.

Topik

Kesalahan nama
Kuota tidak mencukupi
Kesalahan waktu habis hulu

Kesalahan nama

Jika log menyatakanNameError: name 'null' is not defined, pastikan skrip Anda tidak dibuat di buku catatan yang diakhiri .ipnyb dan kemudian diganti namanya menjadi nama file lain seperti. Dockerfile Saat Anda membuat buku catatan, memformat karakter dapat mencegah titik akhir Anda diterapkan. Jika Anda mendapatkan kesalahan ini dan Anda mengubah skrip untuk memperbaikinya, Anda mungkin perlu me-restart kernel Anda agar perubahan diterapkan.

Kuota tidak mencukupi

Jika Anda menerima ResourceLimitExceeded kesalahan, Anda harus meminta kuota tambahan sebagai berikut:

Minta peningkatan AWS Service Quotas

Ambil nama instans, kuota saat ini dan kuota yang diperlukan dari pesan kesalahan di layar. Misalnya, dalam contoh kesalahan berikut:

Nama instance-nya adalahml.c5d.18xlarge.
Kuota saat ini dari nomor berikut current utilization adalah1 instances.
Tambahan kuota yang diperlukan dari nomor berikut request delta adalah1 instances.

Kesalahan sampel berikut:


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.

Masuk ke AWS Management Console dan buka konsol Service Quotas.
Di panel navigasi, di bawah Kelola kuota, masukkan Amazon. SageMaker
Pilih Lihat kuota.
Di bilah pencarian di bawah Kuota layanan, masukkan nama instance dari Langkah 1. Misalnya, menggunakan informasi yang terkandung dalam pesan kesalahan dari Langkah 1, masukanml.c5d.18xlarge.
Pilih nama Kuota yang muncul di sebelah nama instans Anda dan diakhiri dengan untuk penggunaan titik akhir. Misalnya, menggunakan informasi yang terkandung dalam pesan kesalahan dari Langkah 1, pilih ml.g5.12xlarge untuk penggunaan titik akhir.
Pilih Permintaan peningkatan di tingkat akun.
Di bawah Meningkatkan nilai kuota, masukkan kuota yang diperlukan dari informasi yang diberikan dalam pesan kesalahan dari Langkah 1. Masukan total current utilization danrequest delta. Dalam contoh kesalahan sebelumnya, current utilization is1 Instances, dan request delta is1 Instances. Dalam contoh ini, minta kuota 2 untuk memasok kuota yang diperlukan.
Pilih Minta.
Pilih Riwayat permintaan kuota dari panel navigasi.
Saat Status berubah dari Tertunda menjadi Disetujui, jalankan kembali pekerjaan Anda. Anda mungkin perlu menyegarkan browser Anda untuk melihat perubahannya.

Untuk informasi selengkapnya tentang meminta peningkatan kuota, lihat Meminta kenaikan kuota.

Kesalahan waktu habis hulu

Jika Anda menerima upstream timed out (110: Connection timed out) kesalahan, Anda dapat mencoba yang berikut ini:

Kurangi latensi wadah atau tingkatkan batas waktu kontainer. SageMaker mengharuskan wadah Anda menanggapi permintaan dalam waktu 60 detik.
Tingkatkan jumlah waktu sebelum server web Anda menunggu respons dari model.

Untuk informasi lebih lanjut tentang kesalahan waktu habis, lihat Bagaimana cara mengatasi kesalahan SageMaker inferensi Amazon “waktu hulu habis (110: Waktu koneksi habis) saat membaca header respons dari hulu”?

Awas Javascript dinonaktifkan atau tidak tersedia di browser Anda.

Untuk menggunakan Dokumentasi AWS, Javascript harus diaktifkan. Lihat halaman Bantuan browser Anda untuk petunjuk.

Konvensi Dokumen

Gunakan registri Docker yang memerlukan otentikasi untuk pelatihan

Buat wadah dengan algoritme dan model Anda sendiri