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

Vertex AI: שימוש באריזה אוטומטית כדי לכוונן את BERT עם חיבוק פנים באימון Vertex AI

1. סקירה כללית

בשיעור ה-Lab הזה תלמדו איך להריץ משימת אימון מותאמת אישית ב-Vertex AI Training עם תכונת האריזה האוטומטית. משימות אימון בהתאמה אישית בקונטיינרים של Vertex AI משתמשות. אם אתם לא רוצים ליצור קובץ אימג' משלכם, תוכלו להשתמש ב-auotpackaging כדי ליצור תמונת Docker מותאמת אישית על סמך הקוד שלכם, להעביר את התמונה ל-Container Registry ולהפעיל CustomJob על סמך התמונה.

מה לומדים

נסביר לכם איך:

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

העלות הכוללת של הפעלת שיעור ה-Lab הזה ב-Google Cloud היא כ-$2.

2. סקירה כללית של תרחיש השימוש

באמצעות ספריות של Hugging Face, אתם יכולים לכוונן את מודל BERT במערך הנתונים של IMDB. המודל יחזה אם הביקורת על סרט תהיה חיובית או שלילית. המערכת תוריד את מערך הנתונים מספריית מערכי הנתונים של תמונות חיבוקים וממודל BERT מספריית הטרנספורמרים של Faceing Face.

3. מבוא ל-Vertex AI

בשיעור ה-Lab הזה נעשה שימוש במוצר ה-AI החדש ביותר שזמין ב-Google Cloud. Vertex AI משלב את הצעות למידת המכונה ב-Google Cloud ליצירת חוויית פיתוח חלקה. בעבר, ניתן היה לגשת למודלים שעברו אימון באמצעות AutoML ומודלים בהתאמה אישית דרך שירותים נפרדים. המוצר החדש משלב את כל ממשקי ה-API האלה בממשק API אחד, לצד מוצרים חדשים אחרים. תוכלו גם להעביר פרויקטים קיימים ל-Vertex AI. יש לך משוב? אפשר למצוא אותו בדף התמיכה.

Vertex AI כולל מוצרים רבים ושונים לתמיכה בתהליכי עבודה של למידת מכונה מקצה לקצה. שיעור ה-Lab הזה יתמקד בהדרכה וב-Workbench.

סקירה כללית של המוצר Vertex

4. הגדרת הסביבה

כדי להריץ את ה-Codelab הזה צריך פרויקט ב-Google Cloud Platform שהחיוב מופעל בו. כדי ליצור פרויקט, יש לפעול לפי ההוראות האלה.

שלב 1: מפעילים את ממשק ה-API של Compute Engine

עוברים אל Compute Engine ובוחרים באפשרות Enable (הפעלה) אם היא לא מופעלת עדיין.

שלב 2: מפעילים את Vertex AI API

עוברים לקטע Vertex AI במסוף Cloud ולוחצים על Enable Vertex AI API.

מרכז הבקרה של Vertex AI

שלב 3: מפעילים את Container Registry API

עוברים אל Container Registry ובוחרים באפשרות Enable אם עדיין לא משתמשים בו. אפשר להשתמש בו כדי ליצור מאגר למשימת האימון המותאמת אישית.

שלב 4: יצירת מכונה של Vertex AI Workbench

בקטע Vertex AI במסוף Cloud, לוחצים על Workbench:

משם, לוחצים על פנקסי רשימות מנוהלים:

Notebooks_UI

לאחר מכן בוחרים פנקס רשימות חדש.

new_notebook

נותנים שם ל-notebook ולוחצים על הגדרות מתקדמות.

create_notebook

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

idle_timeout

אפשר להשאיר את כל שאר ההגדרות המתקדמות כפי שהן.

לאחר מכן, לוחצים על יצירה.

אחרי שהמכונה נוצרה, בוחרים באפשרות Open JupyterLab.

open_jupyterlab

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

אימות

5. כתיבת קוד אימון

כדי להתחיל, פותחים חלון Terminal במכונה של ה-notebook מתפריט מרכז האפליקציות:

launcher_terminal

יוצרים ספרייה חדשה בשם autopkg-codelab ומוסיפים אליה cd.

mkdir autopkg-codelab
cd autopkg-codelab

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

mkdir trainer
touch trainer/task.py

עכשיו אמורים להיות בספרייה autopkg-codelab/ הפריטים הבאים:

+ trainer/
    + task.py

אחר כך פותחים את הקובץ task.py שיצרתם ומעתיקים את הקוד שבהמשך.

import argparse

import tensorflow as tf
from datasets import load_dataset
from transformers import AutoTokenizer
from transformers import TFAutoModelForSequenceClassification

CHECKPOINT = "bert-base-cased"

def get_args():
  '''Parses args.'''

  parser = argparse.ArgumentParser()
  parser.add_argument(
      '--epochs',
      required=False,
      default=3,
      type=int,
      help='number of epochs')
  parser.add_argument(
      '--job_dir',
      required=True,
      type=str,
      help='bucket to store saved model, include gs://')
  args = parser.parse_args()
  return args


def create_datasets():
    '''Creates a tf.data.Dataset for train and evaluation.'''

    raw_datasets = load_dataset('imdb')
    tokenizer = AutoTokenizer.from_pretrained(CHECKPOINT)
    tokenized_datasets = raw_datasets.map((lambda examples: tokenize_function(examples, tokenizer)), batched=True)

    # To speed up training, we use only a portion of the data.
    # Use full_train_dataset and full_eval_dataset if you want to train on all the data.
    small_train_dataset = tokenized_datasets['train'].shuffle(seed=42).select(range(1000))
    small_eval_dataset = tokenized_datasets['test'].shuffle(seed=42).select(range(1000))
    full_train_dataset = tokenized_datasets['train']
    full_eval_dataset = tokenized_datasets['test']

    tf_train_dataset = small_train_dataset.remove_columns(['text']).with_format("tensorflow")
    tf_eval_dataset = small_eval_dataset.remove_columns(['text']).with_format("tensorflow")

    train_features = {x: tf_train_dataset[x] for x in tokenizer.model_input_names}
    train_tf_dataset = tf.data.Dataset.from_tensor_slices((train_features, tf_train_dataset["label"]))
    train_tf_dataset = train_tf_dataset.shuffle(len(tf_train_dataset)).batch(8)

    eval_features = {x: tf_eval_dataset[x] for x in tokenizer.model_input_names}
    eval_tf_dataset = tf.data.Dataset.from_tensor_slices((eval_features, tf_eval_dataset["label"]))
    eval_tf_dataset = eval_tf_dataset.batch(8)

    return train_tf_dataset, eval_tf_dataset


def tokenize_function(examples, tokenizer):
    '''Tokenizes text examples.'''

    return tokenizer(examples['text'], padding='max_length', truncation=True)


def main():
    args = get_args()
    train_tf_dataset, eval_tf_dataset = create_datasets()
    model = TFAutoModelForSequenceClassification.from_pretrained(CHECKPOINT, num_labels=2)

    model.compile(
        optimizer=tf.keras.optimizers.Adam(learning_rate=0.01),
        loss=tf.keras.losses.SparseCategoricalCrossentropy(from_logits=True),
        metrics=tf.metrics.SparseCategoricalAccuracy(),
    )

    model.fit(train_tf_dataset, validation_data=eval_tf_dataset, epochs=args.epochs)
    model.save(f'{args.job_dir}/model_output')


if __name__ == "__main__":
    main()

כמה דברים שחשוב לציין לגבי הקוד:

CHECKPOINT הוא המודל שרוצים לכוונן. במקרה הזה, נשתמש ב-BERT.
ה-method TFAutoModelForSequenceClassification תטען את ארכיטקטורת מודל השפה שצוינה ואת המשקולות ב-TensorFlow ותוסיף כותרת סיווג למעלה עם משקולות שאותחלו באופן אקראי. במקרה הזה, יש לנו בעיית סיווג בינארית (חיובית או שלילית), ולכן אנחנו מציינים את num_labels=2 עבור המסווג הזה.

6. יצירת קונטיינרים והרצה של קוד אימון באופן מקומי

אפשר להשתמש בפקודה gcloud ai custom-jobs local-run כדי לפתח תמונת קונטיינר של Docker על סמך קוד האימון, ולהריץ את קובץ האימג' כקונטיינר במחשב המקומי. הרצת קונטיינר גורמת להפעלת קוד האימון באופן מקומי בצורה דומה להרצה שלו ב-Vertex AI Training, והיא יכולה לעזור לכם לנפות באגים בקוד לפני שמבצעים אימון מותאם אישית ב-Vertex AI.

במשימת האימון, נייצא את המודל המאומן שלנו לקטגוריה של Cloud Storage. ב-Terminal, מריצים את הפקודה הבאה כדי להגדיר משתנה env לפרויקט ומקפידים להחליף את your-cloud-project במזהה הפרויקט:

PROJECT_ID='your-cloud-project'

לאחר מכן יוצרים קטגוריה. אם יש לכם קטגוריה קיימת, אתם יכולים להשתמש בה במקום זאת.

BUCKET_NAME="gs://${PROJECT_ID}-bucket"
gsutil mb -l us-central1 $BUCKET_NAME

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

מריצים את הפקודה הבאה כדי להגדיר את ה-URI של תמונת Docker שתשמש כבסיס של הקונטיינר.

BASE_CPU_IMAGE=us-docker.pkg.dev/vertex-ai/training/tf-cpu.2-7:latest

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

OUTPUT_IMAGE=$PROJECT_ID-local-package-cpu:latest

קוד האימון שלנו משתמש בספריות של מערכי הנתונים של Hugging Face וספריות הטרנספורמרים. הספריות האלה לא נכללות בתמונה שבחרנו כתמונת הבסיס, ולכן נצטרך לספק אותן כדרישות. לשם כך, ניצור קובץ requirements.txt בספרייה autopkg-codelab שלנו.

עליך לוודא שנמצאים בספרייה autopkg-codelab ולהקליד את הפקודה הבאה בטרמינל.

touch requirements.txt

עכשיו אמורים להיות בספרייה autopkg-codelab הפריטים הבאים:

+ requirements.txt
+ trainer/
    + task.py

יש לפתוח את קובץ הדרישות ולהדביק את הפרטים הבאים

datasets==1.18.2
transformers==4.16.2

בשלב האחרון, מריצים את הפקודה gcloud ai custom-jobs local-run כדי להתחיל את האימון במכונה המנוהלת של Workbench.

gcloud ai custom-jobs local-run \
--executor-image-uri=$BASE_CPU_IMAGE \
--python-module=trainer.task \
--output-image-uri=$OUTPUT_IMAGE \
-- \
--job_dir=$BUCKET_NAME

אתם אמורים לראות את קובץ האימג' של Docker בתהליך הבנייה. יחסי התלות שהוספנו לקובץ requirements.txt יותקנו ב-pip. בפעם הראשונה שמריצים את הפקודה הזו, התהליך עשוי להימשך כמה דקות. אחרי בניית התמונה, הקובץtask.py יתחיל לרוץ והאימון של המודל יוצג. אתם אמורים לראות משהו כזה:

local_training

מכיוון שאנחנו לא משתמשים ב-GPU באופן מקומי, אימון המודלים יימשך זמן רב. אפשר Ctrl+c ולבטל את ההדרכה המקומית במקום להמתין להשלמת המשימה.

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

gcloud beta ai custom-jobs local-run \
--executor-image-uri=$OUTPUT_IMAGE \
-- \
--job_dir=$BUCKET_NAME \
--epochs=1

7. יצירת משרה בהתאמה אישית

עכשיו, אחרי שבדקנו את המצב המקומי, נשתמש בתכונה 'אריזה אוטומטית' כדי להשיק את משימת האימון המותאמת אישית באימון של Vertex AI. באמצעות פקודה אחת, התכונה הזו:

פיתוח תמונת Docker מותאמת אישית על סמך הקוד שלכם.
דוחפים את התמונה ל-Container Registry.
צריך להתחיל CustomJob על סמך התמונה.

חוזרים לטרמינל ולוחצים רמה אחת מעל הספרייה autopkg-codelab.

+ autopkg-codelab
  + requirements.txt
  + trainer/
      + task.py

צריך לציין את התמונה של ה-GPU של TensorFlow מראש לאימון של Vertex AI, בתור תמונת הבסיס למשימת האימון המותאמת אישית.

BASE_GPU_IMAGE=us-docker.pkg.dev/vertex-ai/training/tf-gpu.2-7:latest

בשלב הבא, מריצים את הפקודה gcloud ai custom-jobs create. קודם כל, הפקודה הזו תבנה תמונת Docker מותאמת אישית על סמך קוד האימון. קובץ האימג' הבסיסי הוא הקונטיינר שנוצר מראש ב-Vertex AI Training שהגדרנו בתור BASE_GPU_IMAGE. לאחר מכן תכונת האריזה האוטומטית תתקין את קובץ הנתונים (PIP) של מערכי הנתונים ואת ספריות הטרנספורמרים כפי שמצוין בקובץ requirements.txt שלנו.

gcloud ai custom-jobs create \
--region=us-central1 \
--display-name=fine_tune_bert \
--args=--job_dir=$BUCKET_NAME \
--worker-pool-spec=machine-type=n1-standard-4,replica-count=1,accelerator-type=NVIDIA_TESLA_V100,executor-image-uri=$BASE_GPU_IMAGE,local-package-path=autopkg-codelab,python-module=trainer.task

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

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

machine-type (חובה): סוג המכונה. כאן אפשר למצוא סוגים נתמכים.
replica-count: מספר הרפליקות של העובדים לשימוש במאגר העובדים הזה. כברירת מחדל הערך הוא 1.
accelerator-type: סוג יחידות ה-GPU. כאן אפשר למצוא סוגים נתמכים. בדוגמה הזו ציינתם יחידת GPU אחת מסוג NVIDIA Tesla V100.
accelerator-count: מספר יחידות ה-GPU לכל מכונה וירטואלית במאגר העובדים שצריך להשתמש בה. כברירת מחדל, הערך הוא 1.
executor-image-uri: ה-URI של קובץ אימג' של קונטיינר שיפעיל את החבילה שסופקה. הוא מוגדר לתמונת הבסיס שלנו.
local-package-path: הנתיב המקומי של תיקייה שמכילה קוד אימון.
python-module: שם מודול Python שיש לפעול בתוך החבילה שסופקה.

בדומה להרצה של הפקודה המקומית, תראו את תמונת ה-Docker בתהליך הבנייה ולאחר מכן משימת האימון תתחיל. במקום לראות את הפלט של משימת האימון, תופיע ההודעה הבאה שמאשרת שמשימת האימון התחילה. הערה: בפעם הראשונה שמריצים את הפקודה custom-jobs create, יכול להיות שיעברו כמה דקות עד שהתמונה תיבנה ותידחוף אותה.

training_started

חוזרים לקטע Vertex AI Training במסוף Cloud, ובקטע CUSTOM JOBS אמורים לראות את העבודה שלכם.

training_job

המשימה תימשך כ-20 דקות.

בסיום התהליך, הפריטים השמורים הבאים של המודל אמורים להופיע בספרייה model_output בקטגוריה.

model_output

🎉 כל הכבוד! 🎉

למדתם איך להשתמש ב-Vertex AI כדי:

יצירת קונטיינרים והרצה של קוד אימון באופן מקומי
שליחת משימות אימון ל-Vertex AI Training עם Autopackaging

כדי לקבל מידע נוסף על החלקים השונים ב-Vertex AI, אתם יכולים לעיין במסמכי העזרה.

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

בגלל שהגדרנו את ה-notebook להפסקה של הזמן הקצוב לתפוגה אחרי 60 דקות ללא פעילות, אנחנו לא צריכים לדאוג לכיבוי המכונה. כדי לכבות את המכונה באופן ידני, לוחצים על הלחצן Stop (עצירה) בקטע Vertex AI Workbench במסוף. אם אתה רוצה למחוק לגמרי את ה-notebook, לחץ על הלחצן 'מחיקה'.

delete

כדי למחוק את קטגוריית האחסון, באמצעות תפריט הניווט במסוף Cloud, עוברים אל Storage (אחסון), בוחרים את הקטגוריה ולוחצים על סמל המחיקה:

מחיקת האחסון