יצירת משימת אימון בלי שרת (serverless)

משימות הדרכה ללא שרת (CustomJob משאבים ב-Agent Platform API) הן הדרך הבסיסית להריץ את קוד ההדרכה המותאם אישית שלכם ללמידת מכונה (ML) ב-Gemini Enterprise Agent Platform.

לפני ששולחים משימה

לפני שיוצרים CustomJob ב-Agent Platform, צריך ליצור אפליקציית אימון של Python או קובץ אימג' של קונטיינר מותאם אישית כדי להגדיר את קוד האימון ואת התלות שרוצים להפעיל ב-Agent Platform.

מומלץ להשתמש בתכונה autopackaging של Google Cloud CLI, שמתוארת בקטע בהמשך המדריך הזה, כדי ליצור קובץ אימג' של קונטיינר Docker מקוד במחשב המקומי, להעביר את קובץ האימג' הזה של הקונטיינר אל Artifact Registry וליצור CustomJob, והכול באמצעות פקודה אחת.

אחרת, צריך ליצור באופן ידני אפליקציה לאימון ב-Python או קובץ אימג' של קונטיינר בהתאמה אישית.

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

מה כלול בעבודה בהתאמה אישית

כשיוצרים משימה בהתאמה אישית, מציינים הגדרות ש-Agent Platform צריכה כדי להריץ את קוד ההדרכה, כולל:

• מאגר worker אחד לאימון של צומת יחיד (WorkerPoolSpec), או כמה מאגרי worker לאימון מבוזר
• הגדרות אופציונליות להגדרת תזמון של עבודות (Scheduling), הגדרת משתני סביבה מסוימים לקוד האימון, שימוש בחשבון שירות בהתאמה אישית ושימוש ב-VPC Network Peering

במאגרי העובדים אפשר לציין את ההגדרות הבאות:

• סוגי מכונות ומאיצים
• הגדרה של סוג קוד ההדרכה שמאגר העובדים מריץ: אפליקציית הדרכה של Python‏ (PythonPackageSpec) או קונטיינר בהתאמה אישית (ContainerSpec)

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

הגדרת אימון מבוזר

אפשר להגדיר CustomJob לאימון מבוזר על ידי ציון של כמה מאגרי עובדים.

רוב הדוגמאות בדף הזה מציגות משימות אימון עם עותק יחיד של נתונים ומאגר worker אחד. כדי לשנות אותן לאימון מבוזר:

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

מידע נוסף על שימוש באימון מבוזר

יצירת CustomJob

כדי ליצור CustomJob, פועלים לפי ההוראות באחת מהכרטיסיות הבאות, בהתאם לכלי שבו רוצים להשתמש. אם משתמשים ב-CLI של gcloud, אפשר להשתמש בפקודה אחת כדי לארוז אוטומטית את קוד האימון במכונה המקומית בקובץ אימג' של קונטיינר של Docker, להעביר את קובץ האימג' של הקונטיינר אל Artifact Registry וליצור CustomJob. באפשרויות אחרות מניחים שכבר יצרתם אפליקציית אימון ב-Python או קובץ אימג' של קונטיינר בהתאמה אישית.

gcloud

בדוגמאות הבאות משתמשים בפקודה gcloud ai custom-jobs create.

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

עם אריזה אוטומטית

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

• יצירת קובץ אימג' של Docker בהתאמה אישית על סמך הקוד.
• מעבירים את האימג' ל-Artifact Registry.
• ליצור CustomJob על סמך התמונה.

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

לפני שמתחילים

מכיוון שהגרסה הזו של הפקודה יוצרת קובץ אימג' של Docker ומעבירה אותו, צריך לבצע את ההגדרה הבאה במחשב המקומי:

1. מתקינים את Docker Engine.

2. אם אתם משתמשים ב-Linux, צריך להגדיר את Docker כך שאפשר יהיה להריץ אותו בלי sudo.

3. מפעילים את Artifact Registry API.

   תפקידים שנדרשים להפעלת ממשקי API

   כדי להפעיל ממשקי API, נדרשת ההרשאה serviceusage.services.enable. אם יצרתם את הפרויקט, סביר להניח שכבר יש לכם את ההרשאה הזו דרך התפקיד 'בעלים' (roles/owner). אחרת, תוכלו לקבל את ההרשאה הזו דרך התפקיד 'אדמין בממשק 'שימוש בשירות'' (roles/serviceusage.serviceUsageAdmin). איך מקצים תפקידים

   להפעלת ה-API

4. מגדירים אימות ל-Docker כדי שתוכלו להעביר קובצי אימג' של Docker ל-Artifact Registry:

   gcloud auth configure-docker
   

יוצרים קובץ אימג' של Docker ומעבירים אותו בדחיפה, ויוצרים CustomJob

הפקודה הבאה יוצרת קובץ אימג' של Docker על סמך קובץ אימג' של קונטיינר לאימון שנוצר מראש וקוד Python מקומי, מעבירה את קובץ האימג' אל Artifact Registry ויוצרת CustomJob.

gcloud ai custom-jobs create \
  --region=LOCATION \
  --display-name=JOB_NAME \
  --worker-pool-spec=machine-type=MACHINE_TYPE,replica-count=REPLICA_COUNT,executor-image-uri=EXECUTOR_IMAGE_URI,local-package-path=WORKING_DIRECTORY,script=SCRIPT_PATH

מחליפים את מה שכתוב בשדות הבאים:

• ‫LOCATION: האזור שבו יופעלו הקונטיינר או חבילת Python.

• ‫JOB_NAME: שדה חובה. שם מוצג לCustomJob.

• ‫MACHINE_TYPE: סוג המכונה. אפשר לעיין בסוגי המכונות שזמינים לאימון.

• ‫REPLICA_COUNT: מספר העותקים של העובדים לשימוש. ברוב המקרים, צריך להגדיר את הערך הזה ל-1 עבור מאגר העובדים הראשון.

• ‫EXECUTOR_IMAGE_URI: ה-URI של קובץ אימג' של קונטיינר שמריץ את הקוד שסופק. אפשר לעיין במאגרי התגים המוכנים מראש שזמינים לאימון.

  קובץ האימג' הזה משמש כקובץ האימג' הבסיסי לקובץ האימג' החדש של Docker שאתם יוצרים באמצעות הפקודה הזו.

• ‫WORKING_DIRECTORY: ספרייה במערכת הקבצים המקומית שמכילה את סקריפט נקודת הכניסה שמריץ את קוד האימון (ראו את פריט הרשימה הבא).

  אפשר להשתמש בספריית האב של הסקריפט או בספרייה ברמה גבוהה יותר. יכול להיות שתרצו להשתמש בספרייה ברמה גבוהה יותר כדי לציין שם מודול Python מוגדר במלואו (ראו את הפריט הבא ברשימה). אפשר גם להשתמש בספרייה ברמה גבוהה יותר אם היא מכילה קובץ requirements.txt או setup.py. מידע נוסף זמין במאמר Install dependencies.

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

• ‫SCRIPT_PATH: הנתיב, ביחס ל-WORKING_DIRECTORY במערכת הקבצים המקומית, לסקריפט שמשמש כנקודת הכניסה לקוד האימון. זה יכול להיות סקריפט Python (שמסתיים ב-.py) או סקריפט Bash.

  לדוגמה, אם רוצים להריץ את /hello-world/trainer/task.py והערך של WORKING_DIRECTORY הוא /hello-world, צריך להשתמש ב-trainer/task.py בשביל הערך הזה.

  במקום script, צריך להשתמש ב-python-module

  אפשר להחליף את script=SCRIPT_PATH ב-python-module=PYTHON_MODULE כדי לציין את השם של מודול Python ב-WORKING_DIRECTORY שיפעל כנקודת הכניסה לאימון. לדוגמה, במקום script=trainer/task.py, אפשר לציין python-module=trainer.task.

  במקרה כזה, קובץ ה-Docker שנוצר טוען את הקוד שלכם כמודול ולא כסקריפט. כדאי להשתמש באפשרות הזו אם סקריפט נקודת הכניסה מייבא מודולים אחרים של Python ב-WORKING_DIRECTORY.

התקנת יחסי תלות

כשמשתמשים באריזה אוטומטית, אפשר להתקין תלות של Python בקונטיינר באותן דרכים שזמינות כשמשתמשים בפקודה local-run של gcloud CLI. בקטע Install dependencies במדריך לפקודה local-run מוסבר על הדרכים השונות להתקנת יחסי תלות של Python.

התחביר לציון תלות שונה מעט כשמשתמשים באריזה אוטומטית לעומת שימוש בפקודה local-run. במקום להשתמש בדגלים של שורת הפקודה כדי לציין יחסי תלות, צריך להשתמש באפשרויות בערך של הדגל --worker-pool-spec. בנוסף, הערכים בתוך האפשרויות האלה צריכים להיות מופרדים באמצעות נקודה ופסיק ולא באמצעות פסיק. באופן ספציפי, התחביר:

• במקום הדגל --local-package-path של הפקודה local-run, משתמשים באפשרות local-package-path בערך של הדגל --worker-pool-spec. אם ספריית העבודה שצוינה באפשרות הזו מכילה קובץ requirements.txt או setup.py, התהליך של יצירת חבילה אוטומטית מתקין את התלות על סמך הקובץ הזה.

  הדוגמה שלמעלה ממחישה את התחביר הזה.

• (אופציונלי) במקום בדגל --requirements, משתמשים באפשרות requirements בערך של הדגל --worker-pool-spec. במקום להפריד בין יחסי תלות ב-PyPI באמצעות פסיקים, צריך להשתמש בנקודה-פסיק.

• (אופציונלי) במקום בדגל --extra-packages, משתמשים באפשרות extra-packages בערך של הדגל --worker-pool-spec. במקום להפריד בין תלות מקומית באמצעות פסיקים, צריך להשתמש בנקודה-פסיק.

• (אופציונלי) במקום בדגל --extra-dirs, משתמשים באפשרות extra-dirs בערך של הדגל --worker-pool-spec. במקום להפריד בין נתיבי ספריות באמצעות פסיקים, צריך להשתמש בנקודה-פסיק.

בדוגמה הבאה אפשר לראות איך מתקינים תלות באמצעות כל הטכניקות האופציונליות. (אפשר לציין כל תת-קבוצה שלהם). כדי להדגים את התחביר של הנקודה-פסיק, בדוגמה מוגדרים שני ערכים לכל אפשרות. כדי לקצר את הדוגמה, האפשרויות האחרות של --worker-pool-spec מוחלפות ב-[...].

gcloud ai custom-jobs create \
  --region=LOCATION \
  --display-name=JOB_NAME \
  --worker-pool-spec=[...],requirements=PYPI_DEP_1;PYPI_DEP_2,extra-packages=LOCAL_DEP_1;LOCAL_DEP_2,extra-dirs=EXTRA_DIR_1;EXTRA_DIR_2

כדי לקבל מידע על ערכים מתאימים למחזיקי המקום האלה, אפשר לעיין בקטע 'התקנת תלות' במדריך לפקודה local-run.

ללא אריזה אוטומטית

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

אפליקציית אימון ב-Python

gcloud ai custom-jobs create \
  --region=LOCATION \
  --display-name=JOB_NAME \
  --python-package-uris=PYTHON_PACKAGE_URIS \
  --worker-pool-spec=machine-type=MACHINE_TYPE,replica-count=REPLICA_COUNT,executor-image-uri=EXECUTOR_IMAGE_URI,python-module=PYTHON_MODULE

מחליפים את מה שכתוב בשדות הבאים:

• ‫LOCATION: האזור שבו יופעלו הקונטיינר או חבילת Python.
• ‫JOB_NAME: שדה חובה. שם מוצג לCustomJob.
• ‫PYTHON_PACKAGE_URIS: רשימה מופרדת בפסיקים של URI של Cloud Storage שמציינים את קובצי חבילת Python שהם תוכנית האימון והחבילות התלויות שלה. המספר המקסימלי של כתובות URI של חבילות הוא 100.
• ‫MACHINE_TYPE: סוג המכונה. אפשר לעיין בסוגי המכונות שזמינים לאימון.
• ‫REPLICA_COUNT: מספר העותקים של העובדים לשימוש. ברוב המקרים, צריך להגדיר את הערך הזה ל-1 עבור מאגר העובדים הראשון.
• ‫EXECUTOR_IMAGE_URI: ה-URI של קובץ אימג' של קונטיינר שמריץ את הקוד שסופק. אפשר לעיין במאגרי התגים המוכנים מראש שזמינים לאימון.
• ‫PYTHON_MODULE: השם של מודול Python להפעלה אחרי התקנת החבילות.

קובץ אימג' מותאם אישית של קונטיינר

gcloud ai custom-jobs create \
  --region=LOCATION \
  --display-name=JOB_NAME \
  --worker-pool-spec=machine-type=MACHINE_TYPE,replica-count=REPLICA_COUNT,container-image-uri=CUSTOM_CONTAINER_IMAGE_URI

מחליפים את מה שכתוב בשדות הבאים:

• ‫LOCATION: האזור שבו יופעלו הקונטיינר או חבילת Python.
• ‫JOB_NAME: שדה חובה. שם מוצג לCustomJob.
• ‫MACHINE_TYPE: סוג המכונה. אפשר לעיין בסוגי המכונות שזמינים לאימון.
• ‫REPLICA_COUNT: מספר העותקים של העובדים לשימוש. ברוב המקרים, צריך להגדיר את הערך הזה ל-1 עבור מאגר העובדים הראשון.
• ‫CUSTOM_CONTAINER_IMAGE_URI: ה-URI של קובץ אימג' של קונטיינר ב-Artifact Registry או ב-Docker Hub, שיופעל בכל עותק משוכפל של העובד.

אימון מבוזר

כדי לבצע אימון מבוזר, מגדירים את העבודה עם כמה רפליקות. לדוגמה, כשמשתמשים ב-Google Cloud CLI, אפשר לציין את הדגל --worker-pool-spec כמה פעמים.

אם אתם משתמשים באריזה אוטומטית, אתם צריכים לציין רק את local-package-path, script ואפשרויות אחרות שקשורות לאריזה אוטומטית במאגר העובדים הראשון. משמיטים את השדות שקשורים לקוד האימון במאגרי העובדים הבאים, שכולם ישתמשו באותו קונטיינר אימון שנבנה על ידי אריזה אוטומטית.

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

gcloud ai custom-jobs create \
  --region=LOCATION \
  --display-name=JOB_NAME \
  --worker-pool-spec=machine-type=MACHINE_TYPE,replica-count=REPLICA_COUNT,executor-image-uri=EXECUTOR_IMAGE_URI,local-package-path=WORKING_DIRECTORY,script=SCRIPT_PATH \
  --worker-pool-spec=machine-type=SECOND_POOL_MACHINE_TYPE,replica-count=SECOND_POOL_REPLICA_COUNT

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

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

אפליקציית אימון ב-Python

gcloud ai custom-jobs create \
  --region=LOCATION \
  --display-name=JOB_NAME \
  --python-package-uris=PYTHON_PACKAGE_URIS \
  --worker-pool-spec=machine-type=MACHINE_TYPE,replica-count=REPLICA_COUNT,executor-image-uri=EXECUTOR_IMAGE_URI,python-module=PYTHON_MODULE \
  --worker-pool-spec=machine-type=SECOND_POOL_MACHINE_TYPE,replica-count=SECOND_POOL_REPLICA_COUNT,executor-image-uri=SECOND_POOL_EXECUTOR_IMAGE_URI,python-module=SECOND_POOL_PYTHON_MODULE

הערה: במקרה הזה, כל מאגר העובדים משתמש באותם מזהי URI של חבילות Python.

קובץ אימג' מותאם אישית של קונטיינר

gcloud ai custom-jobs create \
  --region=LOCATION \
  --display-name=JOB_NAME \
  --worker-pool-spec=machine-type=MACHINE_TYPE,replica-count=REPLICA_COUNT,container-image-uri=CUSTOM_CONTAINER_IMAGE_URI \
  --worker-pool-spec=machine-type=SECOND_POOL_MACHINE_TYPE,replica-count=SECOND_POOL_REPLICA_COUNT,container-image-uri=SECOND_POOL_CUSTOM_CONTAINER_IMAGE_URI

הגדרה מתקדמת

אם רוצים לציין אפשרויות הגדרה שלא זמינות בדוגמאות הקודמות, אפשר להשתמש בדגל --config כדי לציין את הנתיב לקובץ config.yaml בסביבה המקומית שמכיל את השדות של CustomJobSpec. לדוגמה:

gcloud ai custom-jobs create \
  --region=LOCATION \
  --display-name=JOB_NAME \
  --config=config.yaml

דוגמה לconfig.yaml קובץ

המסוף

במסוף Google Cloud , אי אפשר ליצור משאב CustomJob ישירות. עם זאת, אפשר ליצור משאב TrainingPipeline שיוצר CustomJob.

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

1. במסוף Google Cloud , בקטע Agent Platform, עוברים לדף Training pipelines.

   מעבר אל Training pipelines

2. לוחצים על יצירה כדי לפתוח את החלונית אימון מודל חדש.

3. בשלב שיטת האימון, מציינים את ההגדרות הבאות:

   1. ברשימה הנפתחת Dataset (קבוצת נתונים), בוחרים באפשרות No managed dataset (אין קבוצת נתונים מנוהלת).

   2. בוחרים באפשרות אימון מותאם אישית (מתקדם).

   לוחצים על Continue.

4. בשלב פרטי המודל, בוחרים באפשרות אימון מודל חדש או אימון גרסה חדשה. אם בוחרים באפשרות 'אימון מודל חדש', מזינים שם לבחירה, MODEL_NAME, למודל. לוחצים על המשך.

5. בשלב Training container (מאגר תגים לאימון), מציינים את ההגדרות הבאות:

   1. בוחרים אם להשתמש במאגר תגים מוכן מראש או במאגר תגים בהתאמה אישית להדרכה.

   2. בהתאם לבחירה, מבצעים אחת מהפעולות הבאות:

      • אם רוצים להשתמש בקונטיינר מוכן מראש לאימון, צריך לספק ל-Agent Platform את המידע הדרוש כדי להשתמש בחבילת האימון שהעליתם ל-Cloud Storage:

        1. משתמשים בתפריטים הנפתחים Model framework (מסגרת מודל) ו-Model framework version (גרסת מסגרת המודל) כדי לציין את מאגר התגים המובנה שבו רוצים להשתמש.

        2. בשדה Package location (מיקום החבילה), מציינים את ה-URI של Cloud Storage של אפליקציית האימון של Python שיצרתם והעליתם. הקובץ הזה בדרך כלל מסתיים ב-.tar.gz.

        3. בשדה Python module [מודול Python], מזינים את שם המודול של נקודת הכניסה של אפליקציית האימון.

      • אם רוצים להשתמש בקונטיינר בהתאמה אישית לאימון, בשדה Container image מציינים את ה-URI של קובץ האימג' של הקונטיינר ב-Artifact Registry או ב-Docker Hub.

   3. בשדה Model output directory (ספריית פלט של המודל), אפשר לציין את ה-URI של Cloud Storage של ספרייה בקטגוריה שיש לכם גישה אליה. הספרייה לא צריכה להתקיים עדיין.

      הערך הזה מועבר ל-Agent Platform בשדה baseOutputDirectory API, שמגדיר כמה משתני סביבה שהאפליקציה להדרכה יכולה לגשת אליהם כשהיא פועלת.

   4. אופציונלי: בשדה Arguments (ארגומנטים), אפשר לציין ארגומנטים לשימוש ב-Agent Platform כשהיא מתחילה להריץ את קוד האימון. האורך המקסימלי של כל הארגומנטים ביחד הוא 100,000 תווים. ההתנהגות של הארגומנטים האלה שונה בהתאם לסוג מאגר התגים שבו אתם משתמשים:

      • אם אתם משתמשים במאגר מוכן מראש, Agent Platform מעביר את הארגומנטים כדגלים של שורת הפקודה אל מודול Python.

      • אם אתם משתמשים במאגר תגים בהתאמה אישית, Agent Platform מבטל את ההוראה CMD במאגר התגים שלכם באמצעות הארגומנטים.

   לוחצים על Continue.

6. בשלב Hyperparameter tuning (התאמת היפרפרמטרים), מוודאים שהתיבה Enable hyperparameter tuning (הפעלת התאמת היפרפרמטרים) לא מסומנת. לוחצים על המשך.

7. בשלב Compute and pricing (חישוב ותמחור), מציינים את ההגדרות הבאות:

   1. בתפריט הנפתח Region, בוחרים באפשרות region that supports custom training (אזור שתומך באימון מותאם אישית).

   2. בקטע Worker pool 0, מציינים את משאבי המחשוב שבהם רוצים להשתמש לאימון.

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

      אם רוצים לבצע אימון מבוזר, לוחצים על Add more worker pools (הוספת עוד מאגרי עובדים) ומציינים קבוצה נוספת של משאבי מחשוב לכל מאגר עובדים נוסף שרוצים להוסיף.

   לוחצים על Continue.

8. בשלב Prediction container (מאגר תגים לחיזוי), בוחרים באפשרות No prediction container (אין מאגר תגים לחיזוי).

9. כדי להפעיל את פייפליין האימון בלי שרת (serverless), לוחצים על Start training (התחלת אימון).

REST

לפני שמשתמשים בנתוני הבקשה, צריך להחליף את הנתונים הבאים:

• ‫LOCATION: האזור שבו יופעלו הקונטיינר או חבילת Python.
• ‫PROJECT_ID: [מזהה הפרויקט](/resource-manager/docs/creating-managing-projects#identifiers). .
• ‫JOB_NAME: שדה חובה. שם מוצג לCustomJob.
• מגדירים את משימת האימון בהתאמה אישית:
  • ‫MACHINE_TYPE: סוג המכונה. אפשר לעיין בסוגי המכונות שזמינים לאימון.
  • ‫ACCELERATOR_TYPE: (אופציונלי). סוג המאיץ לצירוף למשימה.
  • ‫ACCELERATOR_COUNT: (אופציונלי). מספר המאיצים לצירוף למשימה.
  • ‫DISK_TYPE: (אופציונלי). סוג דיסק האתחול שבו רוצים להשתמש למשימה, או pd-standard (ברירת מחדל) או pd-ssd. מידע נוסף על סוגי דיסקים
  • ‫DISK_SIZE: (אופציונלי). הגודל ב-GB של דיסק האתחול שבו יש להשתמש עבור העבודה. ערך ברירת המחדל הוא 100.
  • ‫REPLICA_COUNT: מספר העותקים של העובדים לשימוש. ברוב המקרים, צריך להגדיר את הערך הזה ל-1 עבור מאגר העובדים הראשון.
  • אם אפליקציית האימון פועלת בקונטיינר בהתאמה אישית, צריך לציין את הפרטים הבאים:
    • ‫CUSTOM_CONTAINER_IMAGE_URI: ה-URI של קובץ אימג' של קונטיינר ב-Artifact Registry או ב-Docker Hub, שיופעל בכל עותק משוכפל של העובד. /li>
    • ‫CUSTOM_CONTAINER_COMMAND: (אופציונלי). הפקודה שתופעל כשהקונטיינר יופעל. הפקודה הזו מבטלת את נקודת הכניסה שמוגדרת כברירת מחדל במאגר.
    • ‫CUSTOM_CONTAINER_ARGS: (אופציונלי). הארגומנטים שיועברו כשמפעילים את הקונטיינר.
  • אם אפליקציית האימון היא חבילת Python שפועלת בקונטיינר מוכן מראש, מציינים את הפרטים הבאים:
    • ‫EXECUTOR_IMAGE_URI: ה-URI של קובץ אימג' של קונטיינר שמריץ את הקוד שסופק. אפשר לעיין במאגרי התגים המוכנים מראש שזמינים לאימון.
    • ‫PYTHON_PACKAGE_URIS: רשימה מופרדת בפסיקים של URI של Cloud Storage שמציינים את קובצי חבילת Python שהם תוכנית האימון והחבילות התלויות שלה. המספר המקסימלי של כתובות URI של חבילות הוא 100.
    • ‫PYTHON_MODULE: השם של מודול Python להפעלה אחרי התקנת החבילות.
    • ‫PYTHON_PACKAGE_ARGS: (אופציונלי). ארגומנטים בשורת הפקודה שיועברו אל מודול Python.
  • מידע נוסף על אפשרויות לתזמון משימות
  • ‫TIMEOUT: (אופציונלי). זמן הריצה המקסימלי של העבודה.
• מציינים את התוויות LABEL_NAME ו-LABEL_VALUE שרוצים להוסיף למשרה המותאמת אישית.

ה-method של ה-HTTP וכתובת ה-URL:

POST https://LOCATION-aiplatform.googleapis.com/v1/projects/PROJECT_ID/locations/LOCATION/customJobs

גוף בקשת JSON:

{
  "displayName": "JOB_NAME",
  "jobSpec": {
    "workerPoolSpecs": [
      {
        "machineSpec": {
          "machineType": MACHINE_TYPE,
          "acceleratorType": ACCELERATOR_TYPE,
          "acceleratorCount": ACCELERATOR_COUNT
        },
        "replicaCount": REPLICA_COUNT,
        "diskSpec": {
          "bootDiskType": DISK_TYPE,
          "bootDiskSizeGb": DISK_SIZE
        },

        // Union field task can be only one of the following:
        "containerSpec": {
          "imageUri": CUSTOM_CONTAINER_IMAGE_URI,
          "command": [
            CUSTOM_CONTAINER_COMMAND
          ],
          "args": [
            CUSTOM_CONTAINER_ARGS
          ]
        },
        "pythonPackageSpec": {
          "executorImageUri": EXECUTOR_IMAGE_URI,
          "packageUris": [
            PYTHON_PACKAGE_URIS
          ],
          "pythonModule": PYTHON_MODULE,
          "args": [
            PYTHON_PACKAGE_ARGS
          ]
        }
        // End of list of possible types for union field task.
      }
      // Specify one workerPoolSpec for single replica training, or multiple workerPoolSpecs
      // for distributed training.
    ],
    "scheduling": {
      "timeout": TIMEOUT
    }
  },
  "labels": {
    LABEL_NAME_1": LABEL_VALUE_1,
    LABEL_NAME_2": LABEL_VALUE_2
  }
}

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

curl

הערה: הפקודה הבאה מבוססת על ההנחה שנכנסתם ל-CLI של gcloud באמצעות חשבון המשתמש שלכם, על ידי הרצת gcloud init או gcloud auth login, או באמצעות Cloud Shell שמחבר אתכם אוטומטית ל-CLI של gcloud. כדי לבדוק איזה חשבון פעיל, אפשר להריץ את הפקודה gcloud auth list.

שומרים את גוף הבקשה בקובץ בשם request.json ומריצים את הפקודה הבאה:

curl -X POST \
     -H "Authorization: Bearer $(gcloud auth print-access-token)" \
     -H "Content-Type: application/json; charset=utf-8" \
     -d @request.json \
     "https://LOCATION-aiplatform.googleapis.com/v1/projects/PROJECT_ID/locations/LOCATION/customJobs"

PowerShell

הערה: הפקודה הבאה מבוססת על ההנחה שנכנסתם ל-CLI של gcloud באמצעות חשבון המשתמש שלכם, על ידי הרצת gcloud init או gcloud auth login. כדי לבדוק איזה חשבון פעיל, אפשר להריץ את הפקודה gcloud auth list.

שומרים את גוף הבקשה בקובץ בשם request.json ומריצים את הפקודה הבאה:

$cred = gcloud auth print-access-token
$headers = @{ "Authorization" = "Bearer $cred" }

Invoke-WebRequest `
    -Method POST `
    -Headers $headers `
    -ContentType: "application/json; charset=utf-8" `
    -InFile request.json `
    -Uri "https://LOCATION-aiplatform.googleapis.com/v1/projects/PROJECT_ID/locations/LOCATION/customJobs" | Select-Object -Expand Content

התשובה מכילה מידע על המפרטים וגם על JOB_ID.

תשובה

{
  "name": "projects/PROJECT_ID/locations/LOCATION/customJobs/JOB_ID",
  "displayName": "JOB_NAME",
  "trainingTaskInputs": {
    "workerPoolSpecs": [
      {
        "machineSpec": {
          "machineType": "n1-standard-4"
        },
        "replicaCount": "1",
        "pythonPackageSpec": {
          "executorImageUri": "us-docker.pkg.dev/vertex-ai/training/training-tf-cpu.2-1:latest",
          "packageUris": [
            "gs://BUCKET_NAME/training/hello-custom-training-1.0.tar.gz"
          ],
          "pythonModule": "trainer.task",
          "args": [
            "--model-dir=gs://BUCKET_NAME/output/"
          ]
        }
      }
    ]
  },
  "state": "JOB_STATE_PENDING",
  "createTime": "2020-09-15T19:09:54.342080Z",
  "startTime": "2020-09-15T19:13:42.991045Z",
}

Java

לפני שמנסים את הדוגמה הזו, צריך לפעול לפי Javaההוראות להגדרה במאמר מדריך למתחילים של Agent Platform באמצעות ספריות לקוח. מידע נוסף מופיע במאמרי העזרה של Agent Platform Java API.

כדי לבצע אימות ב-Agent Platform, צריך להגדיר את Application Default Credentials. מידע נוסף זמין במאמר הגדרת אימות לסביבת פיתוח מקומית.

import com.google.cloud.aiplatform.v1.AcceleratorType;
import com.google.cloud.aiplatform.v1.ContainerSpec;
import com.google.cloud.aiplatform.v1.CustomJob;
import com.google.cloud.aiplatform.v1.CustomJobSpec;
import com.google.cloud.aiplatform.v1.JobServiceClient;
import com.google.cloud.aiplatform.v1.JobServiceSettings;
import com.google.cloud.aiplatform.v1.LocationName;
import com.google.cloud.aiplatform.v1.MachineSpec;
import com.google.cloud.aiplatform.v1.WorkerPoolSpec;
import java.io.IOException;

// Create a custom job to run machine learning training code in Vertex AI
public class CreateCustomJobSample {

  public static void main(String[] args) throws IOException {
    // TODO(developer): Replace these variables before running the sample.
    String project = "PROJECT";
    String displayName = "DISPLAY_NAME";

    // Vertex AI runs your training application in a Docker container image. A Docker container
    // image is a self-contained software package that includes code and all dependencies. Learn
    // more about preparing your training application at
    // https://cloud.google.com/vertex-ai/docs/training/overview#prepare_your_training_application
    String containerImageUri = "CONTAINER_IMAGE_URI";
    createCustomJobSample(project, displayName, containerImageUri);
  }

  static void createCustomJobSample(String project, String displayName, String containerImageUri)
      throws IOException {
    JobServiceSettings settings =
        JobServiceSettings.newBuilder()
            .setEndpoint("us-central1-aiplatform.googleapis.com:443")
            .build();
    String location = "us-central1";

    // Initialize client that will be used to send requests. This client only needs to be created
    // once, and can be reused for multiple requests.
    try (JobServiceClient client = JobServiceClient.create(settings)) {
      MachineSpec machineSpec =
          MachineSpec.newBuilder()
              .setMachineType("n1-standard-4")
              .setAcceleratorType(AcceleratorType.NVIDIA_TESLA_T4)
              .setAcceleratorCount(1)
              .build();

      ContainerSpec containerSpec =
          ContainerSpec.newBuilder().setImageUri(containerImageUri).build();

      WorkerPoolSpec workerPoolSpec =
          WorkerPoolSpec.newBuilder()
              .setMachineSpec(machineSpec)
              .setReplicaCount(1)
              .setContainerSpec(containerSpec)
              .build();

      CustomJobSpec customJobSpecJobSpec =
          CustomJobSpec.newBuilder().addWorkerPoolSpecs(workerPoolSpec).build();

      CustomJob customJob =
          CustomJob.newBuilder()
              .setDisplayName(displayName)
              .setJobSpec(customJobSpecJobSpec)
              .build();
      LocationName parent = LocationName.of(project, location);
      CustomJob response = client.createCustomJob(parent, customJob);
      System.out.format("response: %s\n", response);
      System.out.format("Name: %s\n", response.getName());
    }
  }
}

Node.js

לפני שמנסים את הדוגמה הזו, צריך לפעול לפי Node.jsההוראות להגדרה במאמר מדריך למתחילים של Agent Platform באמצעות ספריות לקוח. מידע נוסף מופיע במאמרי העזרה של Agent Platform Node.js API.

כדי לבצע אימות ב-Agent Platform, צריך להגדיר את Application Default Credentials. מידע נוסף זמין במאמר הגדרת אימות לסביבת פיתוח מקומית.

/**
 * TODO(developer): Uncomment these variables before running the sample.\
 * (Not necessary if passing values as arguments)
 */

// const customJobDisplayName = 'YOUR_CUSTOM_JOB_DISPLAY_NAME';
// const containerImageUri = 'YOUR_CONTAINER_IMAGE_URI';
// const project = 'YOUR_PROJECT_ID';
// const location = 'YOUR_PROJECT_LOCATION';

// Imports the Google Cloud Job Service Client library
const {JobServiceClient} = require('@google-cloud/aiplatform');

// Specifies the location of the api endpoint
const clientOptions = {
  apiEndpoint: 'us-central1-aiplatform.googleapis.com',
};

// Instantiates a client
const jobServiceClient = new JobServiceClient(clientOptions);

async function createCustomJob() {
  // Configure the parent resource
  const parent = `projects/${project}/locations/${location}`;
  const customJob = {
    displayName: customJobDisplayName,
    jobSpec: {
      workerPoolSpecs: [
        {
          machineSpec: {
            machineType: 'n1-standard-4',
            acceleratorType: 'NVIDIA_TESLA_T4',
            acceleratorCount: 1,
          },
          replicaCount: 1,
          containerSpec: {
            imageUri: containerImageUri,
            command: [],
            args: [],
          },
        },
      ],
    },
  };
  const request = {parent, customJob};

  // Create custom job request
  const [response] = await jobServiceClient.createCustomJob(request);

  console.log('Create custom job response:\n', JSON.stringify(response));
}
createCustomJob();

Python

במאמר התקנת Vertex AI SDK ל-Python מוסבר איך להתקין או לעדכן את Vertex AI SDK ל-Python. מידע נוסף מופיע ב מאמרי העזרה של Python API.

def create_custom_job_with_experiment_autologging_sample(
    project: str,
    location: str,
    staging_bucket: str,
    display_name: str,
    script_path: str,
    container_uri: str,
    service_account: str,
    experiment: str,
    experiment_run: Optional[str] = None,
) -> None:
    aiplatform.init(project=project, location=location, staging_bucket=staging_bucket, experiment=experiment)

    job = aiplatform.CustomJob.from_local_script(
        display_name=display_name,
        script_path=script_path,
        container_uri=container_uri,
        enable_autolog=True,
    )

    job.run(
        service_account=service_account,
        experiment=experiment,
        experiment_run=experiment_run,
    )

המאמרים הבאים

• Cloud Profiler עוזר לכם לזהות צווארי בקבוק בביצועי האימון כדי לאמן מודלים מהר יותר ובעלות נמוכה יותר.
• במאמר יצירת צינורות אימון מוסבר איך ליצור צינורות אימון להרצת אפליקציות אימון ללא שרתים בפלטפורמת הסוכנים של Gemini Enterprise.
• איך מתזמנים משימות אימון ללא שרתים על סמך זמינות המשאבים