דף זה תורגם על ידי Cloud Translation API.

צינורות עיבוד נתונים של Kubeflow – סיכום בעיות ב-GitHub

1. מבוא

Kubeflow היא ערכת כלים ללמידת מכונה ל-Kubernetes. הפרויקט מיועד לפריסות של תהליכי עבודה של למידת מכונה (ML) ב-Kubernetes לפשוט, נייד וניתנה להתאמה. המטרה היא לספק דרך פשוטה לפרוס מערכות קוד פתוח מהטובות ביותר ללמידת מכונה (ML) לתשתיות מגוונות.

תהליך עבודה של למידת מכונה עשוי לכלול שלבים רבים שתלויים בין שני גורמים, מהכנה וניתוח של נתונים, דרך הכשרה, הערכה, פריסה ועוד. קשה להרכיב את התהליכים האלה ולעקוב אחריהם בצורה אד-הוק – למשל, בקבוצה של קובצי notebook או סקריפטים, ודברים כמו ביקורת ושחזור הופכים להיות בעייתיים יותר ויותר.Kubeflow Pipelines (KFP) עוזר לפתור את הבעיות האלה בכך שהוא מספק דרך לפרוס צינורות עיבוד נתונים חזקים של למידת מכונה שניתן לחזור עליהם יחד עם מעקב, ביקורת, מעקב אחר גרסאות ושחזור. קל להגדיר התקנה של KFP ב-Cloud AI Pipelines.

מה תפַתחו

ב-Codelab הזה תפתחו אפליקציית אינטרנט שמסכמת בעיות ב-GitHub באמצעות Kubeflow Pipelines כדי לאמן ולהציג מודל. הוא מבוסס על דוגמה במאגר הדוגמאות של Kobeflow. בסיום התהליך, התשתית שלכם תכיל:

אשכול Google Kubernetes Engine (GKE) שמותקן בו Kubeflow Pipelines (דרך Cloud AI Pipelines).
צינור עיבוד נתונים לאימון מודל Tensor2Tensor במעבדי GPU
מאגר להצגת מודעות שמספק חיזויים מהמודל שעבר אימון
ממשק משתמש שמפרש את החיזויים כדי לספק סיכום של בעיות ב-GitHub
notebook שיוצר צינור עיבוד נתונים מאפס באמצעות Kubeflow Pipelines (KFP) SDK

מה תלמדו

צינור עיבוד הנתונים שתפתחו לאמן מודל Tensor2Tensor על נתוני בעיות ב-GitHub, ולומד לחזות את כותרות הבעיות מגוף הבעיות. לאחר מכן הוא מייצא את המודל שעבר אימון ופורס את המודל שייצאתם באמצעות הצגה של Tensorflow. השלב האחרון בצינור עיבוד הנתונים מפעיל אפליקציית אינטרנט שמקיימת אינטראקציה עם המכונה של TF-serving כדי לקבל חיזויים של מודלים.

איך להתקין את Kubeflow Pipelines באשכול GKE
איך ליצור ולהפעיל תהליכי עבודה של למידת מכונה באמצעות Kubeflow Pipelines
איך מגדירים ומריצים צינורות עיבוד נתונים מnotebook של AI Platform

מה צריך להכין

הבנה בסיסית של Kubernetes תהיה מועילה, אבל לא הכרחית
פרויקט GCP פעיל שיש לך בו הרשאות בעלים
(אופציונלי) חשבון GitHub
גישה אל Google Cloud Shell, שזמינה במסוף Google Cloud Platform (GCP)

2. הגדרה

Cloud Shell

נכנסים למסוף GCP בדפדפן ומתחברים עם פרטי הכניסה לפרויקט:

לוחצים על Select a project (בחירת פרויקט). אם צריך, כדי לעבוד עם פרויקט Codelab.

לאחר מכן לוחצים על Enable Cloud Shell (הפעלת Cloud Shell). בפינה השמאלית העליונה של המסוף כדי להפעיל 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

ה-Codelab הזה מפעיל את GitHub API כדי לאחזר נתונים שזמינים באופן ציבורי. כדי למנוע הגבלת קצב של יצירת בקשות, במיוחד באירועים שבהם נשלחים מספר גדול של בקשות אנונימיות לממשקי ה-API של GitHub, כדאי להגדיר אסימון גישה ללא הרשאות. פעולה זו נועדה רק לאישורך כאדם פרטי ולא כמשתמש אנונימי.

עוברים אל https://github.com/settings/tokens ויוצרים אסימון חדש ללא היקפים.
שומרים את הקובץ במקום בטוח. אם איבדת את הבעלות, עליך למחוק וליצור חשבון חדש.

אם תדלגו על השלב הזה, שיעור ה-Lab עדיין יפעל – האפשרויות ליצירת נתוני קלט יהיו מוגבלות יותר לבדיקת המודל.

אופציונלי: הצמדת מרכזי בקרה שימושיים

כדי לגשת בקלות רבה יותר למסוף GCP, ניתן להצמיד את לוחות הבקרה Kubernetes Engine ו-Storage.

יצירת התקנה של AI Platform Pipelines (Hosted Kubeflow Pipelines)

עליך לפעול לפי ההוראות בקטע 'לפני שמתחילים' או 'Set up your instance' (הגדרת המכונה) כאן כדי להגדיר מכונת GKE שמותקנת בה KFP. חשוב לסמן את התיבה מתן גישה ל-Cloud APIs הבאים, כפי שמצוין במסמכי התיעוד. (אם לא תעשו זאת, צינור עיבוד הנתונים לדוגמה לא יפעל בהצלחה). צריך להשאיר את מרחב השמות להתקנה בתור default.

עליך לבחור אזור שתומך ב-Nvidia k80s. כברירת מחדל, אפשר להשתמש ב-us-central1-a או ב-us-central1-c.

חשוב לשים לב לשם האשכול ולתחום של GKE שמפורטים במרכז הבקרה של AI Pipelines לאחר השלמת ההתקנה, וכדי שיהיה קל יותר להגדיר משתני סביבה לערכים האלה.

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

הגדרת kubectl לשימוש בפרטי הכניסה של אשכול GKE החדש

אחרי שיוצרים את אשכול ה-GKE, צריך להגדיר ל-kubectl להשתמש בפרטי הכניסה של האשכול החדש על ידי הרצת הפקודה הבאה ב-Cloud Shell:

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

לחלופין, אפשר ללחוץ על שם האשכול במרכז הבקרה של AI Pipelines כדי להיכנס לדף GKE שלו, ואז ללחוץ על 'Connect' בראש הדף. מהחלון הקופץ, מדביקים את הפקודה ב-Cloud Shell.

הפעולה הזו מגדירה את ההקשר של kubectl כדי שתוכלו לבצע אינטראקציה עם האשכול. כדי לבדוק את ההגדרות, מריצים את הפקודה הבאה:

kubectl get nodes -o wide

אמורים להופיע צמתים עם הסטטוס "Ready" ומידע נוסף על גיל הצומת, גרסה, כתובת IP חיצונית, קובץ אימג' של מערכת ההפעלה, גרסת ליבה וזמן ריצה של הקונטיינר.

הגדרת האשכול להתקנת מנהל התקן Nvidia במאגרי צמתים שתומכים ב-gpu

בשלב הבא נחיל daemonset על האשכול. המערכת תתקין את מנהל התקן ה-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, נכנסים לחלונית Pipelines אם אתם לא נמצאים בה עדיין. לאחר מכן לוחצים על 'פתיחת מרכז השליטה של PIPELINES' להתקנה, ולוחצים על צינורות עיבוד נתונים בסרגל התפריטים הימני. אם מופיעה שגיאה בטעינה, מרעננים את הכרטיסייה. אתם אמורים לראות דף חדש כזה:

תיאור צינור עיבוד נתונים

צינור עיבוד הנתונים שתפעילו כולל מספר שלבים (לפרטים, יש לעיין בנספח של Codelab זה):

נקודת ביקורת קיימת של מודל מועתקת לקטגוריה.
מודל Tensor2Tensor מאומן באמצעות נתונים שעברו עיבוד מראש.

האימון מתחיל בנקודת הביקורת של המודל הקיים שהועתקה בשלב הראשון, ולאחר מכן מתאמן עוד כמה מאות שלבים. (ייקח יותר מדי זמן כדי לאמן אותו באופן מלא במהלך ה-Codelab).
בסיום האימון, השלב בצינור עיבוד הנתונים מייצא את המודל בפורמט שמתאים להצגה על ידי TensorFlow.

נפרסת מכונה של TensorFlow-serving באמצעות המודל הזה.
מופעלת אפליקציית אינטרנט לצורך אינטראקציה עם המודל המוצג כדי לאחזר חיזויים.

להוריד ולהרכיב את צינור עיבוד הנתונים

בחלק הזה נסביר איך להדר הגדרה של צינור עיבוד נתונים. הדבר הראשון שאנחנו צריכים לעשות הוא להתקין את ה-SDK של KFP. מריצים את הפקודה הבאה ב-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 צינור עיבוד נתונים ובוחרים באפשרות Import by URL (ייבוא לפי כתובת 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), ולוחצים על הבא כדי ליצור אותו.

עכשיו יופיע דף שבו תוכלו להזין את הפרמטרים של 'הפעלה' ולהתחיל את ההרצה.

יכול להיות שתרצו להריץ את הפקודות הבאות ב-Cloud Shell כדי לעזור במילוי הפרמטרים.

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

שם ההפעלה ימולא באופן אוטומטי, אבל תוכלו לתת לו שם אחר אם תרצו.

לאחר מכן ממלאים שלושה שדות פרמטרים:

project
(אופציונלי) github-token
working-dir

מזינים נתיב ל-work-dir בקטגוריה של GCS שיצרתם. הכללת 'gs://' . בשדה github-token מזינים את האסימון שיצרתם קודם לכן, או משאירים את מחרוזת ה-placeholder כפי שהיא אם לא יצרתם אסימון.

אחרי שממלאים את השדות, לוחצים על Start (התחלה) ואז לוחצים על ההפעלה הרשומה כדי לראות את הפרטים שלה. כששלב מסוים של צינור עיבוד נתונים פועל, אפשר ללחוץ עליו כדי לקבל מידע נוסף עליו, כולל צפייה ביומני pod שלו. (אפשר גם לצפות ביומנים של שלב בצינור עיבוד נתונים באמצעות הקישור ליומני Cloud Logging (Stackdriver) שלו, גם אם צומת האשכול הוסר).

צפייה בהגדרה של צינור עיבוד הנתונים

בזמן שצינור עיבוד הנתונים פועל, כדאי לבחון לעומק איך הוא מורכב ומה הוא עושה. מידע נוסף זמין בקטע נספח ב-Codelab.

צפייה במידע לאימון מודלים ב-TensorBoard

אחרי שהשלמתם את שלב האימון, לוחצים על הכרטיסייה Visualizations (המחשה), לוחצים על הלחצן הכחול Start TensorBoard, ואז לוחצים על Open Tensorboard (פתיחת Tensorboard).

להיכרות עם מרכז הבקרה של תוצרי הפיתוח (Artifact) והביצוע

ב-Kubeflow Pipelines מתועדים באופן אוטומטי מטא-נתונים לגבי השלבים בצינור עיבוד הנתונים בזמן ההפעלה של צינור עיבוד הנתונים. פרטי Artifact וביצוע מתועדים. כדי להמשיך בבדיקה, לוחצים על הרשומות האלה בסרגל הניווט הימני של מרכז הבקרה.

עבור Artifacts אפשר להציג גם חלונית סקירה כללית וגם חלונית של Lineage Explorer.

מעלים את אפליקציית האינטרנט שנוצרה על ידי צינור עיבוד הנתונים ומפיקים כמה חיזויים

בשלב האחרון בצינור עיבוד הנתונים פורסים אפליקציית אינטרנט, שמספקת ממשק משתמש לשליחת שאילתות לגבי המודל האימון — שמופעל באמצעות הצגת TF — כדי ליצור תחזיות.

בסיום צינור עיבוד הנתונים, מתחברים לאפליקציית האינטרנט על ידי ניוד העברה אל השירות שלה (אנחנו מבצעים העברה ליציאה אחרת כי ב-Codelab הזה, השירות של אפליקציית האינטרנט לא מוגדר עם נקודת קצה חיצונית).

כדי למצוא את שם השירות, מריצים את הפקודה הבאה ב-Cloud Shell:

kubectl get services

מחפשים שירות בשם הזה: ghsumm-*-webappsvc ברשימה.

לאחר מכן, ב-Cloud Shell, עוברים לשירות הרצוי באופן הבא ומשנים את הפקודה הבאה לשם של ה-webappsvc:

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

לאחר הפעלת ההעברה ליציאה אחרת, לוחצים על 'תצוגה מקדימה' מעל החלונית של Cloud Shell, ובתפריט הנפתח לוחצים על 'Preview on Port 8080'.

אתם אמורים לראות דף כזה בכרטיסייה חדשה:

לוחצים על הלחצן אכלוס בעיה אקראית כדי לאחזר קטע טקסט. לוחצים על Generate TItle (יצירת כותרת) כדי להפעיל את המודל שעבר אימון ולהציג חיזוי.

אם הפרמטרים של צינור עיבוד הנתונים כללו אסימון GitHub חוקי, אפשר לנסות להזין כתובת URL של GitHub בשדה השני וללחוץ על Generate Title. אם לא הגדרתם אסימון GitHub חוקי, צריך להשתמש רק ב'בעיה אקראית' השדה הזה.

4. איך מריצים צינור עיבוד נתונים מ-notebook של AI Platform

אפשר גם להגדיר ולהפעיל באופן אינטראקטיבי את Kubeflow Pipelines מ-notebook של Jupyter באמצעות ה-KFP SDK. התהליך פשוט מאוד בעזרת notebooks של AI Platform, שבו נשתמש ב-Codelab הזה.

יצירת מכונת notebook

ניצור מכונה של notebook מ-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 את הפקודה כדי ליצור את המכונה של ה-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

כשמריצים את הפקודה הזו בפעם הראשונה, יכול להיות שתתבקשו להפעיל את ה-API של notebooks בפרויקט. תשובה 'y' אם כן.

אחרי כמה דקות, שרת ה-notebook יתחיל לפעול. אתם יכולים לראות את המכונות של Notebook ברשימה ב-Cloud Console.

העלאה של ה-notebook של Codelab

אחרי שיוצרים את המכונה של ה-notebook, לוחצים על הקישור הזה כדי להעלות את ה-notebook של Jupyter של ה-Codelab. בוחרים את ה-notebook שבו רוצים להשתמש. מסמך ה-notebook ייפתח באופן אוטומטי.

הפעלת ה-notebook

פועלים לפי ההוראות ב-notebook עד לסוף שיעור ה-Lab. שימו לב שבקטע 'הגדרה' חלק מה-notebook, תצטרכו להזין ערכים משלכם לפני שתריצו את שאר ה-notebook.

(אם אתם משתמשים בפרויקט משלכם, אל תשכחו לחזור ולבצע את החלק 'ניקוי' בשיעור ה-Lab הזה).

5. הסרת המשאבים

אין צורך לעשות זאת אם אתם משתמשים בחשבון Codelab זמני, אבל ייתכן שתרצו להסיר את התקנת Pipelines ואת ה-Notebook שלכם אם אתם משתמשים בפרויקט משלכם.

הסרת אשכול GKE של צינורות עיבוד הנתונים

אפשר למחוק את אשכול צינורות עיבוד הנתונים ממסוף Cloud. (אפשר פשוט למחוק את ההתקנה של צינורות עיבוד הנתונים אם רוצים להשתמש שוב באשכול GKE).

מחיקת המכונה של AI Notebook

אם הפעלת את 'Notebook' ב-Codelab, אפשר למחוק או להפסיק את מכונת ה-notebook ממסוף Cloud.

אופציונלי: מסירים את אסימון GitHub

עוברים אל https://github.com/settings/tokens ומסירים את האסימון שנוצר.

6. נספחים

מבט על הקוד

הגדרת צינור עיבוד הנתונים

צינור עיבוד הנתונים שבו נעשה שימוש ב-Codelab הזה מוגדר כאן.

בואו נראה איך הוא מוגדר, ונראה איך הרכיבים (השלבים) שלו מוגדרים. נדון בחלק מהמרכזים, אבל יש לעיין במסמכי התיעוד לקבלת פרטים נוספים.

השלבים ב-Kubeflow Pipeline מבוססים על קונטיינר. כשמפתחים צינור עיבוד נתונים, אפשר להשתמש ברכיבים מוכנים מראש, עם קובצי אימג' של קונטיינרים שכבר נוצרו, או ליצור רכיבים משלכם. עבור ה-Codelab הזה, פיתחנו משלנו.

ארבעה מהשלבים בצינור עיבוד הנתונים מוגדרים מרכיבים לשימוש חוזר, שהגישה אליהם מתבצעת דרך קובצי ההגדרה של הרכיבים שלהם. בקטע הקוד הראשון הזה אנחנו ניגשים לקובצי הגדרת הרכיבים האלו דרך כתובת ה-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

אפשר גם להגדיר שלב של צינור עיבוד נתונים דרך ה-constructor של dsl.ContainerOp, כפי שמוצג בהמשך.

בהמשך מופיעה כמות גדולה של הגדרות צינור עיבוד הנתונים. אנחנו מגדירים את מקורות הקלט של צינור עיבוד הנתונים (ואת ערכי ברירת המחדל שלהם). לאחר מכן אנחנו מגדירים את השלבים בצינור עיבוד הנתונים. ברוב המקרים נשתמש באופרטור 'ops'. שמוגדר למעלה, אבל אנחנו גם מגדירים 'הגשה' שלב בתוך 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'. אנחנו משיקים את 'אפליקציית האינטרנט לחיזוי', שבה השתמשנו כדי לבקש סיכומי בעיות ממודל 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 מתוארות כמה שיטות מומלצות לבניית רכיבים משלכם. כחלק מהתהליך הזה תצטרכו להגדיר ולפתח קובץ אימג' של קונטיינר. כאן מופיעים השלבים של הרכיבים לצינור עיבוד הנתונים של Codelab. ההגדרות של קובצי Docker נמצאות בספריות המשנה containers, למשל. כאן.

שימוש במכונות וירטואליות זמניות (preemated) עם מעבדי GPU לאימון

מכונות וירטואליות זמניות (preemptible) הן מכונות וירטואליות של Compute Engine שפועלות למשך 24 שעות לכל היותר ואין בהן הבטחה לזמינות. המחיר של מכונות וירטואליות זמניות (preemptible) נמוך יותר מהמחיר של מכונות וירטואליות רגילות של Compute Engine.

באמצעות Google Kubernetes Engine (GKE) קל להגדיר אשכול או מאגר צמתים שמשתמשים במכונות וירטואליות זמניות. אפשר להגדיר מאגר צמתים כזה עם מעבדי GPU שמחוברים למכונות הניתנות להפסקה. הצמתים האלה פועלים כמו צמתים רגילים שתומכים ב-GPU, אבל יחידות ה-GPU תקפות רק במהלך כל חיי המכונה.

כדי להגדיר מאגר צמתים זמני ומותאם ל-GPU לאשכול, מריצים פקודה שדומה לזו, עורכים את הפקודה הבאה בשם ובתחום (zone) של האשכול ומשנים את סוג המאיץ והספירה שלו בהתאם לדרישות שלכם. אפשר להגדיר שמאגר הצמתים ישתנה באופן אוטומטי על סמך עומסי העבודה הנוכחיים.

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.

הגדרת צינור עיבוד נתונים של Kubeflow שמשתמש בצומתי GKE זמניים

אם מריצים את Kubeflow ב-GKE, עכשיו קל להגדיר ולהריץ את Kubeflow Pipelines שבהם שלב אחד או יותר בצינור עיבוד הנתונים (רכיבים) פועל בצמתים שניתנים להפסקה, וכך מפחית את העלות של הרצת משימה. כדי להשתמש במכונות וירטואליות זמניות מראש כדי לספק תוצאות נכונות, השלבים שאתם מזהים כניתנים להפסקה צריכים להיות אידמפוטנטיים (כלומר, אם מריצים שלב כמה פעמים, תהיה את אותה התוצאה). או שנקודת הביקורת (checkpoint) צריכה לפעול מהמקום שבו היא הופסקה אם היא הופסקה.

כשמגדירים צינור עיבוד נתונים של 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 שבו השתמשנו ב-Codelab הזה כדי להריץ את שלב האימון ב-VMpreemptible.

צריך לשנות את השורה הבאה במפרט צינור עיבוד הנתונים כך שישתמשו גם במאגר צמתים זמני (prediction) של מאגרי צמתים (יש לוודא שיצרתם מאגר כזה כפי שצוין למעלה) ולבצע ניסיון חוזר 5 פעמים:

  train.set_gpu_limit(1)

לאחר מכן, צריך להדר מחדש את צינור עיבוד הנתונים, להעלות את הגרסה החדשה (נותנים לו שם חדש) ואז להריץ את הגרסה החדשה של צינור עיבוד הנתונים.