Sesuaikan wadah inferensi Anda sendiri untuk Amazon AI SageMaker - Amazon SageMaker AI

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 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 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 dengan SageMaker AI, lihat Membangun wadah algoritme Anda sendiri.

Panduan berikut menunjukkan kepada Anda cara menggunakan JupyterLab ruang dengan Amazon SageMaker Studio Classic untuk mengadaptasi wadah inferensi agar berfungsi dengan hosting SageMaker AI. Contohnya menggunakan NGINX server web, Gunicorn sebagai Python antarmuka gateway server 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, lihatKode Inferensi Kustom dengan Layanan Hosting.

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) 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 NER model.

Jika Anda mengadaptasi contoh ini untuk kasus penggunaan Anda, Anda harus menggunakan Dockerfile dan skrip inferensi yang diperlukan untuk menyebarkan 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.

  2. Unggah Docker file dan skrip inferensi.

    1. Buat folder baru di direktori home Anda. Jika Anda menggunakan JupyterLab, di sudut kiri atas, pilih ikon Folder Baru, dan masukkan nama folder untuk berisi Dockerfile. Dalam contoh ini, folder dipanggildocker_test_folder.

    2. Unggah Dockerfile file teks ke folder baru Anda. Berikut ini adalah contoh Dockerfile yang menciptakan 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 menyimpan Python dari buffering aliran output standar, yang memungkinkan pengiriman log lebih cepat ke pengguna. Variabel lingkungan PYTHONDONTWRITEBYTECODE menyimpan Python dari menulis .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.

    3. 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— A Python script 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.

    4. 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 titik akhir:

      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 diformat JSON, mengekstrak bidang input, dan menggunakan NER model untuk mengidentifikasi dan menyimpan entitas dalam entitas variabel. Bagian Flask aplikasi 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).

    5. Unggah skrip untuk memulai server inferensi. Contoh skrip berikut memanggil serve menggunakan Gunicorn sebagai server aplikasi, dan Nginx Sebagai Web Server:

      #!/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 handler sinyalsigterm_handler, yang mematikan Nginx and Gunicorn sub-proses ketika menerima SIGTERM sinyal. Sebuah start_server fungsi memulai penangan sinyal, memulai dan memonitor Nginx and Gunicorn sub-proses, dan menangkap aliran log.

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

    7. Unggah skrip lain yang diperlukan untuk melayani model Anda. Contoh ini membutuhkan contoh script berikut dipanggil wsgi.py untuk membantu Gunicorn temukan 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 foldernya NER. NER folder 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.

  3. Bangun wadah Anda sendiri.

    Dari folderdocker_test_folder, buat Docker wadah. Contoh perintah berikut akan membangun Docker kontainer yang dikonfigurasi di Dockerfile:

    ! docker build -t byo-container-test .

    Perintah sebelumnya akan membangun wadah yang disebut byo-container-test di direktori kerja saat ini. Untuk informasi lebih lanjut tentang Docker membangun parameter, lihat Membangun argumen.

    catatan

    Jika Anda mendapatkan pesan galat berikut bahwa Docker tidak dapat menemukan Dockerfile, 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

    Docker mencari file yang secara khusus disebut 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 sebagai Dockerfile-text.txt, bangun Anda Docker kontainer menggunakan -f bendera diikuti oleh file Anda sebagai berikut:

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

  4. Dorong Anda Docker Gambar ke Amazon Elastic Container Registry (Amazon ECR)

    Di sel notebook, dorong Docker gambar 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 sebagaism-pretrained-spacy.

    2. Buat serve file di dalam NER folder yang dapat dieksekusi.

    3. Mengatur Wilayah AWS.

    4. Buat ECR jika belum ada.

    5. Login ke ECR.

    6. Membangun Docker kontainer secara lokal.

    7. Dorong Docker gambar ke ECR.

  5. Siapkan klien SageMaker AI

    Jika Anda ingin menggunakan layanan hosting SageMaker AI untuk inferensi, Anda harus membuat model, membuat konfigurasi titik akhir, dan membuat titik akhir. Untuk mendapatkan kesimpulan dari titik akhir Anda, Anda dapat menggunakan AI SageMaker boto3 Klien 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:

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

    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, lihatAWS kebijakan terkelola untuk Amazon SageMaker AI.

  6. 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 EC2 instans Amazon.

    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
    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 titik akhir?

    2. 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 pelayan SageMaker AI menunggu titik akhir dalam pelayanan.

  8. 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 AI Runtime menggunakan metode titik akhir pemanggilan untuk mengirim muatan ke titik akhir Anda. Hasilnya berisi respons dari titik akhir Anda setelah mengekstrak bidang output.

    Contoh kode sebelumnya harus mengembalikan output berikut:

    [['NER', 'ORG'],
 ['America', 'GPE'],
 ['Amazon', 'ORG'],
 ['Microsoft', 'ORG'],
 ['Seattle', 'GPE']]

  9. 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.