Mengaktifkan alur kerja ML hybrid di Amazon EKS dan Amazon SageMaker dengan Kubeflow sekali klik di penerapan AWS

Saat ini, banyak pelanggan AWS membangun platform machine learning (ML) yang siap untuk perusahaan Layanan Amazon Elastic Kubernetes (Amazon EKS) menggunakan Kubeflow di AWS (distribusi Kubeflow khusus AWS) di banyak kasus penggunaan, termasuk visi komputer, pemahaman bahasa alami, terjemahan ucapan, dan pemodelan keuangan.

Dengan rilis terbaru dari open-source Kubeflow v1.6.1, komunitas Kubeflow terus mendukung adopsi Kubeflow skala besar ini untuk kasus penggunaan perusahaan. Rilis terbaru mencakup banyak fitur baru yang menarik seperti dukungan untuk Kubernetes v1.22, gabungan Python SDK untuk PyTorch, MXNet, MPI, XGBoost di Operator Pelatihan terdistribusi Kubeflow, ClusterServingRuntime baru dan ServingRuntime CRD untuk layanan model, dan banyak lagi.

Kontribusi AWS untuk Kubeflow dengan peluncuran Kubeflow baru-baru ini di AWS 1.6.1 mendukung semua fitur Kubeflow sumber terbuka upstream dan menyertakan banyak integrasi baru dengan layanan AWS yang sangat dioptimalkan, cloud-native, dan siap untuk perusahaan yang akan membantu Anda membangun dengan sangat andal, sistem ML yang aman, portabel, dan dapat diskalakan.

Dalam postingan ini, kami membahas fitur Kubeflow baru di AWS v1.6.1 dan menyoroti tiga integrasi penting yang telah dipaketkan pada satu platform untuk ditawarkan kepada Anda::

• Solusi satu-klik Infrastruktur sebagai Kode (IaaC) yang mengotomatiskan instalasi Kubeflow end-to-end, termasuk pembuatan cluster EKS
• Dukungan untuk pelatihan yang didistribusikan Amazon SageMaker menggunakan Operator Amazon SageMaker untuk Kubernetes (AK) dan Komponen SageMaker untuk pipeline Kubeflow dan secara lokal menggunakan Kubernetes Operator Pelatihan Kubeflow. Banyak pelanggan menggunakan kemampuan ini untuk membangun arsitektur pembelajaran mesin hybrid dengan memanfaatkan komputasi Kubernetes untuk fase eksperimen dan SageMaker untuk menjalankan beban kerja skala produksi.
• Peningkatan pemantauan dan pengamatan untuk beban kerja ML termasuk Amazon EKS, metrik Kubeflow, dan log aplikasi menggunakan Prometheus, Grafana, dan amazoncloudwatch integrasi

Kasus penggunaan di blog ini secara khusus akan berfokus pada integrasi SageMaker dengan Kubeflow di AWS yang dapat ditambahkan ke alur kerja Kubernetes Anda yang sudah ada sehingga memungkinkan Anda membangun arsitektur pembelajaran mesin hybrid.

Kubeflow di AWS

Kubeflow di AWS 1.6.1 menyediakan jalur yang jelas untuk menggunakan Kubeflow, dengan penambahan layanan AWS berikut di atas kemampuan yang sudah ada:

• Integrasi SageMaker dengan Kubeflow untuk menjalankan alur kerja hybrid ML menggunakan SageMaker Operators for Kubernetes (ACK) dan SageMaker Components untuk Kubeflow Pipelines.
• Opsi penyebaran otomatis telah ditingkatkan dan disederhanakan menggunakan skrip Kustomisasi dan bagan Helm.
• Menambahkan dukungan untuk penerapan sekali klik Infrastruktur sebagai Kode (IaC) untuk Kubeflow di AWS menggunakan Terraform untuk semua yang tersedia opsi penempatan. Skrip ini mengotomatiskan pembuatan sumber daya AWS berikut:
• Dukungan untuk Tautan Pribadi AWS untuk Amazon S3 memungkinkan pengguna Wilayah non-komersial untuk terhubung ke titik akhir S3 masing-masing.
• Menambahkan integrasi dengan Layanan Terkelola Amazon untuk Prometheus (AMP) dan Grafana yang Dikelola Amazon untuk memantau metrik dengan Kubeflow di AWS.
• Kontainer server notebook Kubeflow diperbarui dengan gambar kontainer pembelajaran mendalam terbaru berdasarkan TensorFlow 2.10.0 dan PyTorch 1.12.1.
• Integrasi dengan AWS DLC untuk dijalankan secara terdistribusi latihan dan kesimpulan beban kerja.

Diagram arsitektur berikut adalah snapshot cepat dari semua integrasi layanan (termasuk yang telah disebutkan) yang tersedia untuk kontrol Kubeflow dan komponen bidang data di Kubeflow di AWS. Bidang kontrol Kubeflow dipasang di atas Amazon EKS, yang merupakan layanan kontainer terkelola yang digunakan untuk menjalankan dan menskalakan aplikasi Kubernetes di cloud. Integrasi layanan AWS ini memungkinkan Anda memisahkan bagian-bagian penting bidang kontrol Kubeflow dari Kubernetes, menyediakan desain yang aman, dapat diskalakan, tangguh, dan hemat biaya. Untuk detail lebih lanjut tentang nilai yang ditambahkan oleh integrasi layanan ini melalui Kubeflow sumber terbuka, lihat Bangun dan terapkan sistem pembelajaran mesin yang skalabel di Kubernetes dengan Kubeflow di AWS.

Mari kita bahas lebih detail tentang bagaimana fitur utama Kubeflow di AWS 1.6.1 dapat membantu organisasi Anda.

Detail fitur Kubeflow di AWS

Dengan rilis Kubeflow 1.6.1, kami mencoba menyediakan alat yang lebih baik untuk berbagai jenis pelanggan yang memudahkan untuk memulai dengan Kubeflow apa pun opsi yang Anda pilih. Alat-alat ini memberikan titik awal yang baik dan dapat dimodifikasi agar sesuai dengan kebutuhan Anda.

Opsi penempatan

Kami menyediakan opsi penerapan yang berbeda untuk kasus penggunaan pelanggan yang berbeda. Di sini Anda dapat memilih layanan AWS mana yang ingin Anda integrasikan dengan penerapan Kubeflow Anda. Jika Anda memutuskan untuk mengubah opsi penerapan di lain waktu, sebaiknya lakukan penginstalan baru untuk penerapan baru. Opsi penyebaran berikut tersedia:

Jika Anda ingin menerapkan Kubeflow dengan sedikit perubahan, pertimbangkan vanila opsi penerapan. Semua opsi penerapan yang tersedia dapat diinstal menggunakan Kustomize, Helm, atau Terraform.

Kami juga memiliki penerapan add-on berbeda yang dapat dipasang di atas salah satu opsi penerapan ini:

Opsi pemasangan

Setelah Anda memutuskan opsi penerapan mana yang paling sesuai dengan kebutuhan Anda, Anda dapat memilih bagaimana Anda ingin menginstal penerapan ini. Dalam upaya untuk melayani para ahli dan pendatang baru, kami memiliki tingkat otomatisasi dan konfigurasi yang berbeda.

Opsi 1: Terraform (IaC)

Ini membuat klaster EKS dan semua sumber daya infrastruktur AWS terkait, lalu menerapkan semua Kubeflow dalam satu perintah menggunakan Terraform. Secara internal, ini menggunakan cetak biru EKS dan grafik Helm.

Opsi ini memiliki keuntungan sebagai berikut:

• Ini memberikan fleksibilitas kepada perusahaan untuk menerapkan Amazon EKS dan Kubeflow dengan satu perintah tanpa harus mengkhawatirkan konfigurasi komponen Kubeflow tertentu. Ini akan sangat membantu mempercepat evaluasi teknologi, pembuatan prototipe, dan siklus hidup pengembangan produk yang memberikan fleksibilitas untuk menggunakan modul terraform dan memodifikasinya untuk memenuhi kebutuhan spesifik proyek apa pun.
• Banyak organisasi saat ini yang menjadikan Terraform sebagai pusat strategi cloud mereka sekarang dapat menggunakan Kubeflow pada solusi AWS Terraform untuk memenuhi sasaran cloud mereka.

Opsi 2: Sesuaikan atau Bagan Helm:

Opsi ini memungkinkan Anda menerapkan Kubeflow dalam proses dua langkah:

1. Buat sumber daya AWS seperti Amazon EKS, Amazon RDS, Amazon S3, dan Amazon Cognito, baik melalui skrip otomatis yang disertakan dalam distribusi AWS atau mengikuti a langkah-demi-langkah panduan.
2. Instal penerapan Kubeflow menggunakan diagram Helm atau Kustomisasi.

Opsi ini memiliki keuntungan sebagai berikut:

• Tujuan utama dari opsi instalasi ini adalah untuk menyediakan konfigurasi Kubernetes terkait Kubeflow. Oleh karena itu, Anda dapat memilih untuk membuat atau memasukkan klaster EKS yang ada atau sumber daya AWS terkait lainnya seperti Amazon RDS, Amazon S3, dan Amazon Cognito, serta mengonfigurasi dan mengelolanya agar berfungsi dengan Kubeflow di AWS.
• Lebih mudah untuk berpindah dari manifes Kustomize Kubeflow sumber terbuka ke distribusi AWS Kubeflow.

Diagram berikut mengilustrasikan arsitektur dari kedua opsi.

Integrasi dengan SageMaker

SageMaker adalah layanan terkelola sepenuhnya yang dirancang dan dioptimalkan khusus untuk mengelola alur kerja ML. Ini menghilangkan beban berat manajemen infrastruktur yang tidak dapat dibedakan dan menghilangkan kebutuhan untuk berinvestasi di TI dan DevOps untuk mengelola klaster untuk pembangunan, pelatihan, dan inferensi model ML.

Banyak pelanggan AWS yang memiliki persyaratan portabilitas atau pembatasan standar lokal menggunakan Amazon EKS untuk menyiapkan pipeline ML berulang yang menjalankan pelatihan dan beban kerja inferensi. Namun, hal ini mengharuskan pengembang untuk menulis kode khusus guna mengoptimalkan infrastruktur ML yang mendasarinya, memberikan ketersediaan dan keandalan yang tinggi, serta mematuhi persyaratan keamanan dan peraturan yang sesuai. Oleh karena itu, pelanggan ini ingin menggunakan SageMaker untuk infrastruktur terkelola dan dioptimalkan biaya untuk pelatihan model dan penerapan serta terus menggunakan Kubernetes untuk orkestrasi dan pipeline ML guna mempertahankan standarisasi dan portabilitas.

Untuk mengatasi kebutuhan ini, AWS memungkinkan Anda untuk melatih, menyetel, dan menerapkan model di SageMaker dari Amazon EKS dengan menggunakan dua opsi berikut:

• Operator ACK Amazon SageMaker untuk Kubernetes, yang didasarkan pada Pengontrol AWS untuk Kubernetes (ACK) kerangka kerja. ACK adalah strategi AWS yang menghadirkan standarisasi untuk membangun pengontrol kustom Kubernetes yang memungkinkan pengguna Kubernetes menyediakan sumber daya AWS seperti database atau antrean pesan hanya dengan menggunakan API Kubernetes. Operator ACK SageMaker memudahkan pengembang ML dan ilmuwan data yang menggunakan Kubernetes sebagai bidang kontrol mereka untuk melatih, menyetel, dan menerapkan model ML di SageMaker tanpa masuk ke konsol SageMaker.
• Grafik Komponen SageMaker untuk Pipeline Kubeflow, yang memungkinkan Anda mengintegrasikan SageMaker dengan portabilitas dan orkestrasi Kubeflow Pipelines. Dengan komponen SageMaker, setiap tugas dalam alur kerja pipeline berjalan di SageMaker, bukan di kluster Kubernetes lokal. Hal ini memungkinkan Anda untuk membuat dan memantau pelatihan SageMaker asli, penyetelan, penerapan titik akhir, dan tugas transformasi batch dari Kubeflow Pipelines sehingga memungkinkan Anda untuk memindahkan komputasi lengkap termasuk pemrosesan data dan tugas pelatihan dari kluster Kubernetes ke layanan terkelola yang dioptimalkan pembelajaran mesin SageMaker.

Dimulai dengan Kubeflow di AWS v1.6.1, semua opsi penerapan Kubeflow yang tersedia menyatukan kedua opsi integrasi Amazon SageMaker secara default pada satu platform. Artinya, Anda sekarang dapat mengirimkan pekerjaan SageMaker menggunakan operator ACK SageMaker dari server Kubeflow Notebook itu sendiri dengan mengirimkan sumber daya SageMaker kustom atau dari langkah pipeline Kubeflow menggunakan komponen SageMaker.

Ada dua versi Komponen SageMaker – bot3 (AWS SDK untuk AWS SDK untuk Python) berbasis komponen versi 1 dan komponen versi 8 berbasis SageMaker Operator for K2s (ACK). Komponen SageMaker baru versi 2 mendukung api pelatihan SageMaker terbaru dan kami akan terus menambahkan lebih banyak fitur SageMaker ke versi komponen ini. Namun, Anda memiliki fleksibilitas untuk menggabungkan komponen Sagemaker versi 2 untuk pelatihan dan versi 1 untuk fitur SageMaker lainnya seperti penyetelan hyperparameter, tugas pemrosesan, hosting, dan banyak lagi.

Integrasi dengan Prometheus dan Grafana

Prometheus adalah alat agregasi metrik sumber terbuka yang dapat Anda konfigurasikan untuk dijalankan di kluster Kubernetes. Saat berjalan di kluster Kubernetes, server utama Prometheus secara berkala menghapus titik akhir pod.

Komponen Kubeflow, seperti Kubeflow Pipelines (KFP) dan Notebook, mengeluarkan metrik Prometheus untuk memungkinkan pemantauan sumber daya komponen seperti jumlah eksperimen yang berjalan atau jumlah notebook.

Metrik ini dapat digabungkan oleh server Prometheus yang berjalan di kluster Kubernetes dan dikueri menggunakan Prometheus Query Language (PromQL). Untuk detail lebih lanjut tentang fitur yang didukung Prometheus, lihat dokumentasi Prometheus.

Distribusi Kubeflow on AWS menyediakan dukungan untuk integrasi dengan layanan terkelola AWS berikut:

1. Amazon Managed Prometheus (AMP) yaitu a Prometheus-layanan pemantauan yang kompatibel untuk infrastruktur kontainer dan metrik aplikasi untuk kontainer yang memudahkan pelanggan untuk memantau lingkungan kontainer dalam skala besar dengan aman. Dengan menggunakan AMP, Anda dapat memvisualisasikan, menganalisis, dan memberi peringatan pada metrik, log, dan pelacakan yang dikumpulkan dari berbagai sumber data di sistem keteramatan Anda, termasuk AWS, ISV pihak ketiga, dan sumber daya lainnya di seluruh portofolio TI Anda.
2. Amazon Managed Grafana, layanan visualisasi data yang dikelola sepenuhnya dan aman berdasarkan sumber terbuka grafana proyek, yang memungkinkan pelanggan untuk langsung membuat kueri, menghubungkan, dan memvisualisasikan metrik operasional, log, dan pelacakan untuk aplikasi mereka dari berbagai sumber data. Amazon Managed Grafana membongkar manajemen operasional Grafana dengan secara otomatis menskalakan komputasi dan infrastruktur database seiring meningkatnya permintaan penggunaan, dengan pembaruan versi otomatis dan patching keamanan.

Distribusi Kubeflow di AWS memberikan dukungan untuk integrasi Amazon Managed Service for Prometheus dan Amazon Managed Grafana untuk memfasilitasi penyerapan dan visualisasi metrik Prometheus secara aman dalam skala besar.

Metrik berikut diserap dan dapat divisualisasikan:

• Metrik yang dikeluarkan dari komponen Kubeflow seperti Kubeflow Pipelines dan server Notebook
• kubeflow metrik bidang kontrol

Untuk mengonfigurasi Amazon Managed Service for Prometheus dan Amazon Managed Grafana untuk klaster Kubeflow Anda, lihat Gunakan Prometheus, Amazon Managed Service for Prometheus, dan Amazon Managed Grafana untuk memantau metrik dengan Kubeflow di AWS.

Ikhtisar solusi

Dalam kasus penggunaan ini, kami menggunakan Kubeflow vanilla deployment menggunakan opsi instalasi Terraform. Saat instalasi selesai, kami masuk ke dasbor Kubeflow. Dari dasbor, kami mengaktifkan server notebook Kubeflow Jupyter untuk membuat pipeline Kubeflow yang menggunakan SageMaker untuk menjalankan pelatihan terdistribusi untuk model klasifikasi gambar dan titik akhir SageMaker untuk penerapan model.

Prasyarat

Pastikan Anda memenuhi prasyarat berikut:

• Anda punya Akun AWS.
• Pastikan Anda berada di us-west-2 Wilayah untuk menjalankan contoh ini.
• Gunakan Google Chrome untuk berinteraksi dengan Konsol Manajemen AWS dan Kubeflow.
• Pastikan akun Anda memiliki batas jenis sumber daya Pelatihan SageMaker untuk ml.p3.2xlarge yang ditingkatkan menjadi 2 menggunakan konsol Service Quotas.
• Secara opsional, Anda dapat menggunakan AWS Cloud9, lingkungan pengembangan terintegrasi (IDE) berbasis cloud yang memungkinkan menyelesaikan semua pekerjaan dari browser web Anda. Untuk petunjuk pengaturan, lihat Siapkan Cloud9 IDE. Pilih Ubuntu Server 18.04 sebagai platform di pengaturan AWS Cloud9.Kemudian dari lingkungan AWS Cloud9 Anda, pilih tanda tambah dan buka terminal baru.

Anda juga mengonfigurasi file Antarmuka Baris Perintah AWS (AWS CLI) profil. Untuk melakukannya, Anda memerlukan ID kunci akses dan kunci akses rahasia dari suatu Identitas AWS dan Manajemen Akses (IAM) pemakai akun dengan hak administratif (lampirkan kebijakan terkelola yang ada) dan akses terprogram. Lihat kode berikut:

aws configure --profile=kubeflow

AWS Access Key ID [None]: 
AWS Secret Access Key [None]: 
Default region name [None]: us-west-2
Default output format [None]: json

# (In Cloud9, select “Cancel” and “Permanently disable” when the AWS managed temporary credentials dialog pops up)

export AWS_PROFILE=kubeflow

Verifikasi izin yang akan digunakan cloud9 untuk memanggil sumber daya AWS.

aws sts get-caller-identity

Verifikasi dari output di bawah ini bahwa Anda melihat pengguna admin yang telah Anda konfigurasikan di profil AWS CLI. Dalam contoh ini adalah "kubeflow-user"

{
    "UserId": "*******",
    "Account": "********",
    "Arn": "arn:aws:iam::*******:user/kubeflow-user"
}

Instal Amazon EKS dan Kubeflow di AWS

Untuk menginstal Amazon EKS dan Kubeflow di AWS, selesaikan langkah-langkah berikut:

1. Siapkan lingkungan Anda untuk menerapkan Kubeflow di AWS:

   #Clone the awslabs/kubeflow-manifests and the kubeflow/manifests repositories and check out the release branches of your choosing
   export KUBEFLOW_RELEASE_VERSION=v1.6.1
   export AWS_RELEASE_VERSION=v1.6.1-aws-b1.0.0
   git clone https://github.com/awslabs/kubeflow-manifests.git && cd kubeflow-manifests
   git checkout ${AWS_RELEASE_VERSION}
   git clone --branch ${KUBEFLOW_RELEASE_VERSION} https://github.com/kubeflow/manifests.git upstream
   
   export MANIFEST_DIR=$PWD

   #Install the necessary tools with the following command:
   make install-tools
   source ~/.bash_profile

2. Terapkan Kubeflow versi vanilla di AWS dan sumber daya AWS terkait seperti EKS menggunakan Terraform. Harap perhatikan bahwa volume EBS yang digunakan dalam grup node EKS tidak dienkripsi secara default:

   #Define the following environment variables
   
   #Region to create the cluster in
   export CLUSTER_REGION=us-west-2
   #Name of the cluster to create
   export CLUSTER_NAME=

   cd deployments/vanilla/terraform
   
   #Save the variables to a .tfvars file
   cat < sample.auto.tfvars
   cluster_name="${CLUSTER_NAME}"
   cluster_region="${CLUSTER_REGION}"
   EOF
   
   #Run the following one-click command to deploy terraform to install EKS infrastructure and Kubeflow
   make deploy

Siapkan Izin Kubeflow

1. Menambahkan izin ke pod Notebook dan pod komponen Pipeline untuk membuat panggilan api SageMaker, S3, dan IAM menggunakan kubeflow_iam_permissions.sh Script.

   export NAMESPACE=kubeflow-user-example-com
   
   wget https://raw.githubusercontent.com/aws-samples/eks-kubeflow-cloudformation-quick-start/9e46662d97e1be7edb0be7fc31166e545655636a/utils/kubeflow_iam_permissions.sh
   chmod +x kubeflow_iam_permissions.sh
   ./kubeflow_iam_permissions.sh $NAMESPACE $CLUSTER_NAME $CLUSTER_REGION

2. Buat peran eksekusi SageMaker untuk mengaktifkan tugas pelatihan SageMaker untuk mengakses dataset pelatihan dari layanan S3 menggunakan sagemaker_role.sh Script.

   wget https://raw.githubusercontent.com/aws-samples/eks-kubeflow-cloudformation-quick-start/9e46662d97e1be7edb0be7fc31166e545655636a/utils/sagemaker_role.sh
   chmod +x sagemaker_role.sh
   ./sagemaker_role.sh

Akses dasbor Kubeflow

Untuk mengakses dasbor Kubeflow, selesaikan langkah-langkah berikut:

1. Anda dapat menjalankan dasbor Kubeflow secara lokal di lingkungan Cloud9 tanpa memaparkan URL Anda ke internet publik dengan menjalankan perintah di bawah ini.

   # Configure Kubecontext
   $(terraform output -raw configure_kubectl)
   
   cd ${MANIFEST_DIR}
   make port-forward

2. Pilih Pratinjau Aplikasi yang Berjalan.
3. Pilih ikon di pojok dasbor Kubeflow untuk membukanya sebagai tab terpisah di Chrome.
4. Masukkan kredensial default (user@example.com/12341234) untuk masuk ke dasbor Kubeflow.

Siapkan Kubeflow di lingkungan AWS

Setelah Anda masuk ke dasbor Kubeflow, pastikan Anda memiliki namespace yang tepat (kubeflow-user-example-com) terpilih. Selesaikan langkah-langkah berikut untuk menyiapkan Kubeflow Anda di lingkungan AWS:

1. Di dasbor Kubeflow, pilih notebook di panel navigasi.
2. Pilih Notebook Baru.
3. Untuk Nama, Masuk aws-nb.
4. Untuk Gambar Docket Jupyter, pilih gambar jupyter-pytorch:1.12.0-cpu-py38-ubuntu20.04-ec2-2022-09-20 (terbaru tersedia jupyter-pytorch gambar DLC).
5. Untuk CPU, Masuk 1.
6. Untuk Memori, Masuk 5.
7. Untuk GPU, tinggalkan sebagai None.
8. Jangan membuat perubahan apa pun pada ruang kerja dan Volume Data bagian.
9. Pilih Izinkan akses ke Kubeflow Pipeline dalam Konfigurasi bagian dan Pilih Luncurkan.
10. Pastikan buku catatan Anda berhasil dibuat (mungkin perlu beberapa menit).
11. Pilih Terhubung untuk masuk ke JupyterLab.
12. Kloning repo dengan memasukkan https://github.com/aws-samples/eks-kubeflow-cloudformation-quick-start.git dalam Mengkloning repo lapangan.
13. Pilih Klon.

Jalankan contoh pelatihan terdistribusi

Setelah Anda mengatur notebook Jupyter, Anda dapat menjalankan seluruh demo menggunakan langkah-langkah tingkat tinggi berikut dari folder eks-kubeflow-cloudformation-quick-start/workshop/pytorch-distributed-training di repositori kloning:

1. Jalankan skrip pelatihan PyTorch Distributed Data Parallel (DDP). – Lihat skrip pelatihan PyTorch DDP cifar10-distributed-gpu-final.py, yang menyertakan sampel jaringan neural konvolusional dan logika untuk mendistribusikan pelatihan pada CPU multi-node dan klaster GPU.
2. Buat pipa Kubeflow – Jalankan buku catatan STEP1.0_create_pipeline_k8s_sagemaker.ipynb untuk membuat pipeline yang menjalankan dan menerapkan model di SageMaker. Pastikan Anda menginstal pustaka SageMaker sebagai bagian dari sel notebook pertama dan memulai ulang kernel sebelum Anda menjalankan sel notebook lainnya.
3. Panggil titik akhir SageMaker – Jalankan buku catatan STEP1.1_invoke_sagemaker_endpoint.ipynb untuk memanggil dan menguji titik akhir inferensi model SageMaker yang dibuat di notebook sebelumnya.

Pada bagian selanjutnya, kami membahas masing-masing langkah ini secara rinci.

Jalankan skrip pelatihan DDP PyTorch

Sebagai bagian dari pelatihan terdistribusi, kami melatih model klasifikasi yang dibuat oleh jaringan saraf convolutional sederhana yang beroperasi pada kumpulan data CIFAR10. Skrip pelatihan cifar10-distributed-gpu-final.py hanya berisi library open-source dan kompatibel untuk dijalankan pada kluster pelatihan Kubernetes dan SageMaker pada perangkat GPU atau instance CPU. Mari kita lihat beberapa aspek penting dari skrip pelatihan sebelum kita menjalankan contoh buku catatan kita.

Kami menggunakan torch.distributed modul, yang berisi dukungan PyTorch dan komunikasi primitif untuk paralelisme multi-proses di seluruh node dalam cluster:

...
import torch
import torch.distributed as dist
import torch.nn as nn
import torch.nn.functional as F
import torch.optim as optim
import torch.utils.data
import torch.utils.data.distributed
import torchvision
from torchvision import datasets, transforms
...

Kami membuat model klasifikasi gambar sederhana menggunakan kombinasi lapisan convolutional, max pooling, dan linear yang a relu fungsi aktivasi diterapkan dalam forward pass dari pelatihan model:

# Define models
class Net(nn.Module):
def __init__(self):
super(Net, self).__init__()
self.conv1 = nn.Conv2d(3, 6, 5)
self.pool = nn.MaxPool2d(2, 2)
self.conv2 = nn.Conv2d(6, 16, 5)
self.fc1 = nn.Linear(16 * 5 * 5, 120)
self.fc2 = nn.Linear(120, 84)
self.fc3 = nn.Linear(84, 10)

def forward(self, x):
x = self.pool(F.relu(self.conv1(x)))
x = self.pool(F.relu(self.conv2(x)))
x = x.view(-1, 16 * 5 * 5)
x = F.relu(self.fc1(x))
x = F.relu(self.fc2(x))
x = self.fc3(x)
return x

Jika kluster pelatihan memiliki GPU, skrip menjalankan pelatihan pada perangkat CUDA dan variabel perangkat menyimpan perangkat CUDA default:

device = "cuda" if torch.cuda.is_available() else "cpu"
...

Sebelum Anda menjalankan pelatihan terdistribusi menggunakan PyTorch DistributedDataParallel untuk menjalankan pemrosesan terdistribusi pada banyak node, Anda perlu menginisialisasi lingkungan terdistribusi dengan memanggil init_process_group. Ini diinisialisasi pada setiap mesin dari cluster pelatihan.

dist.init_process_group(backend=args.backend, rank=host_rank, world_size=world_size)
...

Kami membuat instance model classifier dan menyalin model ke perangkat target. Jika pelatihan terdistribusi diaktifkan untuk berjalan di beberapa node, DistributedDataParallel class digunakan sebagai objek pembungkus di sekitar objek model, yang memungkinkan pelatihan terdistribusi secara sinkron di beberapa mesin. Data input dibagi berdasarkan dimensi batch dan replika model ditempatkan di setiap mesin dan setiap perangkat. Lihat kode berikut:

model = Net().to(device)

if is_distributed:
model = torch.nn.parallel.DistributedDataParallel(model)

...

Buat pipa Kubeflow

Buku catatan menggunakan Kubeflow Pipeline SDK dan kumpulan paket Python yang disediakan untuk menentukan dan menjalankan pipeline alur kerja ML. Sebagai bagian dari SDK ini, kami menggunakan dekorator paket domain-specific language (DSL). dsl.pipeline, yang menghiasi fungsi Python untuk mengembalikan saluran pipa.

Pipeline Kubeflow menggunakan komponen V2 SageMaker untuk mengirimkan pelatihan ke SageMaker menggunakan Operator ACK SageMaker. Pembuatan model SageMaker dan penerapan model menggunakan komponen SageMaker V1, yang merupakan komponen SageMaker berbasis Boto3. Kami menggunakan kombinasi kedua komponen dalam contoh ini untuk menunjukkan fleksibilitas pilihan Anda.

1. Muat komponen SageMaker menggunakan kode berikut:

   # Loads SageMaker training components v2 for Kubeflow pipeline from the URL
   sagemaker_train_ack_op = components.load_component_from_url('https://raw.githubusercontent.com/kubeflow/pipelines/d4aaa03035f221351ebe72fbd74fcfccaf25bb66/components/aws/sagemaker/TrainingJob/component.yaml')
   
   # Loads SageMaker components v1 for Kubeflow pipeline from the URL
   sagemaker_model_op = components.load_component_from_url('https://raw.githubusercontent.com/kubeflow/pipelines/cb36f87b727df0578f4c1e3fe9c24a30bb59e5a2/components/aws/sagemaker/model/component.yaml')
   sagemaker_deploy_op = components.load_component_from_url('https://raw.githubusercontent.com/kubeflow/pipelines/cb36f87b727df0578f4c1e3fe9c24a30bb59e5a2/components/aws/sagemaker/deploy/component.yaml')

   Dalam kode berikut, kami membuat pipeline Kubeflow tempat kami menjalankan pelatihan terdistribusi SageMaker menggunakan dua ml.p3.2xlarge contoh:

   # Create Kubeflow Pipeline using Amazon SageMaker Service
   @dsl.pipeline(name="PyTorch Training pipeline", description="Sample training job test")
   def pytorch_cnn_pipeline(region=target_region,
   train_image=aws_dlc_sagemaker_train_image,
   serving_image=aws_dlc_sagemaker_serving_image,
   learning_rate='0.01',
   pytorch_backend='gloo',
   training_job_name=pytorch_distributed_jobname,
   instance_type='ml.p3.2xlarge',
   instance_count='2',
   network_isolation='False',
   traffic_encryption='False',
   ):
   
   # Step to run training on SageMaker using SageMaker Components V2 for Pipeline.
   training = sagemaker_train_ack_op(
   region=region,
   algorithm_specification=(f'{{ '
   f'"trainingImage": "{train_image}",'
   '"trainingInputMode": "File"'
   f'}}'),
   training_job_name=training_job_name,
   hyper_parameters=(f'{{ '
   f'"backend": "{pytorch_backend}",'
   '"batch-size": "64",'
   '"epochs": "10",'
   f'"lr": "{learning_rate}",'
   '"model-type": "custom",'
   '"sagemaker_container_log_level": "20",'
   '"sagemaker_program": "cifar10-distributed-gpu-final.py",'
   f'"sagemaker_region": "{region}",'
   f'"sagemaker_submit_directory": "{source_s3}"'
   f'}}'),
   resource_config=(f'{{ '
   f'"instanceType": "{instance_type}",'
   f'"instanceCount": {instance_count},'
   '"volumeSizeInGB": 50'
   f'}}'),
   input_data_config=training_input(datasets),
   output_data_config=training_output(bucket_name),
   enable_network_isolation=network_isolation,
   enable_inter_container_traffic_encryption=traffic_encryption,
   role_arn=role,
   stopping_condition={"maxRuntimeInSeconds": 3600}
   )
   
   model_artifact_url = get_s3_model_artifact_op(
   training.outputs["model_artifacts"]
   ).output
   
   # This step creates SageMaker Model which refers to model artifacts and inference script to deserialize the input image
   create_model = sagemaker_model_op(
   region=region,
   model_name=training_job_name,
   image=serving_image,
   model_artifact_url=model_artifact_url,
   network_isolation=network_isolation,
   environment=(f'{{ '
   '"SAGEMAKER_CONTAINER_LOG_LEVEL": "20",'
   '"SAGEMAKER_PROGRAM": "inference.py",'
   f'"SAGEMAKER_REGION": "{region}",'
   f'"SAGEMAKER_SUBMIT_DIRECTORY": "{model_artifact_url}"'
   f'}}'),
   role=role
   )
   
   # This step creates SageMaker Endpoint which will be called to run inference
   prediction = sagemaker_deploy_op(
   region=region,
   model_name_1=create_model.output,
   instance_type_1='ml.c5.xlarge'
   )
   
   #Disable pipeline cache
   training.execution_options.caching_strategy.max_cache_staleness = "P0D"

   Setelah pipeline ditentukan, Anda dapat mengompilasi pipeline ke spesifikasi Argo YAML menggunakan Kubeflow Pipelines SDK kfp.compiler kemasan. Anda dapat menjalankan pipeline ini menggunakan klien Kubeflow Pipelines SDK, yang memanggil titik akhir layanan Pipelines dan meneruskan header autentikasi yang sesuai langsung dari notebook. Lihat kode berikut:

   # DSL Compiler that compiles pipeline functions into workflow yaml.
   kfp.compiler.Compiler().compile(pytorch_cnn_pipeline, "pytorch_cnn_pipeline.yaml")
   
   # Connect to Kubeflow Pipelines using the Kubeflow Pipelines SDK client
   client = kfp.Client()
   
   experiment = client.create_experiment(name="ml_workflow")
   
   # Run a specified pipeline
   my_run = client.run_pipeline(experiment.id, "pytorch_cnn_pipeline", "pytorch_cnn_pipeline.yaml")
   
   # Please click “Run details” link generated below this cell to view your pipeline. You can click every pipeline step to see logs.

2. Pilih Jalankan detail tautan di bawah sel terakhir untuk melihat pipa Kubeflow. Tangkapan layar berikut menampilkan detail alur kami untuk komponen pelatihan dan penerapan SageMaker.
3. Pilih langkah pekerjaan pelatihan dan di Log tab, pilih tautan log CloudWatch untuk mengakses log SageMaker.
   Tangkapan layar berikut menunjukkan log CloudWatch untuk masing-masing dari dua instans ml.p3.2xlarge.
4. Pilih salah satu grup untuk melihat log.
5. Abadikan titik akhir SageMaker dengan memilih Sagemaker – Terapkan Model langkah dan menyalin endpoint_name nilai artefak keluaran.

Panggil titik akhir SageMaker

Buku catatan STEP1.1_invoke_sagemaker_endpoint.ipynb memanggil titik akhir inferensi SageMaker yang dibuat di langkah sebelumnya. Pastikan Anda memperbarui nama titik akhir:

# Invoke SageMaker Endpoint. * Ensure you update the endpoint
# You can grab the SageMaker Endpoint name by either 1) going to the pipeline visualization of Kubeflow console and click the component for deployment, or 2) Go to SageMaker console and go to the list of endpoints, and then substitute the name to the EndpointName='...' in this cell.

endpointName=''

response = client.invoke_endpoint(EndpointName=endpointName,
ContentType='application/x-image',
Body=payload)

pred = json.loads(response['Body'].read().decode())

output_vector_list=pred['score']

# Get outout vector of 10 classes
output_vector = output_vector_list[0]

# Find the class with highest probability
max=output_vector[0]
index = 0
for i in range(1,len(output_vector)):
if output_vector[i] > max:
max = output_vector[i]
index = i

print(f'Index of the maximum value is : {index}')

labels = ['airplane','automobile','bird','cat','deer','dog','frog','horse','ship','truck']

print(labels[index])

Membersihkan

Untuk membersihkan sumber daya Anda, selesaikan langkah-langkah berikut:

1. Jalankan perintah berikut di AWS Cloud9 untuk menghapus sumber daya AWS:

   cd ${MANIFEST_DIR}/deployments/vanilla/terraform
   make delete

2. Hapus peran IAM “sagemakerrole” menggunakan perintah AWS CLI berikut:

   aws iam detach-role-policy --role-name sagemakerrole --policy-arn arn:aws:iam::aws:policy/AmazonSageMakerFullAccess
   aws iam detach-role-policy --role-name sagemakerrole --policy-arn arn:aws:iam::aws:policy/AmazonS3FullAccess
   aws iam delete-role --role-name sagemakerrole

3. Hapus titik akhir SageMaker menggunakan perintah AWS CLI berikut:

   aws sagemaker delete-endpoint --endpoint-name  --region us-west-2

Kesimpulan

Dalam postingan ini, kami menyoroti nilai yang disediakan Kubeflow di AWS 1.6.1 melalui integrasi layanan yang dikelola AWS asli untuk memenuhi kebutuhan kasus penggunaan AI dan ML tingkat perusahaan. Anda dapat memilih dari beberapa opsi penerapan untuk menginstal Kubeflow di AWS dengan berbagai integrasi layanan menggunakan Terraform, Kustomize, atau Helm. Kasus penggunaan dalam postingan ini menunjukkan integrasi Kubeflow dengan SageMaker yang menggunakan klaster pelatihan terkelola SageMaker untuk menjalankan pelatihan terdistribusi untuk model klasifikasi gambar dan titik akhir SageMaker untuk penerapan model.

Kami juga telah menyediakan a contoh pipa contoh yang menggunakan komponen SageMaker terbaru; Anda dapat menjalankan ini langsung dari dasbor Kubeflow. Pipa ini membutuhkan Data Amazon S3 dan Peran IAM eksekusi SageMaker sebagai input yang dibutuhkan.

Untuk memulai dengan Kubeflow di AWS, lihat opsi penerapan terintegrasi AWS yang tersedia di Kubeflow di AWS. Anda dapat mengikuti Repositori AWS Labs untuk melacak semua kontribusi AWS ke Kubeflow. Anda juga dapat menemukan kami di Saluran Kubeflow #AWS Slack; umpan balik Anda akan membantu kami memprioritaskan fitur berikutnya untuk berkontribusi pada proyek Kubeflow.

Tentang penulis

Kanwaljit Khurmi adalah Arsitek Solusi Senior di Amazon Web Services. Dia bekerja dengan pelanggan AWS untuk memberikan panduan dan bantuan teknis yang membantu mereka meningkatkan nilai solusi mereka saat menggunakan AWS. Kanwaljit mengkhususkan diri dalam membantu pelanggan dengan aplikasi kemas dan pembelajaran mesin.

Kartik Kalamadi adalah Insinyur Pengembangan Perangkat Lunak di Amazon AI. Saat ini berfokus pada proyek sumber terbuka Machine Learning Kubernetes seperti Kubeflow dan AWS SageMaker Controller untuk k8s. Di waktu senggang saya suka bermain Game PC dan mengutak-atik VR menggunakan mesin Unity.

Rahul Kharse adalah Insinyur Pengembangan Perangkat Lunak di Amazon Web Services. Pekerjaannya berfokus pada pengintegrasian layanan AWS dengan platform open source containerized ML Ops untuk meningkatkan skalabilitas, keandalan, dan keamanannya. Selain berfokus pada permintaan pelanggan akan fitur, Rahul juga senang bereksperimen dengan perkembangan teknologi terkini di lapangan.