خطوط لوله Kubeflow - جمع بندی مسائل GitHub

۱. مقدمه

Kubeflow یک جعبه ابزار یادگیری ماشین برای Kubernetes است. این پروژه به ساده، قابل حمل و مقیاس‌پذیر کردن استقرار گردش‌های کاری یادگیری ماشین (ML) در Kubernetes اختصاص داده شده است. هدف، ارائه روشی ساده برای استقرار بهترین سیستم‌های متن‌باز برای یادگیری ماشین در زیرساخت‌های متنوع است.

یک گردش کار یادگیری ماشین می‌تواند شامل مراحل زیادی با وابستگی‌های متقابل باشد، از آماده‌سازی و تجزیه و تحلیل داده‌ها گرفته تا آموزش، ارزیابی، استقرار و موارد دیگر. ترکیب و پیگیری این فرآیندها به صورت موردی - به عنوان مثال، در مجموعه‌ای از دفترچه یادداشت‌ها یا اسکریپت‌ها - دشوار است و مواردی مانند حسابرسی و تکرارپذیری به طور فزاینده‌ای مشکل‌ساز می‌شوند. Kubeflow Pipelines (KFP) با ارائه راهی برای استقرار خطوط لوله یادگیری ماشین قوی و تکرارپذیر به همراه نظارت، حسابرسی، ردیابی نسخه و تکرارپذیری، به حل این مشکلات کمک می‌کند. Cloud AI Pipelines راه‌اندازی نصب KFP را آسان می‌کند.

آنچه خواهید ساخت

در این آزمایشگاه کد، شما یک برنامه وب خواهید ساخت که مسائل مربوط به گیت‌هاب را با استفاده از Kubeflow Pipelines برای آموزش و ارائه یک مدل خلاصه می‌کند. این برنامه بر اساس یک مثال در مخزن Kubeflow Examples ساخته شده است. پس از اتمام، زیرساخت شما شامل موارد زیر خواهد بود:

  • یک کلاستر از موتور گوگل کوبرنتیز (GKE) که Kubeflow Pipelines (از طریق Cloud AI Pipelines ) روی آن نصب شده باشد.
  • خط لوله‌ای که یک مدل Tensor2Tensor را روی GPUها آموزش می‌دهد
  • یک ظرف سرو که پیش‌بینی‌هایی از مدل آموزش‌دیده ارائه می‌دهد
  • رابط کاربری که پیش‌بینی‌ها را تفسیر می‌کند تا خلاصه‌هایی برای مشکلات GitHub ارائه دهد
  • دفترچه یادداشتی که با استفاده از SDK مربوط به Kubeflow Pipelines (KFP) یک خط لوله از ابتدا ایجاد می‌کند.

آنچه یاد خواهید گرفت

پایپ‌لاین (pipeline) که شما خواهید ساخت، یک مدل Tensor2Tensor را روی داده‌های مسئله‌ی گیت‌هاب آموزش می‌دهد و یاد می‌گیرد که عناوین مسئله را از بدنه‌های مسئله پیش‌بینی کند. سپس مدل آموزش‌دیده را صادر می‌کند و مدل صادر شده را با استفاده از Tensorflow Serving مستقر می‌کند. مرحله‌ی آخر در پایپ‌لاین، یک برنامه‌ی وب را راه‌اندازی می‌کند که با نمونه‌ی TF-Serving تعامل دارد تا پیش‌بینی‌های مدل را دریافت کند.

  • نحوه نصب Kubeflow Pipelines روی کلاستر GKE
  • نحوه ساخت و اجرای گردش‌های کاری یادگیری ماشین با استفاده از Kubeflow Pipelines
  • نحوه تعریف و اجرای خطوط لوله از یک نوت بوک پلتفرم هوش مصنوعی

آنچه نیاز دارید

۲. راه‌اندازی

پوسته ابری

به کنسول GCP در مرورگر مراجعه کنید و با اطلاعات پروژه خود وارد شوید:

در صورت نیاز، روی «انتخاب یک پروژه» کلیک کنید تا با پروژه codelab خود کار کنید.

4f23e1fe87a47cb2.png

سپس روی آیکون «فعال‌سازی پوسته ابری» در سمت راست بالای کنسول کلیک کنید تا یک پوسته ابری راه‌اندازی شود.

ecf212797974dd31.png

وقتی Cloud Shell را اجرا می‌کنید، نام پروژه‌ای که قرار است از آن استفاده کند را به شما می‌گوید. بررسی کنید که این تنظیم صحیح باشد.

برای یافتن شناسه پروژه خود، به پنل اصلی کنسول GCP مراجعه کنید. اگر صفحه خالی است، برای ایجاد داشبورد، روی «بله» کلیک کنید.

115cdf745978ad.png

سپس، در ترمینال Cloud Shell، در صورت لزوم این دستورات را اجرا کنید تا gcloud برای استفاده از پروژه صحیح پیکربندی کنید:

export PROJECT_ID=<your_project_id>
gcloud config set project ${PROJECT_ID}

یک سطل ذخیره‌سازی ایجاد کنید

یک سطل ذخیره‌سازی ابری برای ذخیره‌سازی فایل‌های خط لوله ایجاد کنید. شما باید از یک شناسه منحصر به فرد جهانی استفاده کنید، بنابراین تعریف نام سطلی که شامل شناسه پروژه شما باشد، راحت‌تر است. سطل را با استفاده از دستور gsutil mb (make bucket) ایجاد کنید:

export PROJECT_ID=<your_project_id>
export BUCKET_NAME=kubeflow-${PROJECT_ID}
gsutil mb gs://${BUCKET_NAME}

از طرف دیگر، می‌توانید از طریق کنسول GCP یک سطل ایجاد کنید.

اختیاری**: ایجاد یک توکن گیت‌هاب**

این آزمایشگاه کد، API گیت‌هاب را برای بازیابی داده‌های عمومی فراخوانی می‌کند. برای جلوگیری از محدود کردن سرعت، به خصوص در رویدادهایی که تعداد زیادی درخواست ناشناس به APIهای گیت‌هاب ارسال می‌شود، یک توکن دسترسی بدون مجوز تنظیم کنید. این کار صرفاً برای تأیید شما به عنوان یک فرد به جای کاربر ناشناس انجام می‌شود.

  1. به آدرس https://github.com/settings/tokens بروید و یک توکن جدید بدون محدوده (scope) ایجاد کنید.
  2. آن را در جایی امن ذخیره کنید. اگر آن را گم کردید، باید آن را حذف کرده و یک مورد جدید ایجاد کنید.

اگر از این مرحله صرف نظر کنید، آزمایشگاه همچنان کار خواهد کرد - فقط در گزینه‌های خود برای تولید داده‌های ورودی برای آزمایش مدل خود کمی محدودتر خواهید شد.

اختیاری: پین کردن داشبوردهای مفید

در کنسول GCP، داشبوردهای Kubernetes Engine و Storage را برای دسترسی آسان‌تر پین کنید.

2a50622902d75f6a.png

ایجاد نصب AI Platform Pipelines (Hosted Kubeflow Pipelines)

برای راه‌اندازی یک نمونه GKE با KFP نصب‌شده، دستورالعمل‌های بخش‌های «قبل از شروع» و «راه‌اندازی نمونه» را در اینجا دنبال کنید. حتماً کادر « اجازه دسترسی به APIهای ابری زیر» را همانطور که در مستندات نشان داده شده است، علامت بزنید. (اگر این کار را نکنید، خط لوله نمونه با موفقیت اجرا نخواهد شد). فضای نام نصب را به صورت default باقی بگذارید.

شما باید منطقه‌ای را انتخاب کنید که از کارت‌های گرافیک Nvidia k80 پشتیبانی کند. می‌توانید از us-central1-a یا us-central1-c به عنوان پیش‌فرض استفاده کنید.

نام خوشه GKE و منطقه‌ی فهرست‌شده برای نصب شما در داشبورد AI Pipelines پس از اتمام نصب را یادداشت کنید و برای راحتی، متغیرهای محیطی را روی این مقادیر تنظیم کنید.

6f0729a4fdee88ac.png

export ZONE=<your zone>
export CLUSTER_NAME=<your cluster name>

kubectl را برای استفاده از اعتبارنامه‌های کلاستر جدید GKE خود تنظیم کنید

پس از ایجاد کلاستر GKE، با اجرای دستور زیر در Cloud Shell خود، kubectl طوری پیکربندی کنید که از اعتبارنامه‌های کلاستر جدید استفاده کند:

gcloud container clusters get-credentials ${CLUSTER_NAME} \
  --project ${PROJECT_ID} \
  --zone ${ZONE}

روش دیگر این است که روی نام کلاستر در داشبورد AI Pipelines کلیک کنید تا به صفحه GKE آن بروید، سپس روی «اتصال» در بالای صفحه کلیک کنید. از پنجره باز شده، دستور را در Cloud Shell خود جایگذاری کنید.

این، زمینه kubectl شما را پیکربندی می‌کند تا بتوانید با کلاستر خود تعامل داشته باشید. برای تأیید پیکربندی، دستور زیر را اجرا کنید:

kubectl get nodes -o wide

شما باید گره‌هایی را با وضعیت « Ready » و سایر اطلاعات مربوط به سن گره، نسخه، آدرس IP خارجی، تصویر سیستم عامل، نسخه هسته و زمان اجرای کانتینر مشاهده کنید.

پیکربندی کلاستر برای نصب درایور انویدیا روی گره‌های دارای پردازنده گرافیکی

در مرحله بعد، یک daemonset را به کلاستر اعمال خواهیم کرد که درایور انویدیا را روی هر گره کلاستر مجهز به GPU نصب می‌کند:

kubectl apply -f https://raw.githubusercontent.com/GoogleCloudPlatform/container-engine-accelerators/master/nvidia-driver-installer/cos/daemonset-preloaded.yaml

سپس دستور زیر را اجرا کنید، که به اجزای KFP اجازه ایجاد منابع جدید Kubernetes را می‌دهد:

kubectl create clusterrolebinding sa-admin --clusterrole=cluster-admin --serviceaccount=kubeflow:pipeline-runner

ایجاد یک استخر گره GPU

سپس، یک استخر گره GPU با اندازه ۱ راه‌اندازی خواهیم کرد:

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

۳. اجرای یک خط لوله از داشبورد Pipelines

داشبورد Pipelines را باز کنید

در کنسول ابری، اگر هنوز به پنل خطوط لوله (Pipelines) نرفته‌اید، به آنجا بروید. سپس برای نصب روی « باز کردن داشبورد خطوط لوله » کلیک کنید و در نوار منوی سمت چپ روی خطوط لوله کلیک کنید. اگر با خطای بارگذاری مواجه شدید، برگه را رفرش کنید. باید صفحه جدیدی مانند این را ببینید:

7bb5a9cf0773c3bc.png

شرح خط لوله

خط لوله‌ای که اجرا خواهید کرد چندین مرحله دارد (برای جزئیات بیشتر به پیوست این آزمایشگاه کد مراجعه کنید):

  1. یک ایستگاه بازرسی مدل موجود در سطل شما کپی می‌شود.
  2. یک مدل Tensor2Tensor با استفاده از داده‌های پیش‌پردازش‌شده آموزش داده می‌شود.
  • آموزش از نقطه کنترل مدل موجود که در مرحله اول کپی شده است شروع می‌شود، سپس برای چند صد مرحله دیگر آموزش داده می‌شود. (آموزش کامل آن در طول آزمایشگاه کد خیلی طول می‌کشد).
  • وقتی آموزش تمام شد، مرحله خط لوله، مدل را به شکلی مناسب برای ارائه توسط TensorFlow serving صادر می‌کند.
  1. یک نمونه‌ی سرویس‌دهنده‌ی TensorFlow با استفاده از آن مدل مستقر می‌شود.
  2. یک برنامه وب برای تعامل با مدل ارائه شده جهت بازیابی پیش‌بینی‌ها راه‌اندازی می‌شود.

دانلود و کامپایل خط لوله

در این بخش، نحوه کامپایل تعریف خط لوله را خواهیم دید. اولین کاری که باید انجام دهیم نصب KFP SDK است. دستور زیر را در Cloud Shell اجرا کنید:

pip3 install -U kfp

برای دانلود فایل تعریف خط لوله، این دستور را از Cloud Shell اجرا کنید: 

curl -O https://raw.githubusercontent.com/amygdala/kubeflow-examples/ghsumm/github_issue_summarization/pipelines/example_pipelines/gh_summ_hosted_kfp.py

سپس فایل تعریف خط لوله را با اجرای آن به صورت زیر کامپایل کنید: 

python3 gh_summ_hosted_kfp.py

خواهید دید که فایل gh_summ_hosted_kfp.py.tar.gz به عنوان نتیجه ظاهر می‌شود.

خط لوله کامپایل شده را آپلود کنید

در رابط کاربری وب Kubeflow Pipelines، روی Upload pipeline کلیک کنید و Import by URL را انتخاب کنید. آدرس زیر را که به همان pipeline ای که کامپایل کرده‌اید اشاره دارد، کپی و سپس در آن جایگذاری کنید. (آپلود فایل از Cloud Shell چند مرحله اضافی دارد، بنابراین ما از یک میانبر استفاده می‌کنیم).

https://storage.googleapis.com/aju-dev-demos-codelabs/KF/compiled_pipelines/gh_summ_hosted_kfp.py.tar.gz

به خط لوله یک نام بدهید (مثلاً gh_summ ).

867fdbe248d13bab.png

اجرای خط لوله

روی خط لوله آپلود شده در لیست کلیک کنید - این به شما امکان می‌دهد نمودار استاتیک خط لوله را مشاهده کنید - سپس روی ایجاد آزمایش کلیک کنید تا یک آزمایش جدید با استفاده از خط لوله ایجاد شود. آزمایش راهی برای گروه‌بندی اجراهای مرتبط از نظر معنایی است.

d4b5b1a043d32d4a.png

برای Experiment یک نام انتخاب کنید (مثلاً همان نام pipeline، gh_summ )، سپس برای ایجاد روی Next کلیک کنید.

d9f7d2177efad53.png

این صفحه‌ای را نمایش می‌دهد که می‌توانید پارامترهای مربوط به اجرای برنامه را در آن وارد کرده و آن را شروع کنید.

ممکن است بخواهید دستورات زیر را در Cloud Shell اجرا کنید تا به پر کردن پارامترها کمک کند. 

gcloud config get-value project
echo "gs://${BUCKET_NAME}/codelab"

نام Run به صورت خودکار پر می‌شود، اما در صورت تمایل می‌توانید نام دیگری به آن بدهید.

سپس سه فیلد پارامتر را پر کنید:

  • project
  • (اختیاری) github-token
  • working-dir

برای working-dir، مسیری را در زیر باکت GCS که ایجاد کرده‌اید وارد کنید. پیشوند ' gs:// ' را نیز وارد کنید. برای فیلد github-token ، یا توکنی را که قبلاً به صورت اختیاری ایجاد کرده‌اید وارد کنید، یا اگر توکنی ایجاد نکرده‌اید، رشته‌ی جای‌نگهدار را به همان صورت باقی بگذارید.

8676afba6fd32ac1.png

پس از پر کردن فیلدها، روی Start کلیک کنید، سپس روی اجرای فهرست‌شده کلیک کنید تا جزئیات آن را مشاهده کنید. در حالی که یک مرحله خط لوله مشخص در حال اجرا است، می‌توانید روی آن کلیک کنید تا اطلاعات بیشتری در مورد آن، از جمله مشاهده گزارش‌های pod آن، به دست آورید. (همچنین می‌توانید گزارش‌های مربوط به یک مرحله خط لوله را از طریق لینک گزارش‌های Cloud Logging (Stackdriver) آن مشاهده کنید، حتی اگر گره خوشه از بین رفته باشد).

db2dc819ac0f5c1.png

تعریف خط لوله را مشاهده کنید

در حین اجرای خط لوله، شاید بخواهید نگاه دقیق‌تری به نحوه‌ی سرهم‌بندی و عملکرد آن بیندازید. جزئیات بیشتر در بخش پیوست‌های آزمایشگاه کد وجود دارد.

مشاهده اطلاعات آموزش مدل در TensorBoard

پس از اتمام مرحله آموزش، تب Visualizations را انتخاب کرده و روی دکمه آبی Start TensorBoard کلیک کنید، سپس پس از آماده شدن، روی Open Tensorboard کلیک کنید.

6cb511540a64b9e5.png

d55eb03c4d04f64d.png

داشبورد مصنوعات و اجراها را کاوش کنید

Kubeflow Pipelines به طور خودکار فراداده‌های مربوط به مراحل خط لوله را هنگام اجرای خط لوله ثبت می‌کند. اطلاعات مربوط به مصنوعات و اجرا هر دو ثبت می‌شوند. برای بررسی بیشتر، روی این ورودی‌ها در نوار ناوبری سمت چپ داشبورد کلیک کنید.

3002c4055cc8960b.png

برای مصنوعات، می‌توانید هم پنل مرور کلی و هم پنل Lineage Explorer را مشاهده کنید.

7885776e899d1183.png

40c4f7e5b6545dec.png

برنامه وب ایجاد شده توسط خط لوله را اجرا کنید و پیش‌بینی‌هایی انجام دهید

آخرین مرحله در این فرآیند، استقرار یک برنامه وب است که یک رابط کاربری برای پرس‌وجو از مدل آموزش‌دیده - که از طریق TF Serving ارائه می‌شود - جهت انجام پیش‌بینی‌ها فراهم می‌کند.

پس از اتمام خط لوله، با پورت فورواردینگ به سرویس برنامه وب متصل شوید (ما پورت فورواردینگ انجام می‌دهیم زیرا برای این آزمایشگاه کد، سرویس برنامه وب برای داشتن یک نقطه پایانی خارجی تنظیم نشده است).

با اجرای این دستور در Cloud Shell، نام سرویس را پیدا کنید: 

kubectl get services

در لیست، به دنبال نام سرویسی مانند ghsumm-*-webappsvc بگردید.

سپس، در Cloud Shell، به صورت زیر به آن سرویس پورت فوروارد کنید و دستور زیر را به نام webappsvc خود تغییر دهید : 

kubectl port-forward svc/ghsumm-xxxxx-webappsvc 8080:80

پس از اجرای پورت فورواردینگ، روی آیکون «پیش‌نمایش» در بالای پنل Cloud Shell کلیک کنید و در منوی کشویی، روی «پیش‌نمایش روی پورت ۸۰۸۰» کلیک کنید.

65572bb3b12627cc.png

شما باید صفحه‌ای مانند این را در یک تب جدید ببینید:

902ad2d555281508.png

برای بازیابی یک بلوک متن، روی دکمه‌ی «جمع‌آوری تصادفی مسئله» کلیک کنید. برای فراخوانی مدل آموزش‌دیده و نمایش پیش‌بینی، روی «ایجاد عنوان» کلیک کنید.

b7c39ce51ee603bd.png

اگر پارامترهای خط لوله شما شامل یک توکن GitHub معتبر بود، می‌توانید به طور متناوب یک URL GitHub را در فیلد دوم وارد کنید، سپس روی "ایجاد عنوان" کلیک کنید. اگر یک توکن GitHub معتبر تنظیم نکرده‌اید ، فقط از فیلد "پر کردن شماره تصادفی" استفاده کنید.

۴. اجرای یک خط لوله از یک نوت‌بوک پلتفرم هوش مصنوعی

همچنین می‌توانید به صورت تعاملی، Kubeflow Pipelines را از یک Jupyter notebook با استفاده از KFP SDK تعریف و اجرا کنید. AI Platform Notebooks که ما برای این آزمایشگاه کد از آن استفاده خواهیم کرد، این کار را بسیار ساده می‌کند.

یک نمونه دفترچه یادداشت ایجاد کنید

ما با استفاده از API مربوط به Cloud Shell، یک نمونه دفترچه یادداشت از آن ایجاد خواهیم کرد. (همچنین می‌توانید از طریق Cloud Console یک دفترچه یادداشت ایجاد کنید. برای اطلاعات بیشتر به مستندات مراجعه کنید.)

متغیرهای محیطی زیر را در 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"

سپس، از Cloud Shell، دستور زیر را برای ایجاد نمونه نوت‌بوک اجرا کنید: 

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

وقتی برای اولین بار این دستور را اجرا می‌کنید، ممکن است از شما خواسته شود که API notebooks را برای پروژه خود فعال کنید. در این صورت، ' y ' را تایپ کنید.

بعد از چند دقیقه، سرور نوت‌بوک شما راه‌اندازی و اجرا خواهد شد. می‌توانید نمونه‌های نوت‌بوک خود را که در کنسول ابری فهرست شده‌اند، مشاهده کنید.

206adf3905413dfa.png

دفترچه کدلب را آپلود کنید

پس از ایجاد نمونه نوت‌بوک، روی این لینک کلیک کنید تا نوت‌بوک Jupyter مربوط به codelab آپلود شود. نمونه نوت‌بوک مورد نظر را انتخاب کنید. نوت‌بوک به طور خودکار باز خواهد شد.

دفترچه یادداشت را اجرا کنید

برای ادامه‌ی آزمایش ، دستورالعمل‌های دفترچه را دنبال کنید . توجه داشته باشید که در بخش «تنظیمات» دفترچه، قبل از اجرای بقیه‌ی دفترچه، باید مقادیر خودتان را وارد کنید.

(اگر از پروژه خودتان استفاده می‌کنید، فراموش نکنید که به بخش «پاکسازی» این آزمایش برگردید و آن را انجام دهید.)

۵. تمیز کردن

اگر از یک حساب کاربری موقت codelab استفاده می‌کنید، نیازی به انجام این کار ندارید، اما اگر از پروژه خودتان استفاده می‌کنید، ممکن است بخواهید نصب Pipelines و Notebook خود را حذف کنید.

خوشه Pipelines GKE را از کار بیندازید

شما می‌توانید کلاستر Pipelines را از Cloud Console حذف کنید. (اگر می‌خواهید از کلاستر GKE دوباره استفاده کنید، می‌توانید فقط نصب Pipelines را حذف کنید.)

نمونه‌ی نوت‌بوک هوش مصنوعی را حذف کنید

اگر بخش «دفترچه یادداشت» از codelab را اجرا کرده‌اید، می‌توانید نمونه دفترچه یادداشت را از Cloud Console حذف یا متوقف کنید .

اختیاری: توکن گیت‌هاب را حذف کنید

به آدرس https://github.com/settings/tokens بروید و توکن تولید شده را حذف کنید.

۶. ضمائم

نگاهی به کد

تعریف خط لوله

خط لوله مورد استفاده در این آزمایشگاه کد در اینجا تعریف شده است.

بیایید نگاهی به نحوه تعریف آن و همچنین نحوه تعریف اجزای (مراحل) آن بیندازیم. ما برخی از نکات برجسته را پوشش خواهیم داد، اما برای جزئیات بیشتر به مستندات مراجعه کنید.

مراحل خط لوله Kubeflow مبتنی بر کانتینر هستند. هنگام ساخت یک خط لوله، می‌توانید از اجزای از پیش ساخته شده ، با تصاویر کانتینر از قبل ساخته شده استفاده کنید یا اجزای خود را بسازید. برای این آزمایشگاه کد، ما خودمان آن را ساخته‌ایم.

چهار مورد از مراحل خط لوله از کامپوننت‌های قابل استفاده مجدد تعریف شده‌اند که از طریق فایل‌های تعریف کامپوننت آنها قابل دسترسی هستند. در این قطعه کد اول، ما از طریق URL به این فایل‌های تعریف کامپوننت دسترسی پیدا می‌کنیم و از این تعاریف برای ایجاد «ops» استفاده می‌کنیم که برای ایجاد یک مرحله خط لوله از آنها استفاده خواهیم کرد. 

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

در زیر یکی از تعاریف کامپوننت، برای عملیات آموزشی، در قالب yaml آمده است. می‌توانید ببینید که ورودی‌ها، خروجی‌ها، تصویر کانتینر و آرگومان‌های نقطه ورودی کانتینر تعریف شده‌اند. 

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

همچنین می‌توانید یک مرحله از خط لوله را از طریق سازنده dsl.ContainerOp تعریف کنید، همانطور که در ادامه خواهیم دید.

در زیر بخش عمده‌ای از تعریف خط لوله آمده است. ما ورودی‌های خط لوله (و مقادیر پیش‌فرض آنها) را تعریف می‌کنیم. سپس مراحل خط لوله را تعریف می‌کنیم. در بیشتر موارد، ما از «ops» تعریف شده در بالا استفاده می‌کنیم، اما همچنین یک مرحله «serve» را به صورت درون خطی از طریق ContainerOp تعریف می‌کنیم که تصویر کانتینر و آرگومان‌های نقطه ورود را مستقیماً مشخص می‌کند.

می‌توانید ببینید که مراحل train ، log_model و serve به خروجی‌های مراحل قبلی به عنوان ورودی دسترسی دارند. می‌توانید اطلاعات بیشتر در مورد نحوه تعیین این مورد را اینجا بخوانید. 

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

توجه داشته باشید که ما به مرحله «آموزش» نیاز داریم تا روی گره‌ای در کلاستر اجرا شود که حداقل یک پردازنده گرافیکی (GPU) در دسترس داشته باشد. 

  train.set_gpu_limit(1)

مرحله آخر در خط لوله - که به صورت درون‌خطی تعریف شده است - شرطی است. این مرحله پس از اتمام مرحله ' serve ' اجرا می‌شود، تنها در صورتی که خروجی launch_server در مرحله آموزش، رشته 'true' باشد. این مرحله 'prediction web app' را اجرا می‌کند، که ما برای درخواست خلاصه مسائل از مدل آموزش دیده T2T از آن استفاده کردیم. 

 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)

تعاریف تصویر کانتینر کامپوننت

مستندات Kubeflow Pipeline برخی از بهترین شیوه‌ها را برای ساخت کامپوننت‌های خودتان شرح می‌دهد. به عنوان بخشی از این فرآیند، شما نیاز به تعریف و ساخت یک تصویر کانتینر دارید. می‌توانید مراحل کامپوننت برای pipeline این codelab را اینجا ببینید. تعاریف Dockerfile در زیرشاخه‌های containers ، مثلاً اینجا ، قرار دارند.

استفاده از ماشین‌های مجازی قابل قبضه کردن به همراه پردازنده‌های گرافیکی (GPU) برای آموزش

ماشین‌های مجازی قابل قبضه کردن (Preemptible VMs)، نمونه‌هایی از ماشین‌های مجازی موتور محاسباتی (Compute Engine VM) هستند که حداکثر ۲۴ ساعت دوام می‌آورند و هیچ تضمینی برای در دسترس بودن ارائه نمی‌دهند. قیمت ماشین‌های مجازی قابل قبضه کردن (Preemptible VMs) کمتر از ماشین‌های مجازی موتور محاسباتی استاندارد است.

با موتور گوگل کوبرنتیز (GKE) ، راه‌اندازی یک کلاستر یا مجموعه گره که از ماشین‌های مجازی قابل قبضه کردن استفاده می‌کند، آسان است. می‌توانید چنین مجموعه گره‌ای را با GPUهای متصل به نمونه‌های قابل قبضه کردن راه‌اندازی کنید. این نمونه‌ها مانند گره‌های معمولی دارای GPU کار می‌کنند، اما GPUها فقط تا پایان عمر نمونه باقی می‌مانند.

شما می‌توانید با اجرای دستوری مشابه دستور زیر، ویرایش دستور زیر با نام و منطقه خوشه خود و تنظیم نوع و تعداد شتاب‌دهنده بر اساس نیازهای خود، یک مجموعه گره با قابلیت قبضه کردن و GPU-فعال برای خوشه خود راه‌اندازی کنید. می‌توانید به صورت اختیاری مجموعه گره را طوری تعریف کنید که بر اساس حجم کار فعلی، به صورت خودکار مقیاس‌بندی شود. 

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

همچنین می‌توانید از طریق کنسول ابری، یک مجموعه گره (node ​​pool) راه‌اندازی کنید.

تعریف یک خط لوله Kubeflow که از گره‌های GKE قابل قبضه کردن استفاده می‌کند

اگر Kubeflow را روی GKE اجرا می‌کنید، اکنون تعریف و اجرای Kubeflow Pipelines که در آن یک یا چند مرحله (مولفه) خط لوله روی گره‌های preemptible اجرا می‌شوند ، آسان است و هزینه اجرای یک کار را کاهش می‌دهد. برای اینکه استفاده از ماشین‌های مجازی preemptible نتایج صحیحی داشته باشد، مراحلی که شما به عنوان preemptible شناسایی می‌کنید یا باید idempotent باشند (یعنی اگر یک مرحله را چندین بار اجرا کنید، نتیجه یکسانی داشته باشد)، یا باید دارای Checkpoint باشند تا در صورت قطع شدن، مرحله بتواند از جایی که متوقف شده بود، ادامه یابد.

هنگام تعریف یک Kubeflow Pipeline، می‌توانید با تغییر op به این شکل، مشخص کنید که یک مرحله مشخص باید روی یک گره preemptible اجرا شود: 

your_pipelines_op.apply(gcp.use_preemptible_nodepool())

برای جزئیات بیشتر به مستندات مراجعه کنید.

اگر گره از قبل قبضه شده باشد، احتمالاً می‌خواهید این مرحله را چند بار تکرار کنید. می‌توانید این کار را به صورت زیر انجام دهید - در اینجا، ما 5 تلاش مجدد را مشخص می‌کنیم. 

your_pipelines_op.set_gpu_limit(1).apply(gcp.use_preemptible_nodepool()).set_retry(5)

سعی کنید خط لوله Kubeflow را که در این آزمایشگاه کد استفاده کردیم، ویرایش کنید تا مرحله آموزش را روی یک ماشین مجازی قابل قبضه کردن اجرا کنید .

خط زیر را در مشخصات خط لوله تغییر دهید تا علاوه بر این از یک nodepool قابل قبضه کردن (مطمئن شوید که همانطور که در بالا ذکر شد، یکی ایجاد کرده‌اید) در بالا استفاده کند و 5 بار دوباره امتحان کند: 

  train.set_gpu_limit(1)

سپس، خط لوله را دوباره کامپایل کنید، نسخه جدید را آپلود کنید (نام جدیدی به آن بدهید)، و سپس نسخه جدید خط لوله را اجرا کنید.