این صفحه به‌وسیله ‏Cloud Translation API‏ ترجمه شده است.

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

1. مقدمه

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

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

چیزی که خواهی ساخت

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

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

چیزی که یاد خواهید گرفت

خط لوله‌ای که می‌سازید، یک مدل Tensor2Tensor را بر روی داده‌های مربوط به GitHub آموزش می‌دهد، و یاد می‌گیرد که عناوین موضوع را از بدنه‌های نسخه پیش‌بینی کند. سپس مدل آموزش دیده را صادر می کند و مدل صادر شده را با استفاده از سرویس Tensorflow اجرا می کند. مرحله آخر در خط لوله، یک برنامه وب را راه اندازی می کند که با نمونه TF-Serving تعامل می کند تا پیش بینی های مدل را بدست آورد.

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

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

درک اولیه از Kubernetes مفید خواهد بود اما ضروری نیست
یک پروژه GCP فعال که برای آن مجوزهای مالک دارید
(اختیاری) یک حساب GitHub
دسترسی به Google Cloud Shell ، در کنسول Google Cloud Platform (GCP) موجود است

2. راه اندازی

پوسته ابری

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

در صورت نیاز روی «انتخاب پروژه» کلیک کنید تا در حال کار با پروژه Codelab خود باشید.

سپس روی نماد "فعال کردن پوسته ابری" در سمت راست بالای کنسول کلیک کنید تا یک Cloud Shell راه اندازی شود.

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

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

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

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

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

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

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

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

اختیاری: یک توکن GitHub ایجاد کنید

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

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

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

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

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

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

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

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

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

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 خارجی، تصویر سیستم عامل، نسخه هسته و زمان اجرای کانتینر مشاهده کنید.

خوشه را پیکربندی کنید تا درایور Nvidia را روی Node Pool های مجهز به gpu نصب کند

در مرحله بعد، ما یک دیمون ست را به کلاستر اعمال می کنیم که درایور Nvidia را روی هر گره خوشه ای مجهز به 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 با اندازه 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. یک خط لوله را از داشبورد Pipelines اجرا کنید

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

در Cloud Console، اگر قبلاً آنجا نیستید، از پانل Pipelines دیدن کنید. سپس برای نصب روی " OPEN PIPELINES DASHBOARD " کلیک کنید و در نوار منو سمت چپ روی Pipelines کلیک کنید. اگر با خطای بارگذاری مواجه شدید، برگه را بازخوانی کنید. شما باید صفحه جدیدی مانند این را ببینید:

توضیحات خط لوله

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

یک ایست بازرسی مدل موجود در سطل شما کپی شده است.
یک مدل Tensor2Tensor با استفاده از داده های از پیش پردازش شده آموزش داده شده است.

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

یک نمونه سرویس دهی TensorFlow با استفاده از آن مدل مستقر شده است.
یک برنامه وب برای تعامل با مدل ارائه شده برای بازیابی پیش بینی ها راه اندازی شده است.

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

در این بخش نحوه تدوین تعریف خط لوله را خواهیم دید. اولین کاری که باید انجام دهیم این است که 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 را انتخاب کنید. URL زیر را کپی کنید، سپس در آدرس زیر قرار دهید، که به همان خط لوله ای که به تازگی کامپایل کرده اید اشاره می کند. (این چند مرحله اضافی برای آپلود یک فایل از Cloud Shell است، بنابراین ما از یک میانبر استفاده می کنیم).

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

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

خط لوله را اجرا کنید

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

به آزمایش یک نام بدهید (مثلاً همان نام خط لوله، gh_summ )، سپس برای ایجاد روی Next کلیک کنید.

با این کار صفحه ای ظاهر می شود که در آن می توانید پارامترهای یک Run را وارد کرده و آن را شروع کنید.

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

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

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

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

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

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

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

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

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

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

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

داشبورد Artifacts and Executions را کاوش کنید

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

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

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

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

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

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

kubectl get services

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

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

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

پس از اجرای پورت فورواردینگ، روی نماد «پیش‌نمایش» در بالای صفحه Cloud Shell کلیک کنید و در منوی کشویی روی «پیش‌نمایش در پورت 8080» کلیک کنید.

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

برای بازیابی یک بلوک از متن، روی دکمه Populate Random Issue کلیک کنید. برای فراخوانی مدل آموزش دیده و نمایش یک پیش بینی، روی Generate TItle کلیک کنید.

اگر پارامترهای خط لوله شما شامل یک توکن معتبر GitHub می‌شد، می‌توانید متناوباً سعی کنید URL GitHub را در قسمت دوم وارد کنید و سپس روی «Generate Title» کلیک کنید. اگر یک توکن معتبر GitHub راه‌اندازی نکرده‌اید ، فقط از قسمت «پر کردن مشکل تصادفی» استفاده کنید.

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

همچنین می توانید به صورت تعاملی خطوط لوله Kubeflow را از یک نوت بوک Jupyter با استفاده از KFP SDK تعریف و اجرا کنید. نوت‌بوک‌های پلتفرم هوش مصنوعی ، که ما برای این کد لبه استفاده خواهیم کرد، این کار را بسیار ساده می‌کند.

یک نمونه نوت بوک ایجاد کنید

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

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

بعد از چند دقیقه سرور نوت بوک شما راه اندازی می شود. می‌توانید نمونه‌های Notebook خود را در فهرست Cloud Console ببینید.

نوت بوک Codelab را آپلود کنید

پس از ایجاد نمونه نوت‌بوک، روی این پیوند کلیک کنید تا دفترچه یادداشت Jupyter را بارگذاری کنید. نمونه نوت بوک را برای استفاده انتخاب کنید. نوت بوک به طور خودکار باز می شود.

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

دستورالعمل های موجود در دفترچه را برای بقیه آزمایشگاه دنبال کنید . توجه داشته باشید که در قسمت "Setup" نوت بوک، باید مقادیر خود را قبل از اجرای بقیه نوت بوک پر کنید.

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

5. پاکسازی کنید

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

خوشه Pipelines GKE را حذف کنید

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

نمونه AI Notebook را حذف کنید

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

اختیاری: توکن GitHub را حذف کنید

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

6. ضمائم

نگاهی به کد

تعریف خط لوله

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

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

مراحل خط لوله 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'
  )

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

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)

توجه داشته باشید که ما به مرحله "قطار" نیاز داریم تا بر روی گره ای در خوشه اجرا شود که حداقل 1 GPU در دسترس است.

  train.set_gpu_limit(1)

مرحله نهایی در خط لوله - همچنین به صورت خطی تعریف شده است - مشروط است. پس از اتمام مرحله " serve " اجرا می شود، تنها در صورتی که خروجی مرحله آموزشی launch_server رشته "true" باشد. «برنامه وب پیش‌بینی» را راه‌اندازی می‌کند، که ما از آن برای درخواست خلاصه مسائل از مدل آموزش‌دیده 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 برخی از بهترین شیوه ها را برای ساخت اجزای خود توضیح می دهد. به عنوان بخشی از این فرآیند، باید یک تصویر ظرف را تعریف و بسازید. شما می توانید مراحل کامپوننت را برای خط لوله این Codelab در اینجا ببینید. تعاریف Dockerfile در زیر شاخه های containers هستند، به عنوان مثال در اینجا .

برای آموزش از VMهای قابل پیش‌دستی با GPU استفاده کنید

ماشین‌های مجازی Preemptible نمونه‌های ماشین مجازی رایانه‌ای هستند که حداکثر ۲۴ ساعت دوام می‌آورند و هیچ تضمینی برای در دسترس بودن ندارند. قیمت ماشین های مجازی قابل پیشبرد کمتر از ماشین های مجازی موتور محاسباتی استاندارد است.

با Google Kubernetes Engine (GKE) ، تنظیم یک کلاستر یا گره استخر که از VMهای قابل پیش‌دستی استفاده می‌کند، آسان است. شما می توانید چنین استخر گره ای را با پردازنده های گرافیکی متصل به نمونه های اولیه راه اندازی کنید. اینها مانند گره‌های معمولی فعال با GPU کار می‌کنند، اما GPUها فقط برای تمام عمر نمونه باقی می‌مانند.

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

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

همچنین می‌توانید از طریق کنسول Cloud یک Node Pool راه‌اندازی کنید.

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

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

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

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 را که در این کد لبه استفاده می‌کردیم، ویرایش کنید تا مرحله آموزش را روی یک VM پیش‌دستی اجرا کنید .

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

  train.set_gpu_limit(1)

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