Bangun arsitektur pelatihan terdistribusi yang fleksibel dan skalabel menggunakan Kubeflow di AWS dan Amazon SageMaker

Dalam posting ini, kami menunjukkan caranya Kubeflow di AWS (distribusi Kubeflow khusus AWS) yang digunakan dengan Kontainer Pembelajaran Jauh AWS dan Sistem File Amazon Elastis (Amazon EFS) menyederhanakan kolaborasi dan memberikan fleksibilitas dalam melatih model deep learning dalam skala besar di keduanya Layanan Amazon Elastic Kubernetes (Amazon EKS) dan Amazon SageMaker menggunakan pendekatan arsitektur hybrid.

Pengembangan pembelajaran mesin (ML) bergantung pada kerangka kerja dan toolkit open-source yang kompleks dan terus berkembang, serta ekosistem perangkat keras yang kompleks dan terus berkembang. Hal ini menimbulkan tantangan saat menskalakan pengembangan ML ke sebuah cluster. Kontainer menawarkan solusi, karena mereka dapat sepenuhnya merangkum tidak hanya kode pelatihan, tetapi seluruh ketergantungan menumpuk ke perpustakaan perangkat keras. Ini memastikan lingkungan ML yang konsisten dan portabel, dan memfasilitasi reproduktifitas lingkungan pelatihan pada setiap node individu dari cluster pelatihan.

Kubernetes adalah sistem yang diadopsi secara luas untuk mengotomatisasi penyebaran infrastruktur, penskalaan sumber daya, dan pengelolaan aplikasi dalam container ini. Namun, Kubernetes tidak dibuat dengan mempertimbangkan ML, sehingga bisa terasa berlawanan dengan intuisi ilmuwan data karena ketergantungannya yang besar pada file spesifikasi YAML. Tidak ada pengalaman Jupyter, dan tidak ada banyak kemampuan khusus ML, seperti manajemen alur kerja dan saluran pipa, dan kemampuan lain yang diharapkan pakar ML, seperti penyetelan hyperparameter, hosting model, dan lainnya. Kemampuan seperti itu dapat dibangun, tetapi Kubernetes tidak dirancang untuk melakukan ini sebagai tujuan utamanya.

Komunitas open-source memperhatikan dan mengembangkan lapisan di atas Kubernetes yang disebut Kubeflow. Kubeflow bertujuan untuk membuat penerapan alur kerja ML end-to-end di Kubernetes menjadi sederhana, portabel, dan skalabel. Anda dapat menggunakan Kubeflow untuk menerapkan sistem sumber terbuka terbaik untuk ML ke berbagai infrastruktur.

Kubeflow dan Kubernetes memberikan fleksibilitas dan kontrol kepada tim ilmuwan data. Namun, memastikan pemanfaatan tinggi klaster pelatihan yang berjalan pada skala dengan pengurangan biaya operasional masih merupakan tantangan.

Postingan ini menunjukkan bagaimana pelanggan yang memiliki batasan lokal atau investasi Kubernetes yang ada dapat mengatasi tantangan ini dengan menggunakan Amazon EKS dan Kubeflow di AWS untuk mengimplementasikan pipeline ML untuk pelatihan terdistribusi berdasarkan pendekatan swakelola, dan menggunakan SageMaker yang terkelola sepenuhnya untuk infrastruktur pelatihan skala produksi yang dioptimalkan biaya, terkelola sepenuhnya. Ini termasuk implementasi langkah demi langkah dari arsitektur pelatihan terdistribusi hibrid yang memungkinkan Anda memilih di antara dua pendekatan saat runtime, memberikan kontrol dan fleksibilitas maksimum dengan kebutuhan yang ketat untuk penerapan Anda. Anda akan melihat bagaimana Anda dapat terus menggunakan pustaka sumber terbuka dalam skrip pelatihan pembelajaran mendalam Anda dan tetap membuatnya kompatibel untuk dijalankan di Kubernetes dan SageMaker dengan cara agnostik platform.

Bagaimana Kubeflow di AWS dan SageMaker membantu?

Model jaringan saraf yang dibuat dengan kerangka kerja pembelajaran mendalam seperti TensorFlow, PyTorch, MXNet, dan lainnya memberikan akurasi yang jauh lebih tinggi dengan menggunakan set data pelatihan yang jauh lebih besar, terutama dalam kasus penggunaan computer vision dan pemrosesan bahasa alami. Namun, dengan kumpulan data pelatihan yang besar, diperlukan waktu lebih lama untuk melatih model pembelajaran mendalam, yang pada akhirnya memperlambat waktu untuk memasarkan. Jika kita dapat menskalakan klaster dan menurunkan waktu pelatihan model dari minggu ke hari atau jam, itu bisa berdampak besar pada produktivitas dan kecepatan bisnis.

Amazon EKS membantu menyediakan control plane Kubernetes yang dikelola. Anda dapat menggunakan Amazon EKS untuk membuat kluster pelatihan skala besar dengan instans CPU dan GPU dan menggunakan toolkit Kubeflow untuk menyediakan alat sumber terbuka yang ramah-ML dan mengoperasionalkan alur kerja ML yang portabel dan skalabel menggunakan Kubeflow Pipelines untuk meningkatkan produktivitas dan tim Anda. mengurangi waktu ke pasar.

Namun, mungkin ada beberapa tantangan dengan pendekatan ini:

• Memastikan pemanfaatan cluster secara maksimal di seluruh tim ilmu data. Misalnya, Anda harus menyediakan instans GPU sesuai permintaan dan memastikan pemanfaatannya yang tinggi untuk tugas skala produksi yang menuntut seperti pelatihan deep learning, dan menggunakan instans CPU untuk tugas yang tidak terlalu menuntut seperti prapemrosesan data
• Memastikan ketersediaan tinggi komponen infrastruktur Kubeflow kelas berat, termasuk database, penyimpanan, dan autentikasi, yang diterapkan di node pekerja cluster Kubernetes. Misalnya, bidang kontrol Kubeflow menghasilkan artefak (seperti instans MySQL, log pod, atau penyimpanan MinIO) yang tumbuh seiring waktu dan membutuhkan volume penyimpanan yang dapat diubah ukurannya dengan kemampuan pemantauan berkelanjutan.
• Berbagi set data pelatihan, kode, dan lingkungan komputasi antara developer, kluster pelatihan, dan proyek merupakan hal yang menantang. Misalnya, jika Anda sedang mengerjakan kumpulan pustaka Anda sendiri dan pustaka tersebut memiliki saling ketergantungan yang kuat, akan sangat sulit untuk membagikan dan menjalankan bagian kode yang sama antara ilmuwan data dalam tim yang sama. Selain itu, setiap pelatihan mengharuskan Anda mengunduh kumpulan data pelatihan dan membuat gambar pelatihan dengan perubahan kode baru.

Kubeflow di AWS membantu mengatasi tantangan ini dan menyediakan produk Kubeflow semi-terkelola tingkat perusahaan. Dengan Kubeflow di AWS, Anda dapat mengganti beberapa layanan bidang kontrol Kubeflow seperti database, penyimpanan, pemantauan, dan manajemen pengguna dengan layanan terkelola AWS seperti Layanan Database Relasional Amazon (Amazon RDS), Layanan Penyimpanan Sederhana Amazon (Amazon S3), Sistem File Amazon Elastis (AmazonEFS), AmazonFSx, amazoncloudwatch, dan Amazon Kognito.

Mengganti komponen Kubeflow ini akan memisahkan bagian penting dari bidang kontrol Kubeflow dari Kubernetes, memberikan desain yang aman, skalabel, tangguh, dan hemat biaya. Pendekatan ini juga membebaskan penyimpanan dan sumber daya komputasi dari bidang data EKS, yang mungkin diperlukan oleh aplikasi seperti pelatihan model terdistribusi atau server notebook pengguna. Kubeflow di AWS juga menyediakan integrasi asli notebook Jupyter dengan gambar Deep Learning Container (DLC), yang telah dikemas sebelumnya dan dikonfigurasikan sebelumnya dengan kerangka kerja pembelajaran mendalam yang dioptimalkan AWS seperti PyTorch dan TensorFlow yang memungkinkan Anda untuk mulai menulis kode pelatihan Anda segera tanpa berurusan dengan resolusi ketergantungan dan optimasi kerangka kerja. Selain itu, integrasi Amazon EFS dengan kluster pelatihan dan lingkungan pengembangan memungkinkan Anda untuk berbagi kode dan set data pelatihan yang diproses, yang menghindari pembuatan gambar kontainer dan memuat set data besar setelah setiap perubahan kode. Integrasi dengan Kubeflow di AWS ini membantu Anda mempercepat pembuatan model dan waktu pelatihan serta memungkinkan kolaborasi yang lebih baik dengan berbagi data dan kode yang lebih mudah.

Kubeflow di AWS membantu membangun platform ML yang sangat tersedia dan tangguh. Platform ini memberikan fleksibilitas untuk membangun dan melatih model pembelajaran mendalam dan menyediakan akses ke banyak perangkat sumber terbuka, wawasan tentang log, dan debugging interaktif untuk eksperimen. Namun, mencapai pemanfaatan maksimum sumber daya infrastruktur sambil melatih model pembelajaran mendalam pada ratusan GPU masih melibatkan banyak biaya operasional. Hal ini dapat diatasi dengan menggunakan SageMaker, yang merupakan layanan terkelola sepenuhnya yang dirancang dan dioptimalkan untuk menangani klaster pelatihan berkinerja dan hemat biaya yang hanya disediakan saat diminta, diskalakan sesuai kebutuhan, dan dimatikan secara otomatis saat pekerjaan selesai, sehingga menyediakan hampir 100 % pemanfaatan sumber daya. Anda dapat mengintegrasikan SageMaker dengan Kubeflow Pipelines menggunakan komponen SageMaker terkelola. Hal ini memungkinkan Anda untuk mengoperasionalkan alur kerja ML sebagai bagian dari pipeline Kubeflow, tempat Anda dapat menggunakan Kubernetes untuk pelatihan lokal dan SageMaker untuk pelatihan skala produk dalam arsitektur hibrid.

Ikhtisar solusi

Arsitektur berikut menjelaskan cara kami menggunakan Kubeflow Pipelines untuk membangun dan men-deploy alur kerja ML end-to-end portabel dan skalabel untuk menjalankan pelatihan terdistribusi secara kondisional di Kubernetes menggunakan pelatihan Kubeflow atau SageMaker berdasarkan parameter runtime.

Pelatihan Kubeflow adalah sekelompok Operator Kubernetes yang menambahkan ke Kubeflow dukungan untuk pelatihan terdistribusi model ML menggunakan kerangka kerja yang berbeda seperti TensorFlow, PyTorch, dan lainnya. pytorch-operator adalah implementasi Kubeflow dari Kubernetes sumber daya khusus (PyTorchJob) untuk menjalankan tugas pelatihan PyTorch terdistribusi di Kubernetes.

Kami menggunakan komponen PyTorchJob Launcher sebagai bagian dari pipeline Kubeflow untuk menjalankan pelatihan terdistribusi PyTorch selama fase eksperimen ketika kami membutuhkan fleksibilitas dan akses ke semua sumber daya yang mendasari untuk debugging dan analisis interaktif.

Kami juga menggunakan komponen SageMaker untuk Kubeflow Pipelines untuk menjalankan pelatihan model kami pada skala produksi. Hal ini memungkinkan kami memanfaatkan fitur SageMaker yang canggih seperti layanan yang terkelola sepenuhnya, tugas pelatihan terdistribusi dengan pemanfaatan GPU maksimum, dan pelatihan hemat biaya melalui Cloud komputasi elastis Amazon (Amazon EC2) Contoh Spot.

Sebagai bagian dari proses pembuatan alur kerja, Anda menyelesaikan langkah-langkah berikut (seperti yang diperlihatkan dalam diagram sebelumnya) untuk membuat alur ini:

1. Gunakan file manifes Kubeflow untuk membuat dasbor Kubeflow dan mengakses notebook Jupyter dari dasbor pusat Kubeflow.
2. Gunakan SDK pipeline Kubeflow untuk membuat dan mengompilasi pipeline Kubeflow menggunakan kode Python. Kompilasi saluran pipa mengonversi fungsi Python menjadi sumber daya alur kerja, yang merupakan format YAML yang kompatibel dengan Argo.
3. Gunakan klien Kubeflow Pipelines SDK untuk memanggil endpoint layanan pipeline untuk menjalankan pipeline.
4. Pipeline mengevaluasi variabel runtime bersyarat dan memutuskan antara SageMaker atau Kubernetes sebagai lingkungan run target.
5. Gunakan komponen Kubeflow PyTorch Launcher untuk menjalankan pelatihan terdistribusi di lingkungan Kubernetes asli, atau gunakan komponen SageMaker untuk mengirimkan pelatihan pada platform terkelola SageMaker.

Gambar berikut menunjukkan komponen Kubeflow Pipelines yang terlibat dalam arsitektur yang memberi kita fleksibilitas untuk memilih antara lingkungan terdistribusi Kubernetes atau SageMaker.

Gunakan Alur Kerja Kasus

Kami menggunakan pendekatan langkah demi langkah berikut untuk menginstal dan menjalankan kasus penggunaan untuk pelatihan terdistribusi menggunakan Amazon EKS dan SageMaker menggunakan Kubeflow di AWS.

Prasyarat

Untuk penelusuran ini, Anda harus memiliki prasyarat berikut:

• An Akun AWS.
• Sebuah mesin dengan Docker dan Antarmuka Baris Perintah AWS (AWS CLI) diinstal.
• 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. Dari lingkungan Cloud9 Anda, pilih tanda plus dan buka terminal baru.
• Buat peran dengan nama itu sagemakerrole. Tambahkan kebijakan terkelola AmazonSageMakerFullAccess dan AmazonS3FullAccess untuk memberi SageMaker akses ke bucket S3. Peran ini digunakan oleh tugas SageMaker yang dikirimkan sebagai bagian dari langkah Kubeflow Pipelines.
• Pastikan akun Anda memiliki batas jenis sumber daya Pelatihan SageMaker untuk ml.p3.2xlarge meningkat menjadi 2 menggunakan Konsol Kuota Layanan

1. Instal Amazon EKS dan Kubeflow di AWS

Anda dapat menggunakan beberapa pendekatan berbeda untuk membangun cluster Kubernetes dan men-deploy Kubeflow. Dalam posting ini, kami fokus pada pendekatan yang kami yakini membawa kesederhanaan dalam prosesnya. Pertama, kami membuat klaster EKS, lalu kami menerapkan Kubeflow di AWS v1.5 di atasnya. Untuk setiap tugas ini, kami menggunakan proyek sumber terbuka yang sesuai yang mengikuti prinsip-prinsip Lakukan Kerangka. Daripada menginstal serangkaian prasyarat untuk setiap tugas, kami membangun wadah Docker yang memiliki semua alat yang diperlukan dan melakukan tugas dari dalam wadah.

Kami menggunakan Do Framework dalam posting ini, yang mengotomatiskan penerapan Kubeflow dengan Amazon EFS sebagai add-on. Untuk opsi penerapan Kubeflow di AWS resmi untuk penerapan produksi, lihat Penyebaran.

Konfigurasikan direktori kerja saat ini dan AWS CLI

Kami mengonfigurasi direktori kerja sehingga kami dapat merujuknya sebagai titik awal untuk langkah-langkah berikut:

export working_dir=$PWD

Kami juga mengonfigurasi profil AWS CLI. Untuk melakukannya, Anda memerlukan ID kunci akses dan kunci akses rahasia dari sebuah 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

1.1 Buat klaster EKS

Jika Anda sudah memiliki cluster EKS yang tersedia, Anda dapat melompat ke bagian berikutnya. Untuk posting ini, kami menggunakan proyek aws-do-eks untuk membuat cluster kami.

1. Pertama klon proyek di direktori kerja Anda

   cd ${working_dir}
   git clone https://github.com/aws-samples/aws-do-eks
   cd aws-do-eks/

2. Kemudian buat dan jalankan aws-do-eks wadah:

   ./build.sh
   ./run.sh

   Grafik build.sh script membuat image container Docker yang memiliki semua alat dan skrip yang diperlukan untuk penyediaan dan pengoperasian klaster EKS. Itu run.sh skrip memulai wadah menggunakan gambar Docker yang dibuat dan menyimpannya, sehingga kami dapat menggunakannya sebagai lingkungan manajemen EKS kami. Untuk melihat status Anda aws-do-eks wadah, Anda dapat menjalankan ./status.sh. Jika wadah dalam status Keluar, Anda dapat menggunakan ./start.sh skrip untuk memunculkan wadah, atau untuk memulai kembali wadah, Anda dapat menjalankan ./stop.sh diikuti oleh ./run.sh.

3. Buka cangkang saat berlari aws-do-eks wadah:
4. Untuk meninjau konfigurasi cluster EKS untuk penerapan KubeFlow kami, jalankan perintah berikut:

   vi ./eks-kubeflow.yaml

   Secara default, konfigurasi ini membuat cluster bernama eks-kubeflow dalam us-west-2 Region dengan enam node m5.xlarge. Selain itu, enkripsi volume EBS tidak diaktifkan secara default. Anda dapat mengaktifkannya dengan menambahkan "volumeEncrypted: true" ke nodegroup dan itu akan mengenkripsi menggunakan kunci default. Ubah pengaturan konfigurasi lainnya jika diperlukan.

5. Untuk membuat cluster, jalankan perintah berikut:

   export AWS_PROFILE=kubeflow
   eksctl create cluster -f ./eks-kubeflow.yaml

   Proses penyediaan cluster dapat memakan waktu hingga 30 menit.

6. Untuk memverifikasi bahwa cluster berhasil dibuat, jalankan perintah berikut:

   kubectl get nodes

   Output dari perintah sebelumnya untuk cluster yang berhasil dibuat terlihat seperti kode berikut:

   root@cdf4ecbebf62:/eks# kubectl get nodes
   NAME                                           STATUS   ROLES    AGE   VERSION
   ip-192-168-0-166.us-west-2.compute.internal    Ready       23m   v1.21.14-eks-ba74326
   ip-192-168-13-28.us-west-2.compute.internal    Ready       23m   v1.21.14-eks-ba74326
   ip-192-168-45-240.us-west-2.compute.internal   Ready       23m   v1.21.14-eks-ba74326
   ip-192-168-63-84.us-west-2.compute.internal    Ready       23m   v1.21.14-eks-ba74326
   ip-192-168-75-56.us-west-2.compute.internal    Ready       23m   v1.21.14-eks-ba74326
   ip-192-168-85-226.us-west-2.compute.internal   Ready       23m   v1.21.14-eks-ba74326

Buat volume EFS untuk tugas pelatihan SageMaker

Dalam kasus penggunaan ini, Anda mempercepat pekerjaan pelatihan SageMaker dengan melatih model pembelajaran mendalam dari data yang sudah disimpan di Amazon EFS. Pilihan ini memiliki keuntungan dengan meluncurkan langsung tugas pelatihan Anda dari data di Amazon EFS tanpa memerlukan pemindahan data, sehingga menghasilkan waktu mulai pelatihan yang lebih cepat.

Kami membuat volume EFS dan menerapkan driver EFS Container Storage Interface (CSI). Ini dilakukan dengan skrip penerapan yang terletak di /eks/deployment/csi/efs dalam aws-do-eks wadah.

Skrip ini mengasumsikan Anda memiliki satu klaster EKS di akun Anda. Mengatur CLUSTER_NAME= jika Anda memiliki lebih dari satu klaster EKS.

cd /eks/deployment/csi/efs
./deploy.sh

Skrip ini menyediakan volume EFS dan membuat target pemasangan untuk subnet kluster VPC. Ini kemudian menyebarkan driver EFS CSI dan membuat efs-sc kelas penyimpanan dan efs-pv volume persisten di cluster EKS.

Setelah berhasil menyelesaikan skrip, Anda akan melihat output seperti berikut:

Generating efs-sc.yaml ...

Applying efs-sc.yaml ...
storageclass.storage.k8s.io/efs-sc created
NAME            PROVISIONER             RECLAIMPOLICY   VOLUMEBINDINGMODE      ALLOWVOLUMEEXPANSION   AGE
efs-sc          efs.csi.aws.com         Delete          Immediate              false                  1s
gp2 (default)   kubernetes.io/aws-ebs   Delete          WaitForFirstConsumer   false                  36m

Generating efs-pv.yaml ...
Applying efs-pv.yaml ...
persistentvolume/efs-pv created
NAME     CAPACITY   ACCESS MODES   RECLAIM POLICY   STATUS      CLAIM   STORAGECLASS   REASON   AGE
efs-pv   5Gi        RWX            Retain           Available           efs-sc                  10s

Done ...

Buat titik akhir VPC Amazon S3

Anda menggunakan VPC pribadi yang dapat diakses oleh tugas pelatihan SageMaker dan sistem file EFS Anda. Untuk memberi kluster pelatihan SageMaker akses ke bucket S3 dari VPC pribadi, Anda membuat titik akhir VPC:

cd /eks/vpc 
export CLUSTER_NAME= 
export REGION= 
./vpc-endpoint-create.sh

Anda sekarang dapat keluar dari aws-do-eks cangkang wadah dan lanjutkan ke bagian berikutnya:

exit

root@cdf4ecbebf62:/eks/deployment/csi/efs# exit
exit
TeamRole:~/environment/aws-do-eks (main) $

1.2 Menerapkan Kubeflow di AWS di Amazon EKS

Untuk menerapkan Kubeflow di Amazon EKS, kami menggunakan proyek aws-do-kubeflow.

1. Kloning repositori menggunakan perintah berikut:

   cd ${working_dir}
   git clone https://github.com/aws-samples/aws-do-kubeflow
   cd aws-do-kubeflow

2. Kemudian konfigurasikan proyek:

   ./config.sh

   Skrip ini membuka file konfigurasi proyek di editor teks. Penting untuk AWS_REGION untuk disetel ke Wilayah tempat cluster Anda berada, serta AWS_CLUSTER_NAME untuk mencocokkan nama cluster yang Anda buat sebelumnya. Secara default, konfigurasi Anda sudah diatur dengan benar, jadi jika Anda tidak perlu melakukan perubahan apa pun, tutup saja editornya.

   ./build.sh
   ./run.sh
   ./exec.sh

   Grafik build.sh script membuat image container Docker yang memiliki semua alat yang diperlukan untuk men-deploy dan mengelola Kubeflow di cluster Kubernetes yang ada. Itu run.sh skrip memulai wadah, menggunakan gambar Docker, dan skrip exec.sh membuka shell perintah ke dalam wadah, yang dapat kita gunakan sebagai lingkungan manajemen Kubeflow. Anda dapat menggunakan ./status.sh skrip untuk melihat apakah aws-do-kubeflow wadah sudah aktif dan berjalan dan ./stop.sh dan ./run.sh skrip untuk memulai kembali sesuai kebutuhan.

3. Setelah Anda membuka cangkang di aws-do-eks wadah, Anda dapat memverifikasi bahwa konteks cluster yang dikonfigurasi seperti yang diharapkan:

   root@ip-172-31-43-155:/kubeflow# kubectx
   kubeflow@eks-kubeflow.us-west-2.eksctl.io

4. Untuk men-deploy Kubeflow di cluster EKS, jalankan perintah deploy.sh naskah:

   ./kubeflow-deploy.sh

   Deployment berhasil ketika semua pod di namespace kubeflow memasuki status Running. Output khas terlihat seperti kode berikut:

   Waiting for all Kubeflow pods to start Running ...
   
   Waiting for all Kubeflow pods to start Running ...
   
   Restarting central dashboard ...
   pod "centraldashboard-79f489b55-vr6lp" deleted
   /kubeflow/deploy/distro/aws/kubeflow-manifests /kubeflow/deploy/distro/aws
   /kubeflow/deploy/distro/aws
   
   Kubeflow deployment succeeded
   Granting cluster access to kubeflow profile user ...
   Argument not provided, assuming default user namespace kubeflow-user-example-com ...
   clusterrolebinding.rbac.authorization.k8s.io/kubeflow-user-example-com-cluster-admin-binding created
   Setting up access to Kubeflow Pipelines ...
   Argument not provided, assuming default user namespace kubeflow-user-example-com ...
   
   Creating pod-default for namespace kubeflow-user-example-com ...
   poddefault.kubeflow.org/access-ml-pipeline created

5. Untuk memantau status pod KubeFlow, di jendela terpisah, Anda dapat menggunakan perintah berikut:

   watch kubectl -n kubeflow get pods

6. Tekan Ctrl + C ketika semua pod sedang Berjalan, maka ekspos dasbor Kubeflow di luar cluster dengan menjalankan perintah berikut:

   ./kubeflow-expose.sh

Anda akan melihat output yang terlihat seperti kode berikut:

root@ip-172-31-43-155:/kubeflow# ./kubeflow-expose.sh
root@ip-172-31-43-155:/kubeflow# Forwarding from 127.0.0.1:8080 -> 8080
Forwarding from [::1]:8080 -> 8080

Perintah ini meneruskan layanan gateway ingress Istio dari cluster Anda ke port 8080 lokal Anda. Untuk mengakses dasbor Kubeflow, kunjungi http://localhost:8080 dan masuk menggunakan kredensial pengguna default (pengguna@example.com/12341234). Jika Anda menjalankan aws-do-kubeflow wadah di AWS Cloud9, maka Anda dapat memilih Preview, Lalu pilih Pratinjau Aplikasi yang Berjalan. Jika Anda menjalankan di Docker Desktop, Anda mungkin perlu menjalankan ./kubeflow-expose.sh naskah di luar aws-do-kubeflow wadah.

2. Siapkan Kubeflow di lingkungan AWS

Untuk menyiapkan Kubeflow Anda di lingkungan AWS, kami membuat volume EFS dan notebook Jupyter.

2.1 Buat volume EFS

Untuk membuat volume EFS, selesaikan langkah-langkah berikut:

• Di dasbor Kubeflow, pilih Volume di panel navigasi.
• Memilih volume baru.
• Untuk Nama, Masuk efs-sc-claim.
• Untuk Ukuran volume, Masuk 10.
• Untuk Kelas penyimpanan, pilih efs-sc.
• Untuk Mode akses, pilih BacaTulisSekali.
• Pilih membuat.

2.2 Buat buku catatan Jupyter

Untuk membuat buku catatan baru, selesaikan langkah-langkah berikut:

• Di dasbor Kubeflow, pilih notebook di panel navigasi.
• Pilih Buku catatan baru.
• Untuk Nama, Masuk aws-hybrid-nb.
• Untuk Gambar Docket Jupyter, pilih gambar c9e4w0g3/notebook-servers/jupyter-pytorch:1.11.0-cpu-py38-ubuntu20.04-e3-v1.1 (gambar DLC jupyter-pytorch terbaru yang tersedia).
• Untuk CPU, Masuk 1.
• Untuk Memori, Masuk 5.
• Untuk GPU, tinggalkan sebagai None.
• Jangan membuat perubahan apa pun pada Volume ruang kerja bagian.
• Dalam majalah Volume Data bagian, pilih Lampirkan volume yang ada dan perluas bagian Volume yang ada
• Untuk Nama, pilih efs-sc-claim.
• Untuk Jalur gunung, Masuk /home/jovyan/efs-sc-claim.
  Ini memasang volume EFS ke pod notebook Jupyter Anda, dan Anda dapat melihat foldernya efs-sc-claim di antarmuka lab Jupyter Anda. Anda menyimpan set data pelatihan dan kode pelatihan ke folder ini sehingga kluster pelatihan dapat mengaksesnya tanpa perlu membuat ulang image container untuk pengujian.
• Pilih Izinkan akses ke Kubeflow Pipeline di bagian Konfigurasi.
• Pilih Launch.
  Pastikan buku catatan Anda berhasil dibuat (mungkin perlu beberapa menit).
• pada notebook halaman, pilih Terhubung untuk masuk ke lingkungan JupyterLab.
• pada pergi menu, pilih Mengkloning Repositori.
• Untuk Mengkloning repo, Masuk https://github.com/aws-samples/aws-do-kubeflow.
  

3. Jalankan pelatihan terdistribusi

Setelah Anda mengatur notebook Jupyter, Anda dapat menjalankan seluruh demo menggunakan langkah-langkah tingkat tinggi berikut dari folder aws-do-kubeflow/workshop di repositori kloning:

• Skrip pelatihan PyTorch Distributed Data Parallel (DDP): Lihat skrip pelatihan DDP PyTorch cifar10-distributed-gpu-final.py, yang menyertakan contoh jaringan saraf convolutional dan logika untuk mendistribusikan pelatihan pada cluster CPU dan GPU multi-node. (Lihat 3.1 untuk detailnya)
• Instal perpustakaan: Jalankan buku catatan 0_initialize_dependencies.ipynb untuk menginisialisasi semua dependensi. (Lihat 3.2 untuk detailnya)
• Jalankan pelatihan kerja PyTorch terdistribusi di Kubernetes: Jalankan buku catatan 1_submit_pytorchdist_k8s.ipynb untuk membuat dan mengirimkan pelatihan terdistribusi pada satu kontainer utama dan dua kontainer pekerja menggunakan file YAML sumber daya kustom Kubernetes PyTorchJob menggunakan kode Python. (Lihat 3.3 untuk detailnya)
• Buat pipeline Kubeflow hybrid: Jalankan buku catatan 2_create_pipeline_k8s_sagemaker.ipynb untuk membuat pipeline Kubeflow hybrid yang menjalankan pelatihan terdistribusi di SageMaker atau Amazon EKS menggunakan variabel runtime training_runtime. (Lihat 3.4 untuk detailnya)

Pastikan Anda menjalankan notebook 1_submit_pytorchdist_k8s.ipynb sebelum Anda memulai buku catatan 2_create_pipeline_k8s_sagemaker.ipynb.

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

3.1 Skrip pelatihan PyTorch Distributed Data Parallel (DDP)

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 linier di mana fungsi aktivasi relu 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

Kami menggunakan DataLoader obor yang menggabungkan dataset dan DistributedSampler (memuat subset data secara terdistribusi menggunakan torch.nn.parallel.DistributedDataParallel) dan menyediakan iterator proses tunggal atau multiproses pada data:

# Define data loader for training dataset
def _get_train_data_loader(batch_size, training_dir, is_distributed):
logger.info("Get train data loader")

train_set = torchvision.datasets.CIFAR10(root=training_dir,
train=True,
download=False,
transform=_get_transforms())

train_sampler = (
torch.utils.data.distributed.DistributedSampler(train_set) if is_distributed else None
)

return torch.utils.data.DataLoader(
train_set,
batch_size=batch_size,
shuffle=train_sampler is None,
sampler=train_sampler)
...

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 sinkron di beberapa mesin. Data input dibagi pada dimensi batch dan replika model ditempatkan pada setiap mesin dan setiap perangkat.

model = Net().to(device)

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

...

3.2 Instal perpustakaan

Anda akan menginstal semua pustaka yang diperlukan untuk menjalankan contoh pelatihan terdistribusi PyTorch. Ini termasuk Kubeflow Pipelines SDK, Training Operator Python SDK, klien Python untuk Kubernetes dan Amazon SageMaker Python SDK.

#Please run the below commands to install necessary libraries

!pip install kfp==1.8.4

!pip install kubeflow-training

!pip install kubernetes

!pip install sagemaker

3.3 Jalankan pelatihan kerja PyTorch terdistribusi di Kubernetes

Buku catatan 1_submit_pytorchdist_k8s.ipynb membuat file YAML sumber daya kustom Kubernetes PyTorchJob menggunakan pelatihan Kubeflow dan klien Kubernetes Python SDK. Berikut adalah beberapa cuplikan penting dari notebook ini.

Kami membuat YAML PyTorchJob dengan wadah utama dan pekerja seperti yang ditunjukkan pada kode berikut:

# Define PyTorchJob custom resource manifest
pytorchjob = V1PyTorchJob(
api_version="kubeflow.org/v1",
kind="PyTorchJob",
metadata=V1ObjectMeta(name=pytorch_distributed_jobname,namespace=user_namespace),
spec=V1PyTorchJobSpec(
run_policy=V1RunPolicy(clean_pod_policy="None"),
pytorch_replica_specs={"Master": master,
"Worker": worker}
)
)

Ini dikirimkan ke pesawat kontrol Kubernetes menggunakan PyTorchJobClient:

# Creates and Submits PyTorchJob custom resource file to Kubernetes
pytorchjob_client = PyTorchJobClient()

pytorch_job_manifest=pytorchjob_client.create(pytorchjob):

Lihat log pelatihan Kubernetes

Anda dapat melihat log pelatihan baik dari notebook Jupyter yang sama menggunakan kode Python atau dari shell klien Kubernetes.

3.4 Membuat pipeline Kubeflow hybrid

Buku catatan 2_create_pipeline_k8s_sagemaker.ipynb membuat pipeline Kubeflow hybrid berdasarkan variabel runtime bersyarat training_runtime, seperti yang ditunjukkan pada kode berikut. Buku catatan menggunakan Kubeflow Pipeline SDK dan itu menyediakan satu set paket Python untuk menentukan dan menjalankan pipa alur kerja ML. Sebagai bagian dari SDK ini, kami menggunakan paket berikut:

• Dekorator paket bahasa khusus domain (DSL) dsl.pipeline, yang menghiasi fungsi Python untuk mengembalikan pipa
• Grafik dsl.Condition paket, yang mewakili sekelompok operasi yang hanya dijalankan ketika kondisi tertentu terpenuhi, seperti memeriksa training_runtime nilai sebagai sagemaker or kubernetes

Lihat kode berikut:

# Define your training runtime value with either 'sagemaker' or 'kubernetes'
training_runtime='sagemaker'

# Create Hybrid Pipeline using Kubeflow PyTorch Training Operators and Amazon SageMaker Service
@dsl.pipeline(name="PyTorch Training pipeline", description="Sample training job test")
def pytorch_cnn_pipeline():

# Pipeline Step 1: to evaluate the condition. You can enter any logic here. For demonstration we are checking if GPU is needed for training
condition_result = check_condition_op(training_runtime)

# Pipeline Step 2: to run training on Kuberentes using PyTorch Training Operators. This will be executed if gpus are not needed
with dsl.Condition(condition_result.output == 'kubernetes', name="PyTorch_Comp"):
train_task = pytorch_job_op(
name=training_job_name,
namespace=user_namespace,
master_spec=json.dumps(master_spec_loaded), # Please refer file at pipeline_yaml_specifications/pipeline_master_spec.yml
worker_spec=json.dumps(worker_spec_loaded), # Please refer file at pipeline_yaml_specifications/pipeline_worker_spec.yml
delete_after_done=False
).after(condition_result)

# Pipeline Step 3: to run training on SageMaker using SageMaker Components for Pipeline. This will be executed if gpus are needed
with dsl.Condition(condition_result.output == 'sagemaker', name="SageMaker_Comp"):
training = sagemaker_train_op(
region=region,
image=train_image,
job_name=training_job_name,
training_input_mode=training_input_mode,
hyperparameters='{ 
"backend": "'+str(pytorch_backend)+'", 
"batch-size": "64", 
"epochs": "3", 
"lr": "'+str(learning_rate)+'", 
"model-type": "custom", 
"sagemaker_container_log_level": "20", 
"sagemaker_program": "cifar10-distributed-gpu-final.py", 
"sagemaker_region": "us-west-2", 
"sagemaker_submit_directory": "'+source_s3+'" 
}',
channels=channels,
instance_type=instance_type,
instance_count=instance_count,
volume_size=volume_size,
max_run_time=max_run_time,
model_artifact_path=f's3://{bucket_name}/jobs',
network_isolation=network_isolation,
traffic_encryption=traffic_encryption,
role=role,
vpc_subnets=subnet_id,
vpc_security_group_ids=security_group_id
).after(condition_result)

Kami mengonfigurasi pelatihan terdistribusi SageMaker menggunakan dua instans ml.p3.2xlarge.

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 Pipeline SDK, yang memanggil endpoint 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="kubeflow")

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

Jika Anda mendapatkan file sagemaker import error, jalankan !pip install sagemaker dan mulai ulang kernel (pada Inti menu, pilih Mulai ulang Kernel).

Pilih Jalankan detail link di bawah sel terakhir untuk melihat pipeline Kubeflow.

Ulangi langkah pembuatan pipa dengan training_runtime='kubernetes' untuk menguji pipeline yang dijalankan di lingkungan Kubernetes. Itu training_runtime variabel juga dapat diteruskan dalam pipa CI/CD Anda dalam skenario produksi.

Lihat log proses pipeline Kubeflow untuk komponen SageMaker

Tangkapan layar berikut menunjukkan detail saluran kami untuk komponen SageMaker.

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.

Pilih salah satu grup untuk melihat log.

Lihat log proses pipeline Kubeflow untuk komponen Kubeflow PyTorchJob Launcher

Tangkapan layar berikut menunjukkan detail pipeline untuk komponen Kubeflow kami.

Jalankan perintah berikut menggunakan Kubectl pada shell klien Kubernetes Anda yang terhubung ke cluster Kubernetes untuk melihat log (ganti namespace dan nama pod Anda):

kubectl get pods -n kubeflow-user-example-com
kubectl logs  -n kubeflow-user-example-com -f

4.1 Membersihkan

Untuk membersihkan semua sumber daya yang kami buat di akun, kami harus menghapusnya dalam urutan terbalik.

1. Hapus instalasi Kubeflow dengan menjalankan ./kubeflow-remove.sh dalam aws-do-kubeflow wadah. Kumpulan perintah pertama bersifat opsional dan dapat digunakan jika Anda belum memiliki shell perintah ke dalam aws-do-kubeflow wadah terbuka.

   cd aws-do-kubeflow
   ./status.sh
   ./start.sh
   ./exec.sh
   
   ./kubeflow-remove.sh

2. Dari aws-do-eks folder container, hapus volume EFS. Kumpulan perintah pertama bersifat opsional dan dapat digunakan jika Anda belum memiliki shell perintah ke dalam aws-do-eks wadah terbuka.

   cd aws-do-eks
   ./status.sh
   ./start.sh
   ./exec.sh
   
   cd /eks/deployment/csi/efs
   ./delete.sh
   ./efs-delete.sh

   Menghapus Amazon EFS diperlukan untuk melepaskan antarmuka jaringan yang terkait dengan VPC yang kami buat untuk klaster kami. Perhatikan bahwa menghapus volume EFS akan menghancurkan semua data yang disimpan di dalamnya.

3. Dari aws-do-eks wadah, jalankan eks-delete.sh skrip untuk menghapus cluster dan sumber daya lain yang terkait dengannya, termasuk VPC:

   cd /eks
   ./eks-delete.sh

Kesimpulan

Dalam postingan ini, kami membahas beberapa tantangan khas pelatihan model terdistribusi dan alur kerja ML. Kami memberikan ikhtisar Kubeflow pada distribusi AWS dan membagikan dua proyek sumber terbuka (aws-do-eks dan aws-do-kubeflow) yang menyederhanakan penyediaan infrastruktur dan penerapan Kubeflow di dalamnya. Terakhir, kami menjelaskan dan mendemonstrasikan arsitektur hibrid yang memungkinkan beban kerja bertransisi dengan mulus antara berjalan di Kubernetes yang dikelola sendiri dan infrastruktur SageMaker yang dikelola sepenuhnya. Kami mendorong Anda untuk menggunakan arsitektur hibrid ini untuk kasus penggunaan Anda sendiri.

Anda bisa 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.

Terima kasih khusus kepada Sree Arasanagatta (Manajer Pengembangan Perangkat Lunak AWS ML) dan Suraj Kota (Insinyur Pengembang Perangkat Lunak) atas dukungan mereka terhadap peluncuran posting ini.

Tentang penulis

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

Gautama Kumar adalah Insinyur Perangkat Lunak dengan AWS AI Deep Learning. Dia telah mengembangkan AWS Deep Learning Containers dan AWS Deep Learning AMI. Dia bersemangat membangun alat dan sistem untuk AI. Di waktu luangnya, ia menikmati bersepeda dan membaca buku.

Alex Iankoulski adalah arsitek perangkat lunak dan infrastruktur full-stack yang suka melakukan pekerjaan langsung dan mendalam. Saat ini dia adalah Arsitek Solusi Utama untuk Pembelajaran Mesin yang Dikelola Sendiri di AWS. Dalam perannya, dia berfokus untuk membantu pelanggan dengan containerisasi dan orkestrasi beban kerja ML dan AI pada layanan AWS yang didukung container. Dia juga penulis sumber terbuka Lakukan kerangka kerja dan seorang kapten Docker yang suka menerapkan teknologi kontainer untuk mempercepat laju inovasi sambil memecahkan tantangan terbesar dunia. Selama 10 tahun terakhir, Alex telah berupaya memerangi perubahan iklim, mendemokratisasi AI dan ML, menjadikan perjalanan lebih aman, perawatan kesehatan lebih baik, dan energi lebih cerdas.