1. Pengantar
| Kubeflow adalah toolkit Machine Learning untuk Kubernetes. Project ini dikhususkan untuk membuat deployment alur kerja Machine Learning (ML) di Kubernetes dengan mudah, portabel, dan skalabel. Tujuannya adalah menyediakan cara mudah untuk men-deploy sistem open source terbaik untuk ML ke beragam infrastruktur. |
| Alur kerja machine learning dapat melibatkan banyak langkah yang saling bergantung satu sama lain, mulai dari persiapan dan analisis data, pelatihan, evaluasi, deployment, dan lain-lain. Sulit untuk menyusun dan melacak proses ini secara ad-hoc—misalnya, dalam serangkaian notebook atau skrip—dan hal-hal seperti pengauditan dan kemampuan reproduksi menjadi semakin bermasalah.Kubeflow Pipelines (KFP) membantu mengatasi masalah ini dengan menyediakan cara untuk men-deploy pipeline machine learning yang andal dan dapat diulang beserta pemantauan, pengauditan, pelacakan versi, dan kemampuan reproduksi. Cloud AI Pipelines memudahkan penyiapan penginstalan KFP. |
Yang akan Anda bangun
Dalam codelab ini, Anda akan membangun aplikasi web yang merangkum masalah GitHub menggunakan Kubeflow Pipelines untuk melatih dan menyalurkan model. Hal ini didasarkan pada contoh dalam repo Contoh Kubeflow. Setelah selesai, infrastruktur Anda akan berisi:
- Cluster Google Kubernetes Engine (GKE) dengan Kubeflow Pipelines yang terinstal (melalui Cloud AI Pipelines).
- Pipeline yang melatih model Tensor2Tensor pada GPU
- Penampung penayangan yang menyediakan prediksi dari model yang telah dilatih
- UI yang menafsirkan prediksi untuk memberikan ringkasan masalah GitHub
- Notebook yang membuat pipeline dari awal menggunakan Kubeflow Pipelines (KFP) SDK
Yang akan Anda pelajari
Pipeline yang akan Anda buat akan melatih model Tensor2Tensor pada data masalah GitHub, dan mempelajari cara memprediksi judul masalah dari isi masalah. Layanan ini kemudian mengekspor model terlatih dan men-deploy model yang diekspor menggunakan Tensorflow Serving. Langkah terakhir pada pipeline meluncurkan aplikasi web, yang berinteraksi dengan instance TF-Serving untuk mendapatkan prediksi model.
- Cara menginstal Kubeflow Pipelines di cluster GKE
- Cara membangun dan menjalankan alur kerja ML menggunakan Kubeflow Pipelines
- Cara menentukan dan menjalankan pipeline dari AI Platform Notebook
Yang Anda butuhkan
- Pemahaman dasar tentang Kubernetes akan membantu, tetapi tidak wajib
- Project GCP aktif yang izin Pemiliknya Anda miliki
- (Opsional) Akun GitHub
- Akses ke Google Cloud Shell, yang tersedia di Google Cloud Platform (GCP) Console
2. Penyiapan
Cloud Shell
Buka GCP Console di browser dan login dengan kredensial project Anda:
Klik "Pilih project" jika diperlukan, sehingga Anda menangani project codelab.
Kemudian, klik tombol "Activate Cloud Shell" di kanan atas konsol untuk memulai Cloud Shell.
Saat Anda memulai Cloud Shell, Anda akan diberi tahu nama project yang siap digunakan. Periksa apakah setelan ini sudah benar.
Untuk menemukan project ID Anda, buka Panel beranda GCP Console. Jika layar kosong, klik ‘Ya’ saat diminta untuk membuat dasbor.
Kemudian, di terminal Cloud Shell, jalankan perintah ini jika diperlukan untuk mengonfigurasi gcloud agar menggunakan project yang benar:
export PROJECT_ID=<your_project_id>
gcloud config set project ${PROJECT_ID}
Membuat bucket penyimpanan
Membuat bucket Cloud Storage untuk menyimpan file pipeline. Anda harus menggunakan ID unik global, sehingga akan lebih mudah untuk menentukan nama bucket yang menyertakan project ID Anda. Buat bucket menggunakan perintah gsutil mb (make bucket):
export PROJECT_ID=<your_project_id>
export BUCKET_NAME=kubeflow-${PROJECT_ID}
gsutil mb gs://${BUCKET_NAME}
Atau, Anda dapat membuat bucket melalui GCP Console.
Opsional**: Membuat token GitHub**
Codelab ini memanggil GitHub API untuk mengambil data yang tersedia untuk publik. Untuk mencegah pembatasan kapasitas, terutama pada peristiwa yang mengirimkan sejumlah besar permintaan anonim ke GitHub API, siapkan token akses tanpa izin. Tindakan ini hanya untuk memberikan otorisasi kepada Anda sebagai individu, bukan pengguna anonim.
- Buka https://github.com/settings/tokens dan buat token baru tanpa cakupan.
- Simpan di tempat yang aman. Jika kehilangan, Anda harus menghapus dan membuat yang baru.
Jika Anda melewati langkah ini, lab akan tetap berfungsi – hanya akan sedikit lebih terbatas pada opsi menghasilkan data input untuk menguji model Anda.
Opsional: Menyematkan dasbor yang berguna
Di konsol GCP, sematkan dasbor Kubernetes Engine dan Storage untuk memudahkan akses.
Membuat penginstalan AI Platform Pipelines (Pipeline Kubeflow yang Dihosting)
Ikuti petunjuk di bagian 'Sebelum memulai' dan 'Menyiapkan instance' di sini untuk menyiapkan instance GKE dengan KFP yang sudah terinstal. Pastikan untuk mencentang kotak Izinkan akses ke Cloud API berikut seperti yang ditunjukkan dalam dokumentasi. (Jika tidak, contoh pipeline tidak akan berhasil dijalankan). Biarkan namespace penginstalan sebagai default.
Anda harus memilih zona yang mendukung Nvidia k80. Anda dapat menggunakan us-central1-a atau us-central1-c sebagai setelan default.
Catat nama cluster dan zona GKE yang tercantum untuk penginstalan Anda di dasbor AI Pipelines setelah penginstalan selesai, dan untuk memudahkan, tetapkan variabel lingkungan ke nilai ini.
export ZONE=<your zone> export CLUSTER_NAME=<your cluster name>
Menyiapkan kubectl untuk menggunakan kredensial cluster GKE baru
Setelah cluster GKE dibuat, konfigurasikan kubectl untuk menggunakan kredensial cluster baru dengan menjalankan perintah berikut di Cloud Shell Anda:
gcloud container clusters get-credentials ${CLUSTER_NAME} \
--project ${PROJECT_ID} \
--zone ${ZONE}
Atau, klik nama cluster di dasbor AI Pipelines untuk membuka halaman GKE-nya, lalu klik "Connect" di bagian atas halaman. Dari pop-up, tempel perintah ke Cloud Shell Anda.
Tindakan ini akan mengonfigurasi konteks kubectl sehingga Anda dapat berinteraksi dengan cluster. Untuk memverifikasi konfigurasi, jalankan perintah berikut:
kubectl get nodes -o wide
Anda akan melihat node yang tercantum dengan status "Ready", dan informasi lain tentang usia node, versi, alamat IP eksternal, OS image, versi kernel, dan runtime container.
Mengonfigurasi cluster untuk menginstal driver Nvidia di node pool yang mendukung GPU
Selanjutnya, kita akan menerapkan daemonset ke cluster, yang akan menginstal driver Nvidia pada node cluster yang mendukung GPU:
kubectl apply -f https://raw.githubusercontent.com/GoogleCloudPlatform/container-engine-accelerators/master/nvidia-driver-installer/cos/daemonset-preloaded.yaml
Kemudian, jalankan perintah berikut, yang akan memberikan izin kepada komponen KFP untuk membuat resource Kubernetes baru:
kubectl create clusterrolebinding sa-admin --clusterrole=cluster-admin --serviceaccount=kubeflow:pipeline-runner
Membuat kumpulan node GPU
Kemudian, kita akan menyiapkan kumpulan node GPU dengan ukuran 1:
gcloud container node-pools create gpu-pool \
--cluster=${CLUSTER_NAME} \
--zone ${ZONE} \
--num-nodes=1 \
--machine-type n1-highmem-8 \
--scopes cloud-platform --verbosity error \
--accelerator=type=nvidia-tesla-k80,count=1
3. Menjalankan pipeline dari dasbor Pipeline
Buka dasbor Pipeline
Di Konsol Cloud, buka panel Pipeline jika Anda belum berada di sana. Lalu klik "BUKA DASBOR PIPELINE" untuk penginstalan Anda, lalu klik Pipelines di panel menu kiri. Jika Anda mengalami error saat memuat, muat ulang tab. Anda akan melihat halaman baru seperti ini:
Deskripsi pipeline
Pipeline yang akan Anda jalankan memiliki beberapa langkah (lihat Lampiran codelab ini untuk detailnya):
- Checkpoint model yang ada akan disalin ke bucket Anda.
- Model Tensor2Tensor dilatih menggunakan data yang telah diproses sebelumnya.
- Pelatihan dimulai dari pos pemeriksaan model yang ada yang disalin pada langkah pertama, lalu dilatih dengan beberapa ratus langkah lagi. (Perlu waktu terlalu lama untuk melatihnya sepenuhnya selama codelab).
- Setelah pelatihan selesai, langkah pipeline akan mengekspor model dalam bentuk yang sesuai untuk inferensi oleh pelayanan TensorFlow.
- Instance penyaluran TensorFlow di-deploy menggunakan model tersebut.
- Aplikasi web diluncurkan untuk berinteraksi dengan model yang disajikan guna mengambil prediksi.
Mendownload dan mengompilasi pipeline
Di bagian ini, kita akan melihat cara mengompilasi definisi pipeline. Hal pertama yang perlu kita lakukan adalah menginstal KFP SDK. Jalankan perintah berikut di Cloud Shell:
pip3 install -U kfp
Untuk mendownload file definisi pipeline, jalankan perintah ini dari Cloud Shell:
curl -O https://raw.githubusercontent.com/amygdala/kubeflow-examples/ghsumm/github_issue_summarization/pipelines/example_pipelines/gh_summ_hosted_kfp.py
Kemudian, kompilasi file definisi pipeline dengan menjalankannya seperti ini:
python3 gh_summ_hosted_kfp.py
Anda akan melihat file gh_summ_hosted_kfp.py.tar.gz muncul sebagai hasilnya.
Mengupload pipeline yang telah dikompilasi
Di UI web Kubeflow Pipelines, klik Upload pipeline, lalu pilih Import by URL. Salin, lalu tempel URL berikut, yang mengarah ke pipeline yang sama dengan yang baru saja Anda kompilasi. (Perlu beberapa langkah tambahan untuk mengupload file dari Cloud Shell, jadi kita akan mengambil pintasan).
Beri nama pada pipeline (misalnya, gh_summ).
Menjalankan pipeline
Klik pipeline yang diupload dalam daftar. Dengan begitu, Anda dapat melihat grafik statis pipeline tersebut, lalu klik Buat eksperimen untuk membuat Eksperimen baru menggunakan pipeline. Eksperimen adalah cara untuk mengelompokkan operasi yang terkait secara semantik.
Beri nama untuk Eksperimen (mis., nama yang sama dengan pipeline, gh_summ), lalu klik Next untuk membuatnya.
Tindakan ini akan memunculkan halaman tempat Anda dapat memasukkan parameter untuk Run dan memulainya.
Sebaiknya jalankan perintah berikut di Cloud Shell untuk membantu mengisi parameter.
gcloud config get-value project
echo "gs://${BUCKET_NAME}/codelab"
Nama Run akan diisi secara otomatis, tetapi Anda dapat memberinya nama berbeda jika mau.
Lalu isi tiga kolom parameter:
project- (opsional)
github-token working-dir
Untuk direktori kerja, masukkan beberapa jalur pada bucket GCS yang Anda buat. Sertakan ‘gs://' . Untuk kolom github-token, masukkan token yang Anda buat sebelumnya secara opsional, atau biarkan string placeholder sebagaimana adanya jika Anda tidak membuat token.
Setelah mengisi kolom, klik Start, lalu klik run yang tercantum untuk melihat detailnya. Saat langkah pipeline tertentu sedang berjalan, Anda dapat mengkliknya untuk mendapatkan informasi selengkapnya, termasuk melihat log pod-nya. (Anda juga dapat melihat log untuk langkah pipeline melalui link ke log Cloud Logging (Stackdriver), meskipun node cluster telah dihapus).
Melihat definisi pipeline
Saat pipeline berjalan, sebaiknya Anda melihat lebih dekat cara pipeline ini disusun dan fungsinya. Detail selengkapnya ada di bagian Lampiran di codelab.
Melihat informasi pelatihan model di TensorBoard
Setelah langkah pelatihan selesai, pilih tab Visualizations dan klik tombol Start TensorBoard berwarna biru. Setelah siap, klik Open Tensorboard.
Jelajahi dasbor Artifacts dan Executions
Kubeflow Pipelines secara otomatis mencatat metadata tentang langkah pipeline saat pipeline dijalankan. Informasi Artifact dan Execution dicatat. Klik entri ini di bilah navigasi kiri dasbor untuk menjelajahi lebih lanjut.
Untuk Artefak, Anda dapat melihat panel ringkasan dan panel Lineage Explorer.
Memunculkan aplikasi web yang dibuat oleh pipeline dan membuat beberapa prediksi
Langkah terakhir dalam pipeline adalah men-deploy aplikasi web, yang menyediakan UI untuk membuat kueri model terlatih — yang disalurkan melalui Penayangan TF — untuk membuat prediksi.
Setelah pipeline selesai, hubungkan ke aplikasi web dengan penerusan port ke layanan (kami melakukan penerusan port karena, untuk codelab ini, layanan webapp tidak disiapkan untuk memiliki endpoint eksternal).
Temukan nama layanan dengan menjalankan perintah ini di Cloud Shell:
kubectl get services
Cari nama layanan seperti ini: ghsumm-*-webappsvc dalam daftar.
Kemudian, di Cloud Shell, teruskan port ke layanan tersebut seperti berikut, ubah perintah berikut untuk menggunakan nama webappsvc Anda:
kubectl port-forward svc/ghsumm-xxxxx-webappsvc 8080:80
Setelah penerusan port berjalan, klik ‘preview' di atas panel Cloud Shell, lalu di menu dropdown, klik "Preview on port 8080".
Anda akan melihat halaman seperti ini muncul di tab baru:
Klik tombol Isi Masalah Acak untuk mengambil blok teks. Klik Generate TItle untuk memanggil model terlatih dan menampilkan prediksi.
Jika parameter pipeline Anda menyertakan token GitHub yang valid, Anda dapat mencoba memasukkan URL GitHub di kolom kedua, lalu mengklik "Buat Judul". Jika Anda tidak menyiapkan token GitHub yang valid, hanya gunakan kolom "Isi Masalah Acak" kolom tersebut.
4. Menjalankan pipeline dari AI Platform Notebook
Anda juga dapat secara interaktif mendefinisikan dan menjalankan Kubeflow Pipelines dari notebook Jupyter menggunakan KFP SDK. AI Platform Notebooks, yang akan kita gunakan untuk codelab ini, membuatnya sangat mudah.
Membuat instance notebook
Kita akan membuat instance notebook dari Cloud Shell menggunakan API-nya. (Atau, Anda dapat membuat notebook melalui Konsol Cloud. Lihat dokumentasi untuk informasi selengkapnya).
Tetapkan variabel lingkungan berikut di Cloud Shell:
export INSTANCE_NAME="kfp-ghsumm" export VM_IMAGE_PROJECT="deeplearning-platform-release" export VM_IMAGE_FAMILY="tf2-2-3-cpu" export MACHINE_TYPE="n1-standard-4" export LOCATION="us-central1-c"
Kemudian, jalankan perintah dari Cloud Shell untuk membuat instance notebook:
gcloud beta notebooks instances create $INSTANCE_NAME \ --vm-image-project=$VM_IMAGE_PROJECT \ --vm-image-family=$VM_IMAGE_FAMILY \ --machine-type=$MACHINE_TYPE --location=$LOCATION
Saat pertama kali menjalankan perintah ini, Anda mungkin akan diminta untuk mengaktifkan notebooks API untuk project Anda. Balas ‘y' jika demikian.
Setelah beberapa menit, server notebook Anda akan aktif dan berjalan. Anda dapat melihat instance Notebook yang tercantum di Konsol Cloud.
Mengupload notebook codelab
Setelah instance notebook dibuat, klik link ini untuk mengupload notebook Jupyter codelab. Pilih instance notebook yang akan digunakan. Notebook akan otomatis terbuka.
Menjalankan notebook
Ikuti petunjuk di notebook untuk selanjutnya di lab ini. Perhatikan bahwa dalam "Setup" dari {i>notebook<i}, Anda harus mengisi nilai Anda sendiri sebelum menjalankan sisa {i>notebook<i}.
(Jika Anda menggunakan project sendiri, jangan lupa untuk kembali dan melakukan bagian "Membersihkan" di lab ini).
5. Pembersihan
Anda tidak perlu melakukan hal ini jika menggunakan akun codelab sementara, tetapi Anda mungkin ingin menghapus penginstalan Pipeline dan Notebook jika menggunakan project Anda sendiri.
Menghapus cluster GKE Pipeline
Anda dapat menghapus cluster Pipeline dari Konsol Cloud. (Anda memiliki opsi untuk hanya menghapus penginstalan Pipeline jika ingin menggunakan kembali cluster GKE).
Menghapus instance AI Notebook
Jika Anda menjalankan "Notebook" sebagai bagian dari codelab, Anda dapat MENGHAPUS atau STOP instance notebook dari Konsol Cloud.
Opsional: Menghapus token GitHub
Buka https://github.com/settings/tokens dan hapus token yang dihasilkan.
6. Lampiran
Memahami kode
Menentukan pipeline
Pipeline yang digunakan dalam codelab ini ditentukan di sini.
Mari kita lihat cara ID didefinisikan, serta bagaimana komponennya (langkah-langkah) ditentukan. Kami akan membahas beberapa sorotan, tetapi baca dokumentasi untuk mengetahui detail selengkapnya.
Langkah-langkah Kubeflow Pipeline berbasis container. Saat mem-build pipeline, Anda dapat menggunakan komponen siap pakai, dengan image container yang sudah dibuat, atau membuat komponen sendiri. Untuk codelab ini, kami telah membuatnya sendiri.
Empat langkah pipeline ditentukan dari komponen yang dapat digunakan kembali, yang diakses melalui file definisi komponen. Dalam cuplikan kode pertama ini, kita mengakses file definisi komponen ini melalui URL-nya, dan menggunakan definisi ini untuk membuat 'ops' yang akan kita gunakan untuk membuat langkah pipeline.
import kfp.dsl as dsl
import kfp.gcp as gcp
import kfp.components as comp
...
copydata_op = comp.load_component_from_url(
'https://raw.githubusercontent.com/kubeflow/examples/master/github_issue_summarization/pipelines/components/t2t/datacopy_component.yaml'
)
train_op = comp.load_component_from_url(
'https://raw.githubusercontent.com/kubeflow/examples/master/github_issue_summarization/pipelines/components/t2t/train_component.yaml'
)
Di bawah ini adalah salah satu definisi komponen untuk pelatihan, dalam format yaml. Anda dapat melihat bahwa input, output, image container, dan argumen entrypoint container-nya telah ditentukan.
name: Train T2T model
description: |
A Kubeflow Pipeline component to train a Tensor2Tensor
model
metadata:
labels:
add-pod-env: 'true'
inputs:
- name: train_steps
description: '...'
type: Integer
default: 2019300
- name: data_dir
description: '...'
type: GCSPath
- name: model_dir
description: '...'
type: GCSPath
- name: action
description: '...'
type: String
- name: deploy_webapp
description: '...'
type: String
outputs:
- name: launch_server
description: '...'
type: String
- name: train_output_path
description: '...'
type: GCSPath
- name: MLPipeline UI metadata
type: UI metadata
implementation:
container:
image: gcr.io/google-samples/ml-pipeline-t2ttrain:v3ap
args: [
--data-dir, {inputValue: data_dir},
--action, {inputValue: action},
--model-dir, {inputValue: model_dir},
--train-steps, {inputValue: train_steps},
--deploy-webapp, {inputValue: deploy_webapp},
--train-output-path, {outputPath: train_output_path}
]
env:
KFP_POD_NAME: "{{pod.name}}"
fileOutputs:
launch_server: /tmp/output
MLPipeline UI metadata: /mlpipeline-ui-metadata.json
Anda juga dapat menentukan langkah pipeline melalui konstruktor dsl.ContainerOp, seperti yang akan kita lihat di bawah ini.
Berikut adalah sebagian besar definisi pipeline. Kita menentukan input pipeline (dan nilai defaultnya). Kemudian, kita menentukan langkah-langkah pipeline. Umumnya, kita menggunakan opsi 'ops', didefinisikan di atas, tetapi kita juga mendefinisikan 'serve' langkah inline melalui ContainerOp, yang menentukan image container dan argumen entrypoint secara langsung.
Anda dapat melihat bahwa langkah train, log_model, dan serve mengakses output dari langkah sebelumnya sebagai input. Anda dapat membaca selengkapnya tentang cara menentukannya di sini.
@dsl.pipeline(
name='Github issue summarization',
description='Demonstrate Tensor2Tensor-based training and TF-Serving'
)
def gh_summ( #pylint: disable=unused-argument
train_steps: 'Integer' = 2019300,
project: str = 'YOUR_PROJECT_HERE',
github_token: str = 'YOUR_GITHUB_TOKEN_HERE',
working_dir: 'GCSPath' = 'gs://YOUR_GCS_DIR_HERE',
checkpoint_dir: 'GCSPath' = 'gs://aju-dev-demos-codelabs/kubecon/model_output_tbase.bak2019000/',
deploy_webapp: str = 'true',
data_dir: 'GCSPath' = 'gs://aju-dev-demos-codelabs/kubecon/t2t_data_gh_all/'
):
copydata = copydata_op(
data_dir=data_dir,
checkpoint_dir=checkpoint_dir,
model_dir='%s/%s/model_output' % (working_dir, dsl.RUN_ID_PLACEHOLDER),
action=COPY_ACTION,
)
train = train_op(
data_dir=data_dir,
model_dir=copydata.outputs['copy_output_path'],
action=TRAIN_ACTION, train_steps=train_steps,
deploy_webapp=deploy_webapp
)
serve = dsl.ContainerOp(
name='serve',
image='gcr.io/google-samples/ml-pipeline-kubeflow-tfserve:v6',
arguments=["--model_name", 'ghsumm-%s' % (dsl.RUN_ID_PLACEHOLDER,),
"--model_path", train.outputs['train_output_path']
]
)
train.set_gpu_limit(1)
Perhatikan bahwa kami mengharuskan untuk dijalankan pada node dalam cluster yang memiliki minimal 1 GPU.
train.set_gpu_limit(1)
Langkah terakhir dalam pipeline— yang juga ditentukan secara inline— bersifat kondisional. Fungsi ini akan berjalan setelah 'serve' selesai, hanya jika output launch_server langkah pelatihan adalah string 'true'. Fitur ini meluncurkan 'aplikasi web prediksi', yang kami gunakan untuk meminta ringkasan masalah dari model T2T yang dilatih.
with dsl.Condition(train.outputs['launch_server'] == 'true'):
webapp = dsl.ContainerOp(
name='webapp',
image='gcr.io/google-samples/ml-pipeline-webapp-launcher:v1',
arguments=["--model_name", 'ghsumm-%s' % (dsl.RUN_ID_PLACEHOLDER,),
"--github_token", github_token]
)
webapp.after(serve)
Definisi image container komponen
Dokumentasi Kubeflow Pipeline menjelaskan beberapa praktik terbaik untuk membuat komponen Anda sendiri. Sebagai bagian dari proses ini, Anda harus menentukan dan membangun image container. Anda dapat melihat langkah-langkah komponen untuk pipeline codelab ini di sini. Definisi Dockerfile ada dalam subdirektori containers, misalnya di sini.
Menggunakan preemptible VM dengan GPU untuk pelatihan
Preemptible VM adalah instance VM Compute Engine yang bertahan maksimal 24 jam dan tidak memberikan jaminan ketersediaan. Harga preemptible VM lebih rendah daripada VM Compute Engine standar.
Dengan Google Kubernetes Engine (GKE), Anda dapat dengan mudah menyiapkan cluster atau node pool yang menggunakan preemptible VM. Anda dapat menyiapkan kumpulan node tersebut dengan GPU yang dilampirkan ke preemptible instance. Node ini berfungsi sama seperti node reguler yang mendukung GPU, tetapi GPU hanya bertahan selama masa pakai instance.
Anda dapat menyiapkan kumpulan node yang dapat dihentikan dan diaktifkan GPU untuk cluster Anda dengan menjalankan perintah yang mirip dengan berikut ini, mengedit perintah berikut dengan nama dan zona cluster, serta menyesuaikan jenis dan jumlah akselerator sesuai dengan kebutuhan Anda. Anda juga dapat menentukan kumpulan node untuk diskalakan secara otomatis berdasarkan beban kerja saat ini.
gcloud container node-pools create preemptible-gpu-pool \
--cluster=<your-cluster-name> \
--zone <your-cluster-zone> \
--enable-autoscaling --max-nodes=4 --min-nodes=0 \
--machine-type n1-highmem-8 \
--preemptible \
--node-taints=preemptible=true:NoSchedule \
--scopes cloud-platform --verbosity error \
--accelerator=type=nvidia-tesla-k80,count=4
Anda juga dapat menyiapkan node pool melalui Cloud Console.
Menentukan Kubeflow Pipeline yang menggunakan node GKE yang dapat dihentikan
Jika menjalankan Kubeflow di GKE, Anda kini dapat dengan mudah menentukan dan menjalankan Kubeflow Pipelines dengan satu atau beberapa langkah pipeline (komponen) berjalan pada node yang dapat dihentikan, sehingga mengurangi biaya untuk menjalankan tugas. Agar dapat menggunakan preemptible VM untuk memberikan hasil yang benar, langkah yang Anda identifikasi sebagai preemptible harus bersifat idempoten (yaitu, jika Anda menjalankan langkah beberapa kali, langkah tersebut akan memberikan hasil yang sama), atau harus melakukan checkpoint sehingga langkah tersebut dapat melanjutkan dari tahap yang terakhir dijalankan jika terhenti.
Saat menentukan Kubeflow Pipeline, Anda dapat menunjukkan bahwa langkah tertentu harus dijalankan pada node yang dapat dihentikan dengan memodifikasi op seperti ini:
your_pipelines_op.apply(gcp.use_preemptible_nodepool())
Lihat dokumentasi untuk mengetahui detailnya.
Anda mungkin juga ingin mencoba kembali langkah tersebut beberapa kali jika node di-preempt. Anda dapat melakukannya seperti berikut. Di sini, kami menetapkan 5 percobaan ulang.
your_pipelines_op.set_gpu_limit(1).apply(gcp.use_preemptible_nodepool()).set_retry(5)
Coba edit pipeline Kubeflow yang kita gunakan dalam codelab ini untuk menjalankan langkah pelatihan pada preemptible VM.
Ubah baris berikut dalam spesifikasi pipeline untuk menggunakan kumpulan node yang dapat dihentikan sebagai tambahan (pastikan Anda telah membuatnya seperti yang ditunjukkan di atas) di atas, dan coba lagi 5 kali:
train.set_gpu_limit(1)
Kemudian, kompilasi ulang pipeline, upload versi baru (beri nama baru), lalu jalankan versi baru pipeline.