Terjemahan disediakan oleh mesin penerjemah. Jika konten terjemahan yang diberikan bertentangan dengan versi bahasa Inggris aslinya, utamakan versi bahasa Inggris.
# Kontainer Docker khusus dengan AI SageMaker
Anda dapat mengadaptasi gambar Docker yang ada untuk bekerja dengan SageMaker AI. Anda mungkin perlu menggunakan image Docker eksternal yang ada dengan SageMaker AI saat Anda memiliki wadah yang memenuhi fitur atau persyaratan keselamatan yang saat ini tidak didukung oleh gambar AI yang dibuat sebelumnya SageMaker . Ada dua toolkit yang memungkinkan Anda membawa wadah Anda sendiri dan menyesuaikannya untuk bekerja dengan SageMaker AI:
+ [SageMaker Training Toolkit](https://github.com/aws/sagemaker-training-toolkit) — Gunakan toolkit ini untuk melatih model dengan SageMaker AI.
+ [SageMaker AI Inference Toolkit](https://github.com/aws/sagemaker-inference-toolkit) — Gunakan toolkit ini untuk menerapkan model dengan AI. SageMaker
Topik berikut menunjukkan cara menyesuaikan gambar Anda yang ada menggunakan toolkit SageMaker Pelatihan dan Inferensi:
**Topics**
+ [Perpustakaan Kerangka Individu](#docker-containers-adapt-your-own-frameworks)
+ [SageMaker Toolkit Pelatihan dan Inferensi](amazon-sagemaker-toolkits.md)
+ [Mengadaptasi wadah pelatihan Anda sendiri](adapt-training-container.md)
+ [Sesuaikan wadah inferensi Anda sendiri untuk Amazon AI SageMaker](adapt-inference-container.md)
## Perpustakaan Kerangka Individu
Selain SageMaker Training Toolkit dan SageMaker AI Inference Toolkit, SageMaker AI juga menyediakan toolkit khusus untuk, TensorFlow,, MXNet dan Chainer. PyTorch Tabel berikut menyediakan tautan ke GitHub repositori yang berisi kode sumber untuk setiap kerangka kerja dan toolkit penyajiannya masing-masing. Instruksi yang ditautkan adalah untuk menggunakan Python SDK untuk menjalankan algoritme pelatihan dan model host di AI. SageMaker Fungsionalitas untuk pustaka individu ini termasuk dalam SageMaker AI Training Toolkit dan SageMaker AI Inference Toolkit.
| Kerangka Kerja | Kode Sumber Toolkit |
| --- | --- |
| TensorFlow | [SageMaker TensorFlow Pelatihan AI](https://github.com/aws/sagemaker-tensorflow-training-toolkit) [SageMaker TensorFlow Penyajian AI](https://github.com/aws/sagemaker-tensorflow-serving-container) |
| MXNet | [SageMaker MXNet Pelatihan AI](https://github.com/aws/sagemaker-mxnet-training-toolkit) [SageMaker MXNet Inferensi AI](https://github.com/aws/sagemaker-mxnet-inference-toolkit) |
| PyTorch | [SageMaker PyTorch Pelatihan AI](https://github.com/aws/sagemaker-pytorch-training-toolkit) [SageMaker PyTorch Inferensi AI](https://github.com/aws/sagemaker-pytorch-inference-toolkit) |
| Chainer | [SageMaker Wadah AI Chainer SageMaker AI](https://github.com/aws/sagemaker-chainer-container) |
# SageMaker Toolkit Pelatihan dan Inferensi
Toolkit [SageMaker Pelatihan](https://github.com/aws/sagemaker-training-toolkit) dan [Inferensi SageMaker AI](https://github.com/aws/sagemaker-inference-toolkit) mengimplementasikan fungsionalitas yang Anda butuhkan untuk menyesuaikan wadah Anda untuk menjalankan skrip, melatih algoritme, dan menerapkan model pada AI. SageMaker Saat diinstal, pustaka mendefinisikan hal berikut untuk pengguna:
+ Lokasi untuk menyimpan kode dan sumber daya lainnya.
+ Titik masuk yang berisi kode untuk dijalankan ketika wadah dimulai. Dockerfile Anda harus menyalin kode yang perlu dijalankan ke lokasi yang diharapkan oleh wadah yang kompatibel dengan SageMaker AI.
+ Informasi lain yang dibutuhkan wadah untuk mengelola penerapan untuk pelatihan dan inferensi.
## SageMaker Struktur Kontainer AI Toolkit
Saat SageMaker AI melatih model, ia membuat struktur folder file berikut di `/opt/ml` direktori kontainer.
```
/opt/ml
├── input
│ ├── config
│ │ ├── hyperparameters.json
│ │ └── resourceConfig.json
│ └── data
│ └──
│ └──
├── model
│
├── code
│
├── output
│
└── failure
```
Saat Anda menjalankan pekerjaan *pelatihan* model, wadah SageMaker AI menggunakan `/opt/ml/input/` direktori, yang berisi file JSON yang mengonfigurasi hiperparameter untuk algoritme dan tata letak jaringan yang digunakan untuk pelatihan terdistribusi. `/opt/ml/input/`Direktori ini juga berisi file yang menentukan saluran di mana SageMaker AI mengakses data, yang disimpan di Amazon Simple Storage Service (Amazon S3). Pustaka kontainer SageMaker AI menempatkan skrip yang akan dijalankan penampung di `/opt/ml/code/` direktori. Skrip Anda harus menulis model yang dihasilkan oleh algoritme Anda ke `/opt/ml/model/` direktori. Untuk informasi selengkapnya, lihat [Wadah dengan algoritma pelatihan khusus](your-algorithms-training-algo.md).
Saat Anda *meng-host* model terlatih di SageMaker AI untuk membuat kesimpulan, Anda menerapkan model ke titik akhir HTTP. Model membuat prediksi real-time dalam menanggapi permintaan inferensi. Wadah harus berisi tumpukan penyajian untuk memproses permintaan ini.
Dalam wadah hosting atau batch transform, file model terletak di folder yang sama dengan yang ditulis selama pelatihan.
```
/opt/ml/model
│
└──
```
Untuk informasi selengkapnya, lihat [Wadah dengan kode inferensi khusus](your-algorithms-inference-main.md).
## Kontainer Tunggal Versus Beberapa
Anda dapat memberikan gambar Docker terpisah untuk algoritme pelatihan dan kode inferensi atau Anda dapat menggunakan satu gambar Docker untuk keduanya. Saat membuat gambar Docker untuk digunakan dengan SageMaker AI, pertimbangkan hal berikut:
+ Menyediakan dua gambar Docker dapat meningkatkan persyaratan dan biaya penyimpanan karena pustaka umum mungkin diduplikasi.
+ Secara umum, kontainer yang lebih kecil mulai lebih cepat untuk pelatihan dan hosting. Model berlatih lebih cepat dan layanan hosting dapat bereaksi terhadap peningkatan lalu lintas dengan secara otomatis menskalakan lebih cepat.
+ Anda mungkin dapat menulis wadah inferensi yang secara signifikan lebih kecil dari wadah pelatihan. Ini sangat umum ketika Anda menggunakan GPUs untuk pelatihan, tetapi kode inferensi Anda dioptimalkan untuk CPUs.
+ SageMaker AI mengharuskan kontainer Docker berjalan tanpa akses istimewa.
+ Baik kontainer Docker yang Anda buat maupun yang disediakan oleh SageMaker AI dapat mengirim pesan ke `Stderr` file `Stdout` dan file. SageMaker AI mengirimkan pesan-pesan ini ke CloudWatch log Amazon di AWS akun Anda.
Untuk informasi selengkapnya tentang cara membuat wadah SageMaker AI dan bagaimana skrip dijalankan di dalamnya, lihat repositori [SageMaker AI Training Toolkit](https://github.com/aws/sagemaker-training-toolkit) dan [SageMaker AI Inference Toolkit](https://github.com/aws/sagemaker-inference-toolkit). GitHub Mereka juga menyediakan daftar variabel lingkungan penting dan variabel lingkungan yang disediakan oleh wadah SageMaker AI.
# Mengadaptasi wadah pelatihan Anda sendiri
Untuk menjalankan model pelatihan Anda sendiri, buat container Docker menggunakan [Amazon SageMaker Training Toolkit](https://github.com/aws/sagemaker-training-toolkit) melalui instance SageMaker notebook Amazon.
## Langkah 1: Buat instance SageMaker notebook
1. Buka konsol Amazon SageMaker AI di [https://console.aws.amazon.com/sagemaker/](https://console.aws.amazon.com/sagemaker/).
1. Di panel navigasi kiri, pilih **Notebook**, pilih **instance Notebook**, lalu pilih **Buat instance notebook**.
1. Pada halaman **Create notebook instance**, berikan informasi berikut:
1. Untuk **nama instance Notebook**, masukkan**RunScriptNotebookInstance**.
1. Untuk **jenis Instance Notebook**, pilih**ml.t2.medium**.
1. Di bagian **Izin dan enkripsi**, lakukan hal berikut:
1. Untuk **Peran IAM**, pilih **Buat Peran Baru**. Ini membuka jendela baru.
1. **Pada halaman **Buat peran IAM**, pilih bucket **S3 Spesifik, tentukan bucket** Amazon S3 bernama**sagemaker-run-script**, lalu pilih Buat peran.**
SageMaker AI menciptakan peran IAM bernama`AmazonSageMaker-ExecutionRole-YYYYMMDDTHHmmSS`. Misalnya, `AmazonSageMaker-ExecutionRole-20190429T110788`. Perhatikan bahwa konvensi penamaan peran eksekusi menggunakan tanggal dan waktu di mana peran itu dibuat, dipisahkan oleh a`T`.
1. Untuk **Akses Root**, pilih **Aktifkan**.
1. Pilih **Buat instans notebook**.
1. Pada halaman **Instance Notebook**, **Status** **Tertunda**. Amazon SageMaker AI dapat memakan waktu beberapa menit untuk meluncurkan instance komputasi pembelajaran mesin—dalam hal ini, ia meluncurkan instance notebook—dan melampirkan volume penyimpanan ML ke dalamnya. Instance notebook memiliki server notebook Jupyter yang telah dikonfigurasi sebelumnya dan satu set pustaka Anaconda. Untuk informasi lebih lanjut, lihat [ CreateNotebookInstance](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_CreateNotebookInstance.html).
1. Klik pada **Nama** buku catatan yang baru saja Anda buat. Ini membuka halaman baru.
1. Di bagian **Izin dan enkripsi**, salin **nomor ARN peran IAM**, dan tempel ke file notepad untuk menyimpannya sementara. Anda menggunakan nomor ARN peran IAM ini nanti untuk mengonfigurasi estimator pelatihan lokal di instance notebook. Nomor **ARN peran IAM** terlihat seperti berikut: `'arn:aws:iam::111122223333:role/service-role/AmazonSageMaker-ExecutionRole-20190429T110788'`
1. Setelah status instance notebook berubah menjadi **InService**, pilih **Buka JupyterLab**.
## Langkah 2: Buat dan unggah skrip pelatihan Dockerfile dan Python
1. Setelah JupyterLab terbuka, buat folder baru di direktori home Anda JupyterLab. Di sudut kiri atas, pilih ikon **Folder Baru**, lalu masukkan nama folder. `docker_test_folder`
1. Buat file `Dockerfile` teks di `docker_test_folder` direktori.
1. Pilih ikon **Peluncur Baru** (\$1) di sudut kiri atas.
1. Di panel kanan di bawah bagian **Lainnya**, pilih **File Teks**.
1. Tempelkan kode `Dockerfile` contoh berikut ke dalam file teks Anda.
```
#Download an open source TensorFlow Docker image
FROM tensorflow/tensorflow:latest-gpu-jupyter
# Install sagemaker-training toolkit that contains the common functionality necessary to create a container compatible with SageMaker AI and the Python SDK.
RUN pip3 install sagemaker-training
# Copies the training code inside the container
COPY train.py /opt/ml/code/train.py
# Defines train.py as script entrypoint
ENV SAGEMAKER_PROGRAM train.py
```
Skrip Dockerfile melakukan tugas-tugas berikut:
+ `FROM tensorflow/tensorflow:latest-gpu-jupyter`— Mengunduh gambar dasar TensorFlow Docker terbaru. Anda dapat mengganti ini dengan gambar dasar Docker apa pun yang ingin Anda bawa untuk membangun kontainer, serta dengan gambar dasar kontainer yang AWS sudah dibuat sebelumnya.
+ `RUN pip install sagemaker-training`— Menginstal [SageMaker AI Training Toolkit](https://github.com/aws/sagemaker-training-toolkit) yang berisi fungsionalitas umum yang diperlukan untuk membuat wadah yang kompatibel dengan SageMaker AI.
+ `COPY train.py /opt/ml/code/train.py`— Menyalin skrip ke lokasi di dalam wadah yang diharapkan oleh SageMaker AI. Skrip harus berada di folder ini.
+ `ENV SAGEMAKER_PROGRAM train.py`— Mengambil skrip pelatihan Anda `train.py` sebagai skrip titik masuk yang disalin di `/opt/ml/code` folder wadah. Ini adalah satu-satunya variabel lingkungan yang harus Anda tentukan ketika Anda membangun wadah Anda sendiri.
1. Pada panel navigasi direktori kiri, nama file teks mungkin secara otomatis diberi `untitled.txt` nama. Untuk mengganti nama file, klik kanan file, pilih **Ganti nama**, ganti nama file `Dockerfile` tanpa `.txt` ekstensi, lalu tekan `Ctrl+s` atau `Command+s` untuk menyimpan file.
1. Unggah skrip pelatihan `train.py` ke`docker_test_folder`. Anda dapat menggunakan contoh skrip berikut untuk membuat model yang membaca digit tulisan tangan yang dilatih pada [dataset MNIST](https://en.wikipedia.org/wiki/MNIST_database) untuk latihan ini.
```
import tensorflow as tf
import os
mnist = tf.keras.datasets.mnist
(x_train, y_train), (x_test, y_test) = mnist.load_data()
x_train, x_test = x_train / 255.0, x_test / 255.0
model = tf.keras.models.Sequential([
tf.keras.layers.Flatten(input_shape=(28, 28)),
tf.keras.layers.Dense(128, activation='relu'),
tf.keras.layers.Dropout(0.2),
tf.keras.layers.Dense(10, activation='softmax')
])
model.compile(optimizer='adam',
loss='sparse_categorical_crossentropy',
metrics=['accuracy'])
model.fit(x_train, y_train, epochs=1)
model_save_dir = f"{os.environ.get('SM_MODEL_DIR')}/1"
model.evaluate(x_test, y_test)
tf.saved_model.save(model, model_save_dir)
```
## Langkah 3: Bangun wadah
1. Di direktori JupyterLab home, buka notebook Jupyter. **Untuk membuka buku catatan baru, pilih ikon **Peluncuran Baru** lalu pilih versi terbaru **conda\$1tensorflow2** di bagian Notebook.**
1. Jalankan perintah berikut di sel notebook pertama untuk mengubah ke `docker_test_folder` direktori:
```
cd ~/SageMaker/docker_test_folder
```
Ini mengembalikan direktori Anda saat ini sebagai berikut:
```
! pwd
```
`output: /home/ec2-user/SageMaker/docker_test_folder`
1. Untuk membangun kontainer Docker, jalankan perintah build Docker berikut, termasuk spasi yang diikuti oleh titik di akhir:
```
! docker build -t tf-custom-container-test .
```
Perintah Docker build harus dijalankan dari direktori Docker yang Anda buat, dalam hal ini. `docker_test_folder`
**catatan**
Jika Anda mendapatkan pesan kesalahan 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/Dockerfile: no such file or directory
```
Ingatlah bahwa `docker` mencari 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 `-f` bendera. Misalnya, jika Anda menamai Dockerfile sebagai`Dockerfile-text.txt`, jalankan perintah berikut:
```
! docker build -t tf-custom-container-test -f Dockerfile-text.txt .
```
## Langkah 4: Uji wadahnya
1. Untuk menguji kontainer secara lokal di instance notebook, buka notebook Jupyter. **Pilih **Peluncur Baru** dan pilih versi terbaru **conda\$1tensorflow2** di bagian Notebook.**
1. Tempelkan contoh skrip berikut ke sel kode notebook untuk mengonfigurasi SageMaker AI Estimator.
```
import sagemaker
from sagemaker.estimator import Estimator
estimator = Estimator(image_uri='tf-custom-container-test',
role=sagemaker.get_execution_role(),
instance_count=1,
instance_type='local')
estimator.fit()
```
Dalam contoh kode sebelumnya, `sagemaker.get_execution_role()` ditentukan ke `role` argumen untuk secara otomatis mengambil peran yang disiapkan untuk sesi AI. SageMaker Anda juga dapat menggantinya dengan nilai string nomor **ARN peran IAM** yang Anda gunakan saat mengonfigurasi instance notebook. ARN akan terlihat seperti berikut:. `'arn:aws:iam::111122223333:role/service-role/AmazonSageMaker-ExecutionRole-20190429T110788'`
1. Jalankan sel kode. Tes ini menghasilkan konfigurasi lingkungan pelatihan, nilai yang digunakan untuk variabel lingkungan, sumber data, dan kehilangan dan akurasi yang diperoleh selama pelatihan.
## Langkah 5: Dorong wadah ke Amazon Elastic Container Registry (Amazon ECR)
1. Setelah berhasil menjalankan pengujian mode lokal, Anda dapat mendorong wadah Docker ke [Amazon ECR](https://docs.aws.amazon.com/AmazonECR/latest/userguide/what-is-ecr.html) dan menggunakannya untuk menjalankan pekerjaan pelatihan. Jika Anda ingin menggunakan registri Docker pribadi alih-alih Amazon ECR, lihat [Dorong wadah pelatihan Anda ke registri pribadi](https://docs.aws.amazon.com/sagemaker/latest/dg/docker-containers-adapt-your-own-private-registry.html).
Jalankan baris perintah berikut di sel notebook.
```
%%sh
# Specify an algorithm name
algorithm_name=tf-custom-container-test
account=$(aws sts get-caller-identity --query Account --output text)
# Get the region defined in the current configuration (default to us-west-2 if none defined)
region=$(aws configure get region)
region=${region:-us-west-2}
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/null
fi
# 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}
```
**catatan**
Skrip bash shell ini dapat menimbulkan masalah izin yang mirip dengan pesan kesalahan berikut:
```
"denied: User: [ARN] is not authorized to perform: ecr:InitiateLayerUpload on resource:
arn:aws:ecr:us-east-1:[id]:repository/tf-custom-container-test"
```
Jika kesalahan ini terjadi, Anda harus melampirkan EC2 ContainerRegistryFullAccess kebijakan **Amazon** ke peran IAM Anda. Buka [konsol IAM](https://console.aws.amazon.com/iam/home), pilih **Peran** dari panel navigasi kiri, cari yang IAMrole Anda gunakan untuk instance Notebook. Di bawah tab **Izin**, pilih tombol **Lampirkan kebijakan**, dan cari EC2 ContainerRegistryFullAccess kebijakan **Amazon**. Tandai kotak centang kebijakan, dan pilih **Tambahkan izin** untuk menyelesaikan.
1. Jalankan kode berikut di sel notebook Studio untuk memanggil image Amazon ECR dari wadah pelatihan Anda.
```
import boto3
account_id = boto3.client('sts').get_caller_identity().get('Account')
ecr_repository = 'tf-custom-container-test'
tag = ':latest'
region = boto3.session.Session().region_name
uri_suffix = 'amazonaws.com'
if region in ['cn-north-1', 'cn-northwest-1']:
uri_suffix = 'amazonaws.com.cn'
byoc_image_uri = '{}.dkr.ecr.{}.{}/{}'.format(account_id, region, uri_suffix, ecr_repository + tag)
byoc_image_uri
# This should return something like
# 111122223333.dkr.ecr.us-east-2.amazonaws.com/sagemaker-byoc-test:latest
```
1. Gunakan yang `ecr_image` diambil dari langkah sebelumnya untuk mengonfigurasi objek penaksir SageMaker AI. Contoh kode berikut mengonfigurasi estimator SageMaker AI dengan `byoc_image_uri` dan memulai pekerjaan pelatihan pada instans Amazon EC2.
------
#### [ SageMaker Python SDK v1 ]
```
import sagemaker
from sagemaker import get_execution_role
from sagemaker.estimator import Estimator
estimator = Estimator(image_uri=byoc_image_uri,
role=get_execution_role(),
base_job_name='tf-custom-container-test-job',
instance_count=1,
instance_type='ml.g4dn.xlarge')
#train your model
estimator.fit()
```
------
#### [ SageMaker Python SDK v2 ]
```
import sagemaker
from sagemaker import get_execution_role
from sagemaker.estimator import Estimator
estimator = Estimator(image_uri=byoc_image_uri,
role=get_execution_role(),
base_job_name='tf-custom-container-test-job',
instance_count=1,
instance_type='ml.g4dn.xlarge')
#train your model
estimator.fit()
```
------
1. Jika Anda ingin menerapkan model Anda menggunakan wadah Anda sendiri, lihat [Mengadaptasi Wadah Inferensi Anda Sendiri](https://docs.aws.amazon.com/sagemaker/latest/dg/adapt-inference-container.html). Anda juga dapat menggunakan wadah AWS kerangka kerja yang dapat menerapkan TensorFlow model. Untuk menerapkan model contoh untuk membaca digit tulisan tangan, masukkan skrip contoh berikut ke dalam buku catatan yang sama yang Anda gunakan untuk melatih model Anda di sub-langkah sebelumnya untuk mendapatkan gambar URIs (pengidentifikasi sumber daya universal) yang diperlukan untuk penerapan, dan gunakan model.
```
import boto3
import sagemaker
#obtain image uris
from sagemaker import image_uris
container = image_uris.retrieve(framework='tensorflow',region='us-west-2',version='2.11.0',
image_scope='inference',instance_type='ml.g4dn.xlarge')
#create the model entity, endpoint configuration and endpoint
predictor = estimator.deploy(1,instance_type='ml.g4dn.xlarge',image_uri=container)
```
Uji model Anda menggunakan contoh digit tulisan tangan dari kumpulan data MNIST menggunakan contoh kode berikut.
```
#Retrieve an example test dataset to test
import numpy as np
import matplotlib.pyplot as plt
from keras.datasets import mnist
# Load the MNIST dataset and split it into training and testing sets
(x_train, y_train), (x_test, y_test) = mnist.load_data()
# Select a random example from the training set
example_index = np.random.randint(0, x_train.shape[0])
example_image = x_train[example_index]
example_label = y_train[example_index]
# Print the label and show the image
print(f"Label: {example_label}")
plt.imshow(example_image, cmap='gray')
plt.show()
```
Ubah digit tulisan tangan tes menjadi bentuk yang TensorFlow dapat menelan dan membuat prediksi tes.
```
from sagemaker.serializers import JSONSerializer
data = {"instances": example_image.tolist()}
predictor.serializer=JSONSerializer() #update the predictor to use the JSONSerializer
predictor.predict(data) #make the prediction
```
Untuk contoh lengkap yang menunjukkan cara menguji container kustom secara lokal dan mendorongnya ke image Amazon ECR, lihat contoh buku catatan [Building Your Own TensorFlow Container](https://sagemaker-examples.readthedocs.io/en/latest/advanced_functionality/tensorflow_bring_your_own/tensorflow_bring_your_own.html).
**Tip**
Untuk membuat profil dan men-debug pekerjaan pelatihan untuk memantau masalah pemanfaatan sistem (seperti kemacetan CPU dan kurangnya pemanfaatan GPU) dan mengidentifikasi masalah pelatihan (seperti overfitting, overtraining, tensor meledak, dan gradien menghilang), gunakan Amazon Debugger. SageMaker Untuk informasi selengkapnya, lihat [Gunakan Debugger dengan wadah pelatihan khusus](debugger-bring-your-own-container.md).
## Langkah 6: Bersihkan Sumber Daya
**Untuk membersihkan sumber daya saat selesai dengan contoh memulai**
1. Buka [konsol SageMaker AI](https://console.aws.amazon.com/sagemaker/), pilih instance notebook **RunScriptNotebookInstance**, pilih **Actions**, dan pilih **Stop**. Hal ini dapat memerlukan waktu beberapa menit sampai instans berhenti.
1. Setelah **Status** instance berubah menjadi **Berhenti**, pilih **Tindakan**, pilih **Hapus**, lalu pilih **Hapus** di kotak dialog. Diperlukan waktu beberapa menit untuk menghapus instance. Instance notebook menghilang dari tabel ketika telah dihapus.
1. Buka [konsol Amazon S3](https://console.aws.amazon.com/s3/) dan hapus bucket yang Anda buat untuk menyimpan artefak model dan kumpulan data pelatihan.
1. Buka [konsol IAM](https://console.aws.amazon.com/iam/) dan hapus peran IAM. Jika Anda membuat kebijakan izin, Anda juga dapat menghapusnya.
**catatan**
Kontainer Docker dimatikan secara otomatis setelah dijalankan. Anda tidak perlu menghapusnya.
## Blog dan Studi Kasus
Blog berikut membahas studi kasus tentang penggunaan wadah pelatihan khusus di Amazon SageMaker AI.
+ [Mengapa membawa wadah Anda sendiri ke Amazon SageMaker AI dan bagaimana melakukannya dengan benar](https://medium.com/@pandey.vikesh/why-bring-your-own-container-to-amazon-sagemaker-and-how-to-do-it-right-bc158fe41ed1), *Medium* (20 Januari 2023)
# Sesuaikan pekerjaan pelatihan Anda untuk mengakses gambar di registri Docker pribadi
Anda dapat menggunakan [registri Docker](https://docs.docker.com/registry/) pribadi alih-alih Amazon Elastic Container Registry (Amazon ECR) untuk meng-host gambar Anda untuk Pelatihan AI. SageMaker Petunjuk berikut menunjukkan kepada Anda cara membuat registri Docker, mengonfigurasi cloud pribadi virtual (VPC) dan pekerjaan pelatihan Anda, menyimpan gambar, dan SageMaker memberikan akses AI ke gambar pelatihan di registri docker pribadi. Instruksi ini juga menunjukkan cara menggunakan registri Docker yang memerlukan otentikasi untuk pekerjaan SageMaker pelatihan.
## Buat dan simpan gambar Anda di registri Docker pribadi
Buat registri Docker pribadi untuk menyimpan gambar Anda. Registri Anda harus:
+ gunakan protokol [API HTTP Docker Registry](https://docs.docker.com/registry/spec/api/)
+ dapat diakses dari VPC yang sama yang ditentukan dalam [VpcConfig](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_CreateTrainingJob.html#API_CreateTrainingJob_RequestSyntax)parameter di API. `CreateTrainingJob` Masukan `VpcConfig` saat Anda membuat pekerjaan pelatihan Anda.
+ diamankan dengan sertifikat [TLS dari otoritas sertifikat](https://aws.amazon.com/what-is/ssl-certificate/) publik yang dikenal.
Untuk informasi selengkapnya tentang membuat registri Docker, lihat [Menerapkan server registri](https://docs.docker.com/registry/deploying/).
## Konfigurasikan VPC dan SageMaker pekerjaan pelatihan Anda
SageMaker AI menggunakan koneksi jaringan dalam VPC Anda untuk mengakses gambar di registri Docker Anda. Untuk menggunakan gambar di registri Docker Anda untuk pelatihan, registri harus dapat diakses dari VPC Amazon di akun Anda. Untuk informasi selengkapnya, lihat [Gunakan registri Docker yang memerlukan otentikasi untuk pelatihan](docker-containers-adapt-your-own-private-registry-authentication.md).
Anda juga harus mengonfigurasi pekerjaan pelatihan Anda untuk terhubung ke VPC yang sama dengan yang dapat diakses oleh registri Docker Anda. Untuk informasi selengkapnya, lihat [Mengonfigurasi Pekerjaan Pelatihan untuk Akses VPC Amazon](https://docs.aws.amazon.com/sagemaker/latest/dg/train-vpc.html#train-vpc-configure).
## Buat pekerjaan pelatihan menggunakan gambar dari registri Docker pribadi Anda
Untuk menggunakan gambar dari registri Docker pribadi Anda untuk pelatihan, gunakan panduan berikut untuk mengonfigurasi gambar Anda, mengonfigurasi, dan membuat pekerjaan pelatihan. Contoh kode yang mengikuti menggunakan AWS SDK untuk Python (Boto3) klien.
1. Buat objek konfigurasi gambar pelatihan dan `Vpc` masukan `TrainingRepositoryAccessMode` bidang sebagai berikut.
```
training_image_config = {
'TrainingRepositoryAccessMode': 'Vpc'
}
```
**catatan**
Jika registri Docker pribadi Anda memerlukan otentikasi, Anda harus menambahkan `TrainingRepositoryAuthConfig` objek ke objek konfigurasi gambar pelatihan. Anda juga harus menentukan Nama Sumber Daya Amazon (ARN) dari AWS Lambda fungsi yang menyediakan kredensyal akses ke SageMaker AI menggunakan `TrainingRepositoryCredentialsProviderArn` bidang objek. `TrainingRepositoryAuthConfig` Untuk informasi lebih lanjut, lihat contoh struktur kode di bawah ini.
```
training_image_config = {
'TrainingRepositoryAccessMode': 'Vpc',
'TrainingRepositoryAuthConfig': {
'TrainingRepositoryCredentialsProviderArn': 'arn:aws:lambda:Region:Acct:function:FunctionName'
}
}
```
Untuk informasi tentang cara membuat fungsi Lambda untuk menyediakan otentikasi, lihat. [Gunakan registri Docker yang memerlukan otentikasi untuk pelatihan](docker-containers-adapt-your-own-private-registry-authentication.md)
1. Gunakan klien Boto3 untuk membuat pekerjaan pelatihan dan meneruskan konfigurasi yang benar ke [create\$1training\$1job](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_CreateTrainingJob.html) API. Petunjuk berikut menunjukkan cara mengkonfigurasi komponen dan membuat pekerjaan pelatihan.
1. Buat `AlgorithmSpecification` objek yang ingin Anda lewati`create_training_job`. Gunakan objek konfigurasi gambar pelatihan yang Anda buat pada langkah sebelumnya, seperti yang ditunjukkan pada contoh kode berikut.
```
algorithm_specification = {
'TrainingImage': 'myteam.myorg.com/docker-local/my-training-image:',
'TrainingImageConfig': training_image_config,
'TrainingInputMode': 'File'
}
```
**catatan**
Untuk menggunakan versi tetap, bukan versi gambar yang diperbarui, lihat [intisari](https://docs.docker.com/engine/reference/commandline/pull/#pull-an-image-by-digest-immutable-identifier) gambar alih-alih berdasarkan nama atau tag.
1. Tentukan nama pekerjaan pelatihan dan peran yang ingin Anda berikan`create_training_job`, seperti yang ditunjukkan pada contoh kode berikut.
```
training_job_name = 'private-registry-job'
execution_role_arn = 'arn:aws:iam::123456789012:role/SageMakerExecutionRole'
```
1. Tentukan grup keamanan dan subnet untuk konfigurasi VPC untuk pekerjaan pelatihan Anda. Registri Docker pribadi Anda harus mengizinkan lalu lintas masuk dari grup keamanan yang Anda tentukan, seperti yang ditunjukkan dalam contoh kode berikut.
```
vpc_config = {
'SecurityGroupIds': ['sg-0123456789abcdef0'],
'Subnets': ['subnet-0123456789abcdef0','subnet-0123456789abcdef1']
}
```
**catatan**
Jika subnet Anda tidak berada di VPC yang sama dengan registri Docker pribadi Anda, Anda harus mengatur koneksi jaringan di antara keduanya. VPCs SeeConnect VPCs menggunakan [VPC peering](https://docs.aws.amazon.com/vpc/latest/userguide/vpc-peering.html) untuk informasi lebih lanjut.
1. Tentukan konfigurasi sumber daya, termasuk instance komputasi pembelajaran mesin dan volume penyimpanan yang akan digunakan untuk pelatihan, seperti yang ditunjukkan dalam contoh kode berikut.
```
resource_config = {
'InstanceType': 'ml.m4.xlarge',
'InstanceCount': 1,
'VolumeSizeInGB': 10,
}
```
1. Tentukan konfigurasi data input dan output, tempat dataset pelatihan disimpan, dan di mana Anda ingin menyimpan artefak model, seperti yang ditunjukkan pada contoh kode berikut.
```
input_data_config = [
{
"ChannelName": "training",
"DataSource":
{
"S3DataSource":
{
"S3DataDistributionType": "FullyReplicated",
"S3DataType": "S3Prefix",
"S3Uri": "s3://your-training-data-bucket/training-data-folder"
}
}
}
]
output_data_config = {
'S3OutputPath': 's3://your-output-data-bucket/model-folder'
}
```
1. Tentukan jumlah detik maksimum yang dapat dijalankan oleh pekerjaan pelatihan model seperti yang ditunjukkan pada contoh kode berikut.
```
stopping_condition = {
'MaxRuntimeInSeconds': 1800
}
```
1. Terakhir, buat pekerjaan pelatihan menggunakan parameter yang Anda tentukan pada langkah sebelumnya seperti yang ditunjukkan pada contoh kode berikut.
```
import boto3
sm = boto3.client('sagemaker')
try:
resp = sm.create_training_job(
TrainingJobName=training_job_name,
AlgorithmSpecification=algorithm_specification,
RoleArn=execution_role_arn,
InputDataConfig=input_data_config,
OutputDataConfig=output_data_config,
ResourceConfig=resource_config,
VpcConfig=vpc_config,
StoppingCondition=stopping_condition
)
except Exception as e:
print(f'error calling CreateTrainingJob operation: {e}')
else:
print(resp)
```
# Gunakan estimator SageMaker AI untuk menjalankan pekerjaan pelatihan
Anda juga dapat menggunakan [estimator](https://sagemaker.readthedocs.io/en/stable/api/training/estimators.html) dari SageMaker Python SDK untuk menangani konfigurasi dan menjalankan tugas pelatihan Anda. SageMaker Contoh kode berikut menunjukkan cara mengkonfigurasi dan menjalankan estimator menggunakan gambar dari registri Docker pribadi.
1. Impor pustaka dan dependensi yang diperlukan, seperti yang ditunjukkan pada contoh kode berikut.
```
import boto3
import sagemaker
from sagemaker.estimator import Estimator
session = sagemaker.Session()
role = sagemaker.get_execution_role()
```
1. Berikan Uniform Resource Identifier (URI) ke image latihan, grup keamanan, dan subnet untuk konfigurasi VPC untuk tugas latihan Anda, seperti yang ditunjukkan pada contoh kode berikut.
```
image_uri = "myteam.myorg.com/docker-local/my-training-image:"
security_groups = ["sg-0123456789abcdef0"]
subnets = ["subnet-0123456789abcdef0", "subnet-0123456789abcdef0"]
```
Untuk informasi selengkapnya tentang `security_group_ids` dan`subnets`, lihat deskripsi parameter yang sesuai di bagian [Estimator](https://sagemaker.readthedocs.io/en/stable/api/training/estimators.html) SDK SageMaker Python.
**catatan**
SageMaker AI menggunakan koneksi jaringan dalam VPC Anda untuk mengakses gambar di registri Docker Anda. Untuk menggunakan gambar di registri Docker Anda untuk pelatihan, registri harus dapat diakses dari VPC Amazon di akun Anda.
1. Secara opsional, jika registri Docker Anda memerlukan otentikasi, Anda juga harus menentukan Nama Sumber Daya Amazon (ARN) dari AWS Lambda fungsi yang menyediakan kredensyal akses ke AI. SageMaker Contoh kode berikut menunjukkan cara menentukan ARN.
```
training_repository_credentials_provider_arn = "arn:aws:lambda:us-west-2:1234567890:function:test"
```
Untuk informasi selengkapnya tentang penggunaan gambar dalam registri Docker yang memerlukan autentikasi, lihat **Menggunakan registri Docker yang memerlukan otentikasi** untuk pelatihan di bawah ini.
1. Gunakan contoh kode dari langkah-langkah sebelumnya untuk mengkonfigurasi estimator, seperti yang ditunjukkan pada contoh kode berikut.
```
# The training repository access mode must be 'Vpc' for private docker registry jobs
training_repository_access_mode = "Vpc"
# Specify the instance type, instance count you want to use
instance_type="ml.m5.xlarge"
instance_count=1
# Specify the maximum number of seconds that a model training job can run
max_run_time = 1800
# Specify the output path for the model artifacts
output_path = "s3://your-output-bucket/your-output-path"
estimator = Estimator(
image_uri=image_uri,
role=role,
subnets=subnets,
security_group_ids=security_groups,
training_repository_access_mode=training_repository_access_mode,
training_repository_credentials_provider_arn=training_repository_credentials_provider_arn, # remove this line if auth is not needed
instance_type=instance_type,
instance_count=instance_count,
output_path=output_path,
max_run=max_run_time
)
```
1. Mulai pekerjaan pelatihan Anda `estimator.fit` dengan menelepon dengan nama pekerjaan Anda dan jalur input sebagai parameter, seperti yang ditunjukkan pada contoh kode berikut.
```
input_path = "s3://your-input-bucket/your-input-path"
job_name = "your-job-name"
estimator.fit(
inputs=input_path,
job_name=job_name
)
```
# Gunakan registri Docker yang memerlukan otentikasi untuk pelatihan
Jika registri Docker Anda memerlukan otentikasi, Anda harus membuat AWS Lambda fungsi yang menyediakan kredensyal akses ke AI. SageMaker [Kemudian, buat pekerjaan pelatihan dan berikan ARN fungsi Lambda ini di dalam create\$1training\$1job API.](https://boto3.amazonaws.com/v1/documentation/api/latest/reference/services/sagemaker.html#SageMaker.Client.create_training_job) Terakhir, Anda dapat secara opsional membuat titik akhir VPC antarmuka sehingga VPC Anda dapat berkomunikasi dengan fungsi Lambda Anda tanpa mengirim lalu lintas melalui internet. Panduan berikut menunjukkan cara membuat fungsi Lambda, menetapkan peran yang benar dan membuat antarmuka VPC endpoint.
## Buat fungsi Lambda
Buat AWS Lambda fungsi yang meneruskan kredensyal akses ke SageMaker AI dan mengembalikan respons. Contoh kode berikut menciptakan fungsi handler Lambda, sebagai berikut.
```
def handler(event, context):
response = {
"Credentials": {"Username": "username", "Password": "password"}
}
return response
```
Jenis otentikasi yang digunakan untuk mengatur registri Docker pribadi Anda menentukan isi respons yang dikembalikan oleh fungsi Lambda Anda sebagai berikut.
+ Jika registri Docker pribadi Anda menggunakan otentikasi dasar, fungsi Lambda akan mengembalikan nama pengguna dan kata sandi yang diperlukan untuk mengautentikasi ke registri.
+ Jika registri Docker pribadi Anda menggunakan [otentikasi token pembawa](https://docs.docker.com/registry/spec/auth/token/), nama pengguna dan kata sandi dikirim ke server otorisasi Anda, yang kemudian mengembalikan token pembawa. Token ini kemudian digunakan untuk mengautentikasi ke registri Docker pribadi Anda.
**catatan**
Jika Anda memiliki lebih dari satu fungsi Lambda untuk pendaftar Anda di akun yang sama, dan peran pelaksanaannya sama untuk pekerjaan pelatihan Anda, maka pekerjaan pelatihan untuk registri seseorang akan memiliki akses ke fungsi Lambda untuk pendaftar lain.
## Berikan izin peran yang benar ke fungsi Lambda Anda
[IAMrole](https://docs.aws.amazon.com/sagemaker/latest/dg/sagemaker-roles.html)Yang Anda gunakan di `create_training_job` API harus memiliki izin untuk memanggil AWS Lambda fungsi. Contoh kode berikut menunjukkan cara memperluas kebijakan izin dari peran IAM untuk memanggil. `myLambdaFunction`
```
{
"Effect": "Allow",
"Action": [
"lambda:InvokeFunction"
],
"Resource": [
"arn:aws:lambda:*:*:function:*myLambdaFunction*"
]
}
```
Untuk informasi tentang mengedit kebijakan izin peran, lihat [Memodifikasi kebijakan izin peran (konsol)](https://docs.aws.amazon.com/IAM/latest/UserGuide/roles-managingrole-editing-console.html#roles-modify_permissions-policy) di Panduan Pengguna *AWS Identity and Access Management*.
**catatan**
Peran IAM dengan kebijakan **AmazonSageMakerFullAccess**terkelola terlampir memiliki izin untuk memanggil fungsi Lambda apa pun dengan SageMaker "AI” dalam namanya.
## Buat titik akhir VPC antarmuka untuk Lambda
Jika Anda membuat titik akhir antarmuka, VPC Amazon Anda dapat berkomunikasi dengan fungsi Lambda Anda tanpa mengirim lalu lintas melalui internet. *Untuk informasi selengkapnya, lihat [Mengonfigurasi titik akhir VPC antarmuka untuk](https://docs.aws.amazon.com/lambda/latest/dg/configuration-vpc-endpoints.html)AWS Lambda Lambda di Panduan Pengembang.*
Setelah titik akhir antarmuka Anda dibuat, SageMaker pelatihan akan memanggil fungsi Lambda Anda dengan mengirimkan permintaan melalui VPC Anda ke. `lambda.region.amazonaws.com` Jika Anda memilih **Aktifkan Nama DNS** saat membuat titik akhir antarmuka, [Amazon Route 53 merutekan](https://docs.aws.amazon.com/Route53/latest/DeveloperGuide/Welcome.html) panggilan ke titik akhir antarmuka Lambda. Jika Anda menggunakan penyedia DNS yang berbeda, Anda harus memetakan `lambda.region.amazonaws.co` m, ke titik akhir antarmuka Lambda Anda.
# 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:
![\[The Dockerfile structure has inference scripts under the NER directory next to the Dockerfile.\]](http://docs.aws.amazon.com/id_id/sagemaker/latest/dg/images/docker-file-struct-adapt-ex.png)
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 Wilayah AWS.
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).