בניית ארכיטקטורות אימון מבוזרות גמישות וניתנות להרחבה באמצעות Kubeflow ב-AWS ו-Amazon SageMaker

בפוסט זה, אנו מדגימים כיצד Kubeflow ב-AWS (הפצה ספציפית ל-AWS של Kubeflow) בשימוש עם מיכלי למידה עמוקה של AWS ו מערכת הקבצים של אמזון אלסטית (Amazon EFS) מפשט את שיתוף הפעולה ומספק גמישות בהכשרת מודלים של למידה עמוקה בקנה מידה בשניהם שירות קוברנט של אמזון (אמזון EKS) ו אמזון SageMaker תוך שימוש בגישת ארכיטקטורה היברידית.

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

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

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

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

פוסט זה מדגים כיצד לקוחות שיש להם הגבלות מקומיות או השקעות קיימות של Kubernetes יכולים להתמודד עם אתגר זה באמצעות Amazon EKS ו-Kubeflow ב-AWS כדי ליישם צינור ML להדרכה מבוזרת המבוססת על גישה בניהול עצמי, ולהשתמש ב-SageMaker המנוהל במלואו עבור תשתית הדרכה מותאמת לעלות, מנוהלת במלואה ובקנה מידה ייצור. זה כולל יישום שלב אחר שלב של ארכיטקטורת אימון מבוזרת היברידית המאפשרת לך לבחור בין שתי הגישות בזמן ריצה, ומעניקה שליטה וגמישות מירבית עם צרכים מחמירים לפריסות שלך. אתה תראה איך אתה יכול להמשיך להשתמש בספריות קוד פתוח בסקריפט האימון ללמידה עמוקה שלך ועדיין להפוך אותו לתואם להפעלה הן על Kubernetes והן על SageMaker בצורה אגנוסטית לפלטפורמה.

איך Kubeflow ב-AWS ו- SageMaker עוזרים?

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

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

עם זאת, יכולים להיות כמה אתגרים עם גישה זו:

• הבטחת ניצול מקסימלי של אשכול בין צוותי מדעי הנתונים. לדוגמה, עליך לספק מופעי GPU על פי דרישה ולהבטיח ניצול גבוה שלו למשימות תובעניות בקנה מידה ייצור כגון אימון למידה עמוקה, ולהשתמש במופעי CPU עבור המשימות הפחות תובעניות כגון עיבוד מקדים של נתונים
• הבטחת זמינות גבוהה של רכיבי תשתית Kubeflow כבדי משקל, כולל מסד נתונים, אחסון ואימות, שנפרסים בצומת העבודה של אשכול Kubernetes. לדוגמה, מישור הבקרה של Kubeflow מייצר חפצים (כגון מופעי MySQL, יומני תרמילים או אחסון MinIO) שגדלים עם הזמן וזקוקים לנפחי אחסון הניתנים לשינוי גודל עם יכולות ניטור רציפות.
• שיתוף מערך ההדרכה, הקוד וסביבות המחשוב בין מפתחים, אשכולות הדרכה ופרויקטים הוא מאתגר. לדוגמה, אם אתה עובד על סט ספריות משלך ולספריות האלה יש תלות הדדית חזקה, זה נהיה ממש קשה לשתף ולהריץ את אותה פיסת קוד בין מדעני נתונים באותו צוות. כמו כן, כל ריצת אימון מחייבת אותך להוריד את מערך ההדרכה ולבנות את תמונת האימון עם שינויי קוד חדשים.

Kubeflow ב-AWS עוזר להתמודד עם אתגרים אלה ומספק מוצר Kubeflow מנוהל למחצה ברמה ארגונית. עם Kubeflow ב-AWS, אתה יכול להחליף חלק משירותי מטוסי הבקרה של Kubeflow כמו מסד נתונים, אחסון, ניטור וניהול משתמשים בשירותים מנוהלים של AWS כמו שירות מסדי נתונים יחסי של אמזון (Amazon RDS), שירות אחסון פשוט של אמזון (אמזון S3), מערכת הקבצים של אמזון אלסטית (EFS של אמזון), אמזון FSx, אמזון CloudWatch, ו אמזון קוגניטו.

החלפת רכיבי Kubeflow אלו מנתקת חלקים קריטיים במישור הבקרה של Kubeflow מ-Kubernetes, ומספקת עיצוב מאובטח, ניתן להרחבה, גמיש ומוטב עלות. גישה זו גם משחררת משאבי אחסון ומחשוב ממישור הנתונים של EKS, אשר עשויים להידרש על ידי יישומים כגון הדרכת מודלים מבוזרים או שרתי מחברת משתמשים. Kubeflow ב-AWS מספקת גם אינטגרציה מקורית של מחברות Jupyter עם תמונות Deep Learning Container (DLC), שארוזות מראש ומוגדרות מראש עם מסגרות למידה עמוקה מותאמות ל-AWS כגון PyTorch ו-TensorFlow המאפשרות לך להתחיל לכתוב את קוד האימון שלך מיד בלי להתעסק. עם החלטות תלות ואופטימיזציות של מסגרת. כמו כן, אינטגרציה של Amazon EFS עם אשכולות הדרכה וסביבת הפיתוח מאפשרת לך לשתף את הקוד ואת מערך ההדרכה המעובד שלך, מה שנמנע מבניית תמונת המיכל וטעינת מערכי נתונים ענקיים לאחר כל שינוי קוד. האינטגרציות הללו עם Kubeflow ב-AWS עוזרות לך להאיץ את זמן בניית המודל וההדרכה ומאפשרות שיתוף פעולה טוב יותר עם שיתוף נתונים וקוד קל יותר.

Kubeflow ב-AWS עוזר לבנות פלטפורמת ML זמינה וחזקה במיוחד. פלטפורמה זו מספקת גמישות לבנות ולהכשיר מודלים של למידה עמוקה ומספקת גישה לערכות כלים רבות בקוד פתוח, תובנות על יומנים וניפוי באגים אינטראקטיבי לצורך ניסויים. עם זאת, השגת ניצול מקסימלי של משאבי תשתית תוך אימון מודלים של למידה עמוקה על מאות GPUs עדיין כרוכה בהרבה תקורה תפעולית. ניתן לטפל בכך על ידי שימוש ב- SageMaker, שהוא שירות מנוהל במלואו שתוכנן ומותאם לטיפול באשכולות הדרכה ביצועיים ומותאמים לעלות המוענקים רק כאשר מתבקשים, מותאמים לפי הצורך, ונסגרים אוטומטית עם סיום העבודות, ובכך מספקים קרוב ל-100 % ניצול משאבים. אתה יכול לשלב את SageMaker עם Kubeflow Pipelines באמצעות רכיבי SageMaker מנוהלים. זה מאפשר לך להפעיל תהליכי עבודה של ML כחלק מצינורות Kubeflow, שבהם תוכל להשתמש ב-Kubernetes להדרכה מקומית וב-SageMaker להדרכה בקנה מידה של מוצר בארכיטקטורה היברידית.

סקירת פתרונות

הארכיטקטורה הבאה מתארת ​​כיצד אנו משתמשים ב-Kubeflow Pipelines כדי לבנות ולפרוס זרימות עבודה ML ניידות ומדרגיות מקצה לקצה כדי להפעיל הדרכה מבוזרת על תנאי על Kubernetes באמצעות אימון Kubeflow או SageMaker בהתבסס על פרמטר זמן הריצה.

אימון Kubeflow הוא קבוצה של מפעילי Kubernetes המוסיפים ל-Kubeflow את התמיכה בהדרכה מבוזרת של מודלים של ML באמצעות מסגרות שונות כמו TensorFlow, PyTorch ואחרות. pytorch-operator הוא יישום Kubeflow של Kubernetes משאב מותאם אישית (PyTorchJob) להפעלת משרות הדרכה מבוזרות של PyTorch ב-Kubernetes.

אנו משתמשים ברכיב PyTorchJob Launcher כחלק מצינור Kubeflow כדי להפעיל אימון מבוזר של PyTorch במהלך שלב הניסויים כאשר אנו זקוקים לגמישות וגישה לכל המשאבים הבסיסיים עבור ניפוי באגים וניתוח אינטראקטיביים.

אנו משתמשים גם ברכיבי SageMaker עבור Kubeflow Pipelines כדי להפעיל את הדרכת המודלים שלנו בקנה מידה ייצור. זה מאפשר לנו לנצל את היתרונות של תכונות SageMaker חזקות כגון שירותים מנוהלים במלואם, עבודות הדרכה מבוזרות עם ניצול מקסימלי של GPU והדרכה חסכונית באמצעות ענן מחשוב אלסטי של אמזון (Amazon EC2) מקרי ספוט.

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

1. השתמש בקובץ המניפסט של Kubeflow כדי ליצור לוח מחוונים של Kubeflow ולגשת למחברות Jupyter מלוח המחוונים המרכזי של Kubeflow.
2. השתמש ב-Kubeflow pipeline SDK כדי ליצור ולהרכיב צינורות של Kubeflow באמצעות קוד Python. הידור Pipeline ממירה את פונקציית Python למשאב זרימת עבודה, שהוא פורמט YAML תואם Argo.
3. השתמש בלקוח Kubeflow Pipelines SDK כדי לקרוא לנקודת הקצה של שירות הצינור כדי להפעיל את הצינור.
4. הצינור מעריך את משתני זמן הריצה המותנים ומחליט בין SageMaker או Kubernetes כסביבת הריצה היעד.
5. השתמש ברכיב Kubeflow PyTorch Launcher כדי להפעיל הדרכה מבוזרת בסביבת Kubernetes המקורית, או השתמש ברכיב SageMaker כדי להגיש את ההדרכה בפלטפורמה המנוהלת של SageMaker.

האיור הבא מציג את רכיבי Kubeflow Pipelines המעורבים בארכיטקטורה המעניקים לנו את הגמישות לבחור בין סביבות מבוזרות של Kubernetes או SageMaker.

השתמש ב-Case Workflow

אנו משתמשים בגישה שלב אחר שלב הבאה כדי להתקין ולהפעיל את מקרה השימוש להדרכה מבוזרת באמצעות Amazon EKS ו- SageMaker באמצעות Kubeflow ב-AWS.

תנאים מוקדמים

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

• An חשבון AWS.
• מכונה עם Docker ו- ממשק שורת הפקודה של AWS (AWS CLI) מותקן.
• לחלופין, אתה יכול להשתמש AWS Cloud9, סביבת פיתוח משולבת מבוססת ענן (IDE) המאפשרת השלמת כל העבודה מדפדפן האינטרנט שלך. להוראות התקנה, עיין ב הגדר את Cloud9 IDE. מסביבת Cloud9 שלך, בחר את סימן הפלוס ופתח מסוף חדש.
• צור תפקיד עם השם sagemakerrole. הוסף מדיניות מנוהלת AmazonSageMakerFullAccess ו AmazonS3FullAccess כדי לתת ל-SageMaker גישה לדלי S3. תפקיד זה משמש את עבודת SageMaker שנשלחה כחלק משלב Kubeflow Pipelines.
• ודא שבחשבון שלך יש מגבלת סוג משאב של SageMaker Training ml.p3.2xlarge גדל ל-2 באמצעות קונסולת מכסות שירות

1. התקן את Amazon EKS ו-Kubeflow ב-AWS

אתה יכול להשתמש במספר גישות שונות כדי לבנות אשכול Kubernetes ולפרוס את Kubeflow. בפוסט זה, אנו מתמקדים בגישה שאנו מאמינים שמביאה פשטות לתהליך. ראשית, אנו יוצרים אשכול EKS, ואז אנו פורסים בו את Kubeflow ב-AWS v1.5. עבור כל אחת מהמשימות הללו, אנו משתמשים בפרויקט קוד פתוח תואם העוקב אחר עקרונות ה- עשה מסגרת. במקום להתקין סט תנאים מוקדמים לכל משימה, אנו בונים קונטיינרים של Docker שיש להם את כל הכלים הדרושים ומבצעים את המשימות מתוך הקונטיינרים.

אנו משתמשים ב-Do Framework בפוסט זה, אשר הופכת את פריסת Kubeflow לאוטומטית עם Amazon EFS כתוסף. לאפשרויות הפריסה הרשמיות של Kubeflow על AWS עבור פריסות ייצור, עיין ב פְּרִיסָה.

הגדר את ספריית העבודה הנוכחית ואת AWS CLI

אנו מגדירים ספריית עבודה כך שנוכל להתייחס אליה כנקודת ההתחלה לשלבים הבאים:

export working_dir=$PWD

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

aws configure --profile=kubeflow
AWS Access Key ID [None]: 
AWS Secret Access Key [None]: 
Default region name [None]: us-west-2
Default output format [None]: json

# (In Cloud9, select “Cancel” and “Permanently disable” when the AWS managed temporary credentials dialog pops up)

export AWS_PROFILE=kubeflow

1.1 צור אשכול EKS

אם כבר יש לך אשכול EKS זמין, תוכל לדלג לסעיף הבא. עבור פוסט זה, אנו משתמשים ב- פרויקט aws-do-eks כדי ליצור את האשכול שלנו.

1. תחילה שכפל את הפרויקט בספריית העבודה שלך

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

2. לאחר מכן בנה והפעל את aws-do-eks מְכוֹלָה:

   ./build.sh
   ./run.sh

   השמיים build.sh script יוצר תמונת קונטיינר של Docker הכוללת את כל הכלים והסקריפטים הדרושים להקצאה ותפעול של אשכולות EKS. ה run.sh script מתחיל קונטיינר באמצעות תמונת Docker שנוצרה ושומר אותו כך שנוכל להשתמש בו כסביבת ניהול ה-EKS שלנו. כדי לראות את הסטטוס שלך aws-do-eks מיכל, אתה יכול לרוץ ./status.sh. אם המיכל נמצא במצב יציאה, אתה יכול להשתמש ב- ./start.sh סקריפט כדי להעלות את המיכל, או כדי להפעיל מחדש את המיכל, אתה יכול להפעיל ./stop.sh אחריו ./run.sh.

3. פתח מעטפת בריצה aws-do-eks מְכוֹלָה:
4. כדי לסקור את תצורת אשכול EKS עבור פריסת KubeFlow שלנו, הפעל את הפקודה הבאה:

   vi ./eks-kubeflow.yaml

   כברירת מחדל, תצורה זו יוצרת אשכול בשם eks-kubeflow ב us-west-2 אזור עם שישה צמתים m5.xlarge. כמו כן, הצפנת נפחי EBS אינה מופעלת כברירת מחדל. אתה יכול להפעיל אותו על ידי הוספה "volumeEncrypted: true" לקבוצת הצמתים והיא תצפין באמצעות מפתח ברירת המחדל. שנה הגדרות תצורות אחרות במידת הצורך.

5. כדי ליצור את האשכול, הפעל את הפקודה הבאה:

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

   תהליך הקצאת האשכולות עשוי להימשך עד 30 דקות.

6. כדי לוודא שהאשכול נוצר בהצלחה, הפעל את הפקודה הבאה:

   kubectl get nodes

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

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

צור נפח EFS עבור עבודת ההדרכה של SageMaker

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

אנו יוצרים אמצעי אחסון EFS ופורסים את מנהל ההתקן של EFS Container Storage Interface (CSI). זה מושג על ידי סקריפט פריסה שנמצא ב /eks/deployment/csi/efs בתוך aws-do-eks מיכל.

סקריפט זה מניח שיש לך אשכול EKS אחד בחשבון שלך. מַעֲרֶכֶת CLUSTER_NAME= במקרה שיש לך יותר מאשכול EKS אחד.

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

סקריפט זה מספק אמצעי אחסון EFS ויוצר יעדי הרכבה עבור רשתות המשנה של ה-VPC של האשכול. לאחר מכן הוא פורס את מנהל ההתקן של EFS CSI ויוצר את efs-sc כיתת אחסון ו efs-pv נפח מתמשך באשכול EKS.

לאחר סיום מוצלח של הסקריפט, אתה אמור לראות פלט כמו הבא:

Generating efs-sc.yaml ...

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

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

Done ...

צור נקודת קצה של Amazon S3 VPC

אתה משתמש ב-VPC פרטי שלעבודת ההדרכה של SageMaker ולמערכת הקבצים של EFS יש גישה אליו. כדי לתת לאשכול ההדרכה של SageMaker גישה לדלי S3 מה-VPC הפרטי שלך, אתה יוצר נקודת קצה VPC:

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

כעת תוכל לצאת מ- aws-do-eks מעטפת מיכל והמשך לסעיף הבא:

exit

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

1.2 פרוס את Kubeflow ב-AWS ב- Amazon EKS

כדי לפרוס את Kubeflow ב- Amazon EKS, אנו משתמשים ב- פרויקט aws-do-kubeflow.

1. שכפל את המאגר באמצעות הפקודות הבאות:

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

2. לאחר מכן הגדר את הפרויקט:

   ./config.sh

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

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

   השמיים build.sh סקריפט יוצר תמונת קונטיינר של Docker הכוללת את כל הכלים הדרושים לפריסה וניהול של Kubeflow באשכול Kubernetes קיים. ה run.sh סקריפט מתחיל קונטיינר, באמצעות תמונת Docker, והסקריפט exec.sh פותח מעטפת פקודה לתוך הקונטיינר, שבה נוכל להשתמש כסביבת ניהול Kubeflow שלנו. אתה יכול להשתמש ב ./status.sh סקריפט כדי לראות אם aws-do-kubeflow המכולה פועלת וה ./stop.sh ו ./run.sh סקריפטים כדי להפעיל אותו מחדש לפי הצורך.

3. אחרי שנפתחת מעטפת ב aws-do-eks מכיל, אתה יכול לוודא שהקשר האשכול שהוגדר הוא כצפוי:

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

4. כדי לפרוס את Kubeflow באשכול EKS, הפעל את deploy.sh תַסרִיט:

   ./kubeflow-deploy.sh

   הפריסה מוצלחת כאשר כל הפודים במרחב השמות של kubeflow נכנסים למצב Running. פלט טיפוסי נראה כמו הקוד הבא:

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

5. כדי לעקוב אחר מצב הפודים של KubeFlow, בחלון נפרד, תוכל להשתמש בפקודה הבאה:

   watch kubectl -n kubeflow get pods

6. חדשות ועדכונים Ctrl + C כאשר כל התרמילים פועלים, לאחר מכן חשוף את לוח המחוונים של Kubeflow מחוץ לאשכול על ידי הפעלת הפקודה הבאה:

   ./kubeflow-expose.sh

אתה אמור לראות פלט שנראה כמו הקוד הבא:

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

פקודה זו מעבירה את שירות שער הכניסה של Istio מהאשכול שלך ליציאה המקומית 8080. כדי לגשת ללוח המחוונים של Kubeflow, בקר בכתובת http://localhost:8080 והיכנס באמצעות ברירת המחדל של אישורי המשתמש (user@example.com/12341234). אם אתה מפעיל את aws-do-kubeflow מיכל ב-AWS Cloud9, אז אתה יכול לבחור תצוגה מקדימה, ואז לבחור תצוגה מקדימה של יישום. אם אתה פועל על Docker Desktop, ייתכן שתצטרך להפעיל את ./kubeflow-expose.sh תסריט מחוץ ל aws-do-kubeflow מיכל.

2. הגדר את סביבת Kubeflow ב-AWS

כדי להגדיר את סביבת Kubeflow ב-AWS, אנו יוצרים אמצעי אחסון EFS ומחברת Jupyter.

2.1 צור אמצעי אחסון EFS

כדי ליצור אמצעי אחסון EFS, בצע את השלבים הבאים:

• בלוח המחוונים של Kubeflow, בחר כרכים בחלונית הניווט.
• בחר כרך חדש.
• בעד שם, להיכנס efs-sc-claim.
• בעד גודל נפח, להיכנס 10.
• בעד שיעור אחסון, בחר efs-sc.
• בעד מצב גישה, בחר ReadWriteOnce.
• בחרו צור.

2.2 צור מחברת Jupyter

כדי ליצור מחברת חדשה, בצע את השלבים הבאים:

• בלוח המחוונים של Kubeflow, בחר מחברה בחלונית הניווט.
• בחרו מחברת חדשה.
• בעד שם, להיכנס aws-hybrid-nb.
• בעד Jupyter Docket Image, בחר את התמונה c9e4w0g3/notebook-servers/jupyter-pytorch:1.11.0-cpu-py38-ubuntu20.04-e3-v1.1 (תמונת ה-DLC העדכנית ביותר של jupyter-pytorch).
• בעד CPU, להיכנס 1.
• בעד זכרון, להיכנס 5.
• בעד GPUs, השאר כמו ללא חתימה.
• אל תבצע שינויים ב- נפח סביבת עבודה סָעִיף.
• ב נפחי נתונים סעיף, בחר צרף נפח קיים ולהרחיב את קטע נפח קיים
• בעד שם, בחר efs-sc-claim.
• בעד שביל הר, להיכנס /home/jovyan/efs-sc-claim.
  זה מעלה את עוצמת הקול של EFS לתרמיל מחברת Jupyter שלך, ותוכל לראות את התיקיה efs-sc-claim בממשק מעבדת Jupyter שלך. אתה שומר את מערך ההדרכה וקוד ההדרכה בתיקייה זו כדי שאשכולות ההדרכה יוכלו לגשת אליו מבלי צורך לבנות מחדש את תמונות המכולה לצורך בדיקה.
• בחר אפשר גישה ל-Kubeflow Pipelines בסעיף תצורה.
• בחרו לשגר.
  ודא שהמחברת שלך נוצרה בהצלחה (זה עשוי לקחת כמה דקות).
• על מחברה עמוד, בחר לְחַבֵּר כדי להיכנס לסביבת JupyterLab.
• על Git בתפריט, בחר שיבוט מאגר.
• בעד שיבוט ריפו, להיכנס https://github.com/aws-samples/aws-do-kubeflow.
  

3. הפעל אימון מבוזר

לאחר הגדרת מחברת Jupyter, תוכל להריץ את כל ההדגמה באמצעות השלבים הבאים ברמה הגבוהה מהתיקיה aws-do-kubeflow/workshop במאגר המשובט:

• PyTorch Distributed Data Parallel (DDP) סקריפט אימון: עיין בסקריפט אימון PyTorch DDP cifar10-distributed-gpu-final.py, הכולל דוגמה של רשת עצבית קונבולוציונית והיגיון להפצת הדרכה על מעבד ו-GPU מרובה-צמתים. (ראה 3.1 לפרטים)
• התקן ספריות: הפעל את המחברת 0_initialize_dependencies.ipynb לאתחל את כל התלות. (ראה 3.2 לפרטים)
• הפעל הדרכת עבודה מבוזרת של PyTorch ב-Kubernetes: הפעל את המחברת 1_submit_pytorchdist_k8s.ipynb ליצור ולשלוח הדרכה מבוזרת על קונטיינרים ראשיים אחד ושני עובדים באמצעות המשאב המותאם אישית של Kubernetes PyTorchJob YAML באמצעות קוד Python. (ראה 3.3 לפרטים)
• צור צינור Kubeflow היברידי: הפעל את המחברת 2_create_pipeline_k8s_sagemaker.ipynb ליצור את צינור Kubeflow ההיברידי שמפעיל אימון מבוזר ב- SageMaker או Amazon EKS באמצעות משתנה זמן הריצה training_runtime. (ראה 3.4 לפרטים)

ודא שהרצת את המחברת 1_submit_pytorchdist_k8s.ipynb לפני שתתחיל את המחברת 2_create_pipeline_k8s_sagemaker.ipynb.

בסעיפים הבאים, נדון בכל אחד מהשלבים הללו בפירוט.

3.1 PyTorch Distributed Data Parallel (DDP) סקריפט אימון

כחלק מההדרכה המבוזרת, אנו מאמנים מודל סיווג שנוצר על ידי רשת עצבית קונבולוציונית פשוטה הפועלת על מערך הנתונים CIFAR10. תסריט האימון cifar10-distributed-gpu-final.py מכיל רק את ספריות הקוד הפתוח ותואם להפעלה הן באשכולות הדרכה של Kubernetes והן של SageMaker על התקני GPU או מופעי CPU. בואו נסתכל על כמה היבטים חשובים של תסריט ההדרכה לפני שנפעיל את דוגמאות המחברת שלנו.

אנו משתמשים torch.distributed מודול, המכיל תמיכה ב- PyTorch ופרימיטיבים לתקשורת עבור מקביליות מרובת תהליכים על פני צמתים באשכול:

...
import torch
import torch.distributed as dist
import torch.nn as nn
import torch.nn.functional as F
import torch.optim as optim
import torch.utils.data
import torch.utils.data.distributed
import torchvision
from torchvision import datasets, transforms
...

אנו יוצרים מודל סיווג תמונה פשוט תוך שימוש בשילוב של שכבות קונבולוציוניות, איסוף מקסימלי וליניאריות שעליהן מיושמת פונקציית הפעלת relu במעבר קדימה של אימון המודל:

# Define models
class Net(nn.Module):
def __init__(self):
super(Net, self).__init__()
self.conv1 = nn.Conv2d(3, 6, 5)
self.pool = nn.MaxPool2d(2, 2)
self.conv2 = nn.Conv2d(6, 16, 5)
self.fc1 = nn.Linear(16 * 5 * 5, 120)
self.fc2 = nn.Linear(120, 84)
self.fc3 = nn.Linear(84, 10)

def forward(self, x):
x = self.pool(F.relu(self.conv1(x)))
x = self.pool(F.relu(self.conv2(x)))
x = x.view(-1, 16 * 5 * 5)
x = F.relu(self.fc1(x))
x = F.relu(self.fc2(x))
x = self.fc3(x)
return x

אנו משתמשים ב- Torch DataLoader המשלב את מערך הנתונים ו DistributedSampler (טוען תת-קבוצה של נתונים בצורה מבוזרת באמצעות torch.nn.parallel.DistributedDataParallel) ומספק איטרטור של תהליך יחיד או ריבוי תהליכים על הנתונים:

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

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

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

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

אם לאשכול האימון יש GPUs, הסקריפט מריץ את האימון במכשירי CUDA ומשתנה ההתקן מכיל את מכשיר ברירת המחדל של CUDA:

device = "cuda" if torch.cuda.is_available() else "cpu"
...

לפני שאתה מפעיל אימון מבוזר באמצעות PyTorch DistributedDataParallel כדי להפעיל עיבוד מבוזר על מספר צמתים, עליך לאתחל את הסביבה המבוזרת על ידי קריאה init_process_group. זה מאותחל בכל מכונה של אשכול האימונים.

dist.init_process_group(backend=args.backend, rank=host_rank, world_size=world_size)
...

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

model = Net().to(device)

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

...

3.2 התקנת ספריות

תתקין את כל הספריות הדרושות כדי להפעיל את דוגמה ההדרכה המבוזרת של PyTorch. זה כולל Kubeflow Pipelines SDK, Training Operator Python SDK, Python client for Kubernetes ו- Amazon SageMaker Python SDK.

#Please run the below commands to install necessary libraries

!pip install kfp==1.8.4

!pip install kubeflow-training

!pip install kubernetes

!pip install sagemaker

3.3 הפעל הדרכת עבודה מבוזרת של PyTorch ב-Kubernetes

המחברת 1_submit_pytorchdist_k8s.ipynb יוצר את המשאב המותאם אישית של Kubernetes PyTorchJob YAML באמצעות אימון Kubeflow ו-Kubernetes הלקוח Python SDK. להלן מספר קטעים חשובים ממחברת זו.

אנו יוצרים את PyTorchJob YAML עם המיכלים הראשיים והעובדים כפי שמוצג בקוד הבא:

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

זה מוגש למטוס הבקרה של Kubernetes באמצעות PyTorchJobClient:

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

pytorch_job_manifest=pytorchjob_client.create(pytorchjob):

הצג את יומני ההדרכה של Kubernetes

אתה יכול להציג את יומני ההדרכה מאותו מחברת Jupyter באמצעות קוד Python או ממעטפת הלקוח של Kubernetes.

3.4 צור צינור Kubeflow היברידי

המחברת 2_create_pipeline_k8s_sagemaker.ipynb יוצר צינור Kubeflow היברידי המבוסס על משתנה זמן ריצה מותנה training_runtime, כפי שמוצג בקוד הבא. המחברת משתמשת ב- קו צינורות צינורות קובלה והוא מסופק קבוצה של חבילות Python כדי לציין ולהפעיל את צינורות זרימת העבודה של ML. כחלק מ-SDK זה, אנו משתמשים בחבילות הבאות:

• מעצב החבילות לשפה ספציפית לתחום (DSL). dsl.pipeline, אשר מקשט את פונקציות Python כדי להחזיר צינור
• השמיים dsl.Condition חבילה, המייצגת קבוצת פעולות המופעלות רק כאשר מתקיים תנאי מסוים, כגון בדיקת ה training_runtime ערך כ sagemaker or kubernetes

ראה את הקוד הבא:

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

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

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

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

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

אנו מגדירים אימון מבוזר של SageMaker באמצעות שני מופעים של ml.p3.2xlarge.

לאחר הגדרת הצינור, תוכל להרכיב את הצינור למפרט Argo YAML באמצעות ה-SDK של Kubeflow Pipelines kfp.compiler חֲבִילָה. אתה יכול להפעיל את הצינור הזה באמצעות לקוח Kubeflow Pipeline SDK, הקורא לנקודת הקצה של שירות Pipelines ומעביר כותרות אימות מתאימות ישירות מהמחברת. ראה את הקוד הבא:

# DSL Compiler that compiles pipeline functions into workflow yaml.
kfp.compiler.Compiler().compile(pytorch_cnn_pipeline, "pytorch_cnn_pipeline.yaml")

# Connect to Kubeflow Pipelines using the Kubeflow Pipelines SDK client
client = kfp.Client()

experiment = client.create_experiment(name="kubeflow")

# Run a specified pipeline
my_run = client.run_pipeline(experiment.id, "pytorch_cnn_pipeline", "pytorch_cnn_pipeline.yaml")

# Please click “Run details” link generated below this cell to view your pipeline. You can click every pipeline step to see logs.

אם אתה מקבל sagemaker import שגיאה, הפעל את !pip install sagemaker והפעל מחדש את הליבה (ב- גַרעִין בתפריט, בחר הפעל מחדש את הקרנל).

בחר את הרץ פרטים קישור מתחת לתא האחרון כדי להציג את הצינור של Kubeflow.

חזור על שלב יצירת הצינור עם training_runtime='kubernetes' כדי לבדוק את הפעלת הצינור בסביבת Kubernetes. ה training_runtime ניתן להעביר משתנה גם בצינור ה-CI/CD שלך בתרחיש ייצור.

הצג את יומני ריצת הצינור של Kubeflow עבור רכיב SageMaker

צילום המסך הבא מציג את פרטי הצינור שלנו עבור רכיב SageMaker.

בחר את שלב עבודת ההדרכה ועל יומנים בכרטיסייה, בחר בקישור יומני CloudWatch כדי לגשת ליומני SageMaker.

צילום המסך הבא מציג את יומני CloudWatch עבור כל אחד משני המופעים ml.p3.2xlarge.

בחר כל אחת מהקבוצות כדי לראות את היומנים.

הצג את יומני ריצת הצינור של Kubeflow עבור רכיב Kubeflow PyTorchJob Launcher

צילום המסך הבא מציג את פרטי הצינור עבור רכיב Kubeflow שלנו.

הפעל את הפקודות הבאות באמצעות Kubectl במעטפת הלקוח של Kubernetes המחוברת לאשכול Kubernetes כדי לראות את היומנים (החלף את מרחב השמות ואת שמות הפוד שלך):

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

4.1 לנקות

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

1. מחק את התקנת Kubeflow על ידי הפעלה ./kubeflow-remove.sh ב aws-do-kubeflow מְכוֹלָה. קבוצת הפקודות הראשונה הן אופציונליות וניתן להשתמש בהן למקרה שעדיין אין לך מעטפת פקודה aws-do-kubeflow מיכל פתוח.

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

2. מ aws-do-eks תיקיית container, הסר את אמצעי האחסון של EFS. קבוצת הפקודות הראשונה היא אופציונלית וניתן להשתמש בה למקרה שעדיין אין לך מעטפת פקודה aws-do-eks מיכל פתוח.

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

   מחיקת Amazon EFS נחוצה על מנת לשחרר את ממשק הרשת המשויך ל-VPC שיצרנו עבור האשכול שלנו. שים לב שמחיקת אמצעי האחסון של EFS הורסת כל נתונים המאוחסנים בו.

3. מ aws-do-eks מיכל, הפעל את eks-delete.sh סקריפט למחיקת האשכול וכל משאב אחר המשויך אליו, כולל ה-VPC:

   cd /eks
   ./eks-delete.sh

<br> סיכום

בפוסט זה, דנו בכמה מהאתגרים האופייניים של אימון מודלים מבוזרים וזרימות עבודה של ML. סיפקנו סקירה כללית של Kubeflow על הפצת AWS ושיתפנו שני פרויקטים בקוד פתוח (aws-do-eks ו aws-do-kubeflow) שמפשטות את הקצאת התשתית ואת הפריסה של Kubeflow עליה. לבסוף, תיארנו והדגמנו ארכיטקטורה היברידית המאפשרת לעומסי עבודה לעבור בצורה חלקה בין ריצה על גבי תשתית Kubernetes בניהול עצמי לבין תשתית SageMaker המנוהלת במלואה. אנו ממליצים לך להשתמש בארכיטקטורה ההיברידית הזו למקרי השימוש שלך.

אתה יכול לעקוב אחר מאגר AWS Labs כדי לעקוב אחר כל התרומות של AWS ל-Kubeflow. אתה יכול למצוא אותנו גם ב ערוץ Slack של Kubeflow #AWS; המשוב שלך שם יעזור לנו לתעדף את התכונות הבאות לתרום לפרויקט Kubeflow.

תודה מיוחדת ל-Sree Arasanagatta (מנהל פיתוח תוכנה AWS ML) ו-Suraj Kota (מהנדס תוכנה) על תמיכתם בהשקת הפוסט הזה.

על המחברים

Kanwaljit Khurmi הוא אדריכל פתרונות AI/ML מומחה בשירותי האינטרנט של אמזון. הוא עובד עם המוצר, ההנדסה והלקוחות של AWS כדי לספק הדרכה וסיוע טכני המסייעים להם לשפר את הערך של פתרונות ה-ML ההיברידיים שלהם בעת שימוש ב-AWS. Kanwaljit מתמחה בסיוע ללקוחות עם יישומי מכולות ולמידת מכונה.

גוטם קומאר הוא מהנדס תוכנה עם AWS AI Deep Learning. הוא פיתח את AWS Deep Learning Containers ו-AWS Deep Learning AMI. הוא נלהב מבניית כלים ומערכות עבור AI. בזמנו הפנוי הוא נהנה לרכוב על אופניים ולקרוא ספרים.

אלכס יאנקולסקי הוא ארכיטקט תוכנה ותשתית מלא שאוהב לעשות עבודה מעשית ומעמיקה. כיום הוא אדריכל פתרונות ראשי ללמידת מכונה בניהול עצמי ב-AWS. בתפקידו הוא מתמקד בסיוע ללקוחות עם קונטיינריזציה ותזמור של עומסי עבודה של ML ו-AI בשירותי AWS המונעים על ידי קונטיינרים. הוא גם המחבר של הקוד הפתוח תעשה מסגרת וקברניט דוקר שאוהב ליישם טכנולוגיות מכולות כדי להאיץ את קצב החדשנות תוך פתרון האתגרים הגדולים בעולם. במהלך 10 השנים האחרונות, אלכס עבד על מאבק בשינויי האקלים, דמוקרטיזציה של AI ו-ML, הפיכת נסיעות לבטוחות יותר, שירותי בריאות טובים יותר ואנרגיה חכמה יותר.