1. סקירה כללית
בשיעור ה-Lab הזה תלמדו איך להריץ משימה מותאמת אישית לאימון מודל באמצעות Kubeflow Pipelines SDK ב-Vertex Pipelines.
מה תלמדו
נסביר לכם איך:
- שימוש ב-Kubeflow Pipelines SDK כדי לפתח צינורות עיבוד נתונים ניתנים להרחבה של למידת מכונה
- יצירת משימת אימון מותאמת אישית של מודל Scikit-learn בקונטיינר, שמשתמשת במערכי נתונים מנוהלים של Vertex AI ותופעל ב-Vertex AI Training בתוך צינור עיבוד נתונים
- הרצת משימת חיזוי באצווה בתוך Vertex Pipelines
- להשתמש ברכיבים מוכנים מראש לאינטראקציה עם שירותי Vertex AI, שמסופקים דרך הספרייה
google_cloud_pipeline_components
העלות הכוללת להרצת הסדנה הזו ב-Google Cloud היא כ-$5.
2. מבוא ל-Vertex AI
במעבדה הזו נעשה שימוש ב-Vertex AI, הפלטפורמה המנוהלת שלנו ל-ML מקצה לקצה ב-Google Cloud. Vertex AI משלב את חבילות השירות של Google ללמידת מכונה ב-Google Cloud לחוויית פיתוח חלקה. בנוסף לשירותי אימון מודלים ופריסה שלהם, Vertex AI כולל גם מגוון מוצרים של MLOps, כולל Vertex Pipelines (המרכז של סדנת ה-Lab הזו), Model Monitoring, Feature Store ועוד. כל מוצרי Vertex AI מפורטים בתרשים הבא.
יש לך משוב? אפשר להיכנס לדף התמיכה.
למה צינורות עיבוד נתונים של למידת מכונה שימושיים?
לפני שנצלול לתוך הנושא, חשוב להבין למה כדאי להשתמש בצינור עיבוד נתונים. נניח שאתם מפתחים תהליך עבודה של למידת מכונה שכולל עיבוד נתונים, אימון מודל, התאמת פרמטרים היפר-מרחביים, הערכה ופריסה של מודל. לכל אחד מהשלבים האלה יכולות להיות יחסי תלות שונים, שעשויים להיות קשים לניהול אם מתייחסים לתהליך העבודה כולו כאל מונולית. כשמתחילים להרחיב את תהליך למידת המכונה, כדאי לשתף את תהליך העבודה של למידת המכונה עם אנשים אחרים בצוות כדי שהם יוכלו להריץ אותו ולתרום קוד. ללא תהליך אמין שאפשר לשחזר, זה יכול להיות קשה. באמצעות צינורות עיבוד נתונים, כל שלב בתהליך למידת המכונה הוא מאגר משלו. כך אפשר לפתח שלבים בנפרד ולעקוב אחרי הקלט והפלט של כל שלב באופן שניתן לשחזור. אפשר גם לתזמן או להפעיל את ההרצות של צינור עיבוד הנתונים על סמך אירועים אחרים בסביבת Cloud, כמו הפעלת הרצה של צינור עיבוד הנתונים כשיש נתוני אימון חדשים.
The tl;dr: צינורות עיבוד נתונים עוזרים לפשט ולשחזר את תהליכי העבודה שלכם ללמידת מכונה.
3. הגדרה של סביבת הענן
כדי להריץ את הקודלה הזה, צריך פרויקט ב-Google Cloud Platform שבו החיוב מופעל. כדי ליצור פרויקט, יש לפעול לפי ההוראות האלה.
שלב 1: הפעלת Cloud Shell
בשיעור ה-Lab הזה תלמדו איך לעבוד בסשן של Cloud Shell, שהוא מתורגם פקודות שמתארח במכונה וירטואלית שפועלת בענן של Google. אפשר להריץ את הקטע הזה בקלות גם באופן מקומי במחשב שלכם, אבל השימוש ב-Cloud Shell מאפשר לכל אחד לגשת לחוויה שניתן לשחזור בסביבה עקבית. בסיום הסדנה, תוכלו לנסות שוב את הקטע הזה במחשב שלכם.
הפעלת Cloud Shell
בצד שמאל למעלה ב-Cloud Console, לוחצים על הלחצן שלמטה כדי Activate Cloud Shell (הפעלה של Cloud Shell):
אם זו הפעם הראשונה שאתם מפעילים את Cloud Shell, יוצג לכם מסך ביניים (מתחת לקצה המסך) עם תיאור של Cloud Shell. במקרה כזה, לוחצים על Continue (והמסך הזה לא יוצג לכם שוב). כך נראה המסך החד-פעמי:
ההקצאה וההתחברות ל-Cloud Shell נמשכת כמה דקות.
המכונה הווירטואלית הזו כוללת את כל הכלים הדרושים לפיתוח. יש בה ספריית בית בנפח מתמיד של 5GB והיא פועלת ב-Google Cloud, משפרת מאוד את הביצועים והאימות של הרשת. אפשר לבצע חלק גדול מהעבודה ב-codelab הזה, אם לא את כולה, באמצעות דפדפן או Chromebook.
אחרי שתתחברו ל-Cloud Shell, אמורה להופיע הודעה על כך שהאימות כבר בוצע והפרויקט כבר מוגדר לפי מזהה הפרויקט שלכם.
מריצים את הפקודה הבאה ב-Cloud Shell כדי לוודא שהאימות בוצע:
gcloud auth list
אתם אמורים לראות משהו כזה בפלט הפקודה:
מריצים את הפקודה הבאה ב-Cloud Shell כדי לוודא שהפקודה ב-gcloud יודעת על הפרויקט שלכם:
gcloud config list project
פלט הפקודה
[core] project = <PROJECT_ID>
אם לא, אפשר להגדיר אותו באמצעות הפקודה הבאה:
gcloud config set project <PROJECT_ID>
פלט הפקודה
Updated property [core/project].
ל-Cloud Shell יש כמה משתני סביבה, כולל GOOGLE_CLOUD_PROJECT שמכיל את השם של הפרויקט הנוכחי ב-Cloud. נשתמש בו במקומות שונים במהלך שיעור ה-Lab. אפשר לראות אותו על ידי הפעלת הפקודה:
echo $GOOGLE_CLOUD_PROJECT
שלב 2: מפעילים את ממשקי ה-API
בשלבים הבאים נסביר איפה נדרשים השירותים האלה (ולמה), אבל בינתיים מריצים את הפקודה הבאה כדי לתת לפרויקט גישה לשירותים Compute Engine, Container Registry ו-Vertex AI:
gcloud services enable compute.googleapis.com \
containerregistry.googleapis.com \
aiplatform.googleapis.com
אמורה ליצור מסר מוצלח שדומה להודעה הזו:
Operation "operations/acf.cc11852d-40af-47ad-9d59-477a12847c9e" finished successfully.
שלב 3: יצירת קטגוריה של Cloud Storage
כדי להריץ משימה של אימון ב-Vertex AI, נצטרך קטגוריית אחסון לאחסון נכסי המודלים השמורים שלנו. הקטגוריה צריכה להיות אזורית. אנחנו משתמשים כאן ב-us-central, אבל אתם יכולים להשתמש באזור אחר (פשוט מחליפים אותו בכל שיעור ה-Lab). אם כבר יש לכם קטגוריה, אתם יכולים לדלג על השלב הזה.
כדי ליצור קטגוריה, מריצים את הפקודות הבאות בטרמינל של Cloud Shell:
BUCKET_NAME=gs://$GOOGLE_CLOUD_PROJECT-bucket
gsutil mb -l us-central1 $BUCKET_NAME
בשלב הבא נתת לחשבון השירות שלנו ל-Compute גישה לקטגוריה הזו. כך תבטיחו של-Vertex Pipelines יהיו ההרשאות הדרושות לכתיבת קבצים בקטגוריה הזו. מריצים את הפקודה הבאה כדי להוסיף את ההרשאה הזו:
gcloud projects describe $GOOGLE_CLOUD_PROJECT > project-info.txt
PROJECT_NUM=$(cat project-info.txt | sed -nre 's:.*projectNumber\: (.*):\1:p')
SVC_ACCOUNT="${PROJECT_NUM//\'/}-compute@developer.gserviceaccount.com"
gcloud projects add-iam-policy-binding $GOOGLE_CLOUD_PROJECT --member serviceAccount:$SVC_ACCOUNT --role roles/storage.objectAdmin
שלב 4: יצירת מכונה של Vertex AI Workbench
בקטע Vertex AI במסוף Cloud, לוחצים על Workbench:
לאחר מכן, בקטע Notebooks בניהול המשתמשים, לוחצים על New Notebook:
לאחר מכן בוחרים בסוג המכונה TensorFlow Enterprise 2.3 (with LTS) without GPUs:
משתמשים באפשרויות ברירת המחדל ולוחצים על Create.
שלב 5: פותחים את ה-Notebook
אחרי יצירת המכונה, בוחרים באפשרות Open JupyterLab:
4. הגדרת Vertex Pipelines
יש כמה ספריות נוספות שנצטרך להתקין כדי להשתמש ב-Vertex Pipelines:
- Kubeflow Pipelines: זהו ה-SDK שבו נשתמש כדי ליצור את צינור עיבוד הנתונים. ב-Vertex Pipelines יש תמיכה בצינורות עיבוד נתונים שפועלים ב-Kubeflow Pipelines וגם ב-TFX.
- רכיבי צינור עיבוד נתונים של Google Cloud: הספרייה הזו מספקת רכיבים מוכנים מראש שמאפשרים לבצע אינטראקציה בקלות עם שירותי Vertex AI מהשלבים בצינור עיבוד הנתונים.
שלב 1: יצירת notebook ב-Python והתקנת ספריות
קודם כול, בתפריט Launcher במכונה של Notebook (אפשר לגשת אליו בלחיצה על סמל הפלוס + בפינה הימנית העליונה של Notebook), יוצרים פנקס הערות על ידי בחירה באפשרות Python 3:
כדי לגשת לתפריט 'מרכז האפליקציות', לוחצים על הסימן + בפינה השמאלית העליונה של מכונה של מחברת.
כדי להתקין את שני השירותים שבהם נשתמש בשיעור ה-Lab הזה, קודם צריך להגדיר את דגל המשתמש בתא ב-notebook:
USER_FLAG = "--user"
לאחר מכן מריצים את הפקודה הבאה מה-notebook:
!pip3 install {USER_FLAG} google-cloud-aiplatform==1.7.0 --upgrade
!pip3 install {USER_FLAG} kfp==1.8.9 google-cloud-pipeline-components==0.2.0
אחרי התקנת החבילות האלה, צריך להפעיל מחדש את הליבה:
import os
if not os.getenv("IS_TESTING"):
# Automatically restart kernel after installs
import IPython
app = IPython.Application.instance()
app.kernel.do_shutdown(True)
לבסוף, בודקים שהתקנתם את החבילות בצורה נכונה. גרסת ה-SDK של KFP צריכה להיות 1.8 ומעלה:
!python3 -c "import kfp; print('KFP SDK version: {}'.format(kfp.__version__))"
!python3 -c "import google_cloud_pipeline_components; print('google_cloud_pipeline_components version: {}'.format(google_cloud_pipeline_components.__version__))"
שלב 2: מגדירים את מזהה הפרויקט ואת הקטגוריה
בשיעור ה-Lab הזה תפנו למזהה הפרויקט ב-Cloud ולקטגוריה שיצרתם קודם. בשלב הבא ניצור משתנים לכל אחד מהם.
אם אתם לא יודעים מהו מזהה הפרויקט, יכול להיות שתוכלו לקבל אותו על ידי הפעלת הפקודה הבאה:
import os
PROJECT_ID = ""
# Get your Google Cloud project ID from gcloud
if not os.getenv("IS_TESTING"):
shell_output=!gcloud config list --format 'value(core.project)' 2>/dev/null
PROJECT_ID = shell_output[0]
print("Project ID: ", PROJECT_ID)
אחרת, מגדירים אותו כאן:
if PROJECT_ID == "" or PROJECT_ID is None:
PROJECT_ID = "your-project-id" # @param {type:"string"}
לאחר מכן יוצרים משתנה לאחסון שם הקטגוריה. אם יצרתם אותו בשיעור ה-Lab הזה, הפעולות הבאות יעבדו. אחרת, תצטרכו להגדיר את זה באופן ידני:
BUCKET_NAME="gs://" + PROJECT_ID + "-bucket"
שלב 3: ייבוא ספריות
מוסיפים את הקוד הבא כדי לייבא את הספריות שבהן נשתמש במהלך הקודלאב:
from kfp.v2 import compiler, dsl
from kfp.v2.dsl import pipeline
from google.cloud import aiplatform
from google_cloud_pipeline_components import aiplatform as gcc_aip
שלב 4: מגדירים קבועים
הדבר האחרון שצריך לעשות לפני שמפתחים את צינור עיבוד הנתונים הוא להגדיר כמה משתנים קבועים. PIPELINE_ROOT הוא הנתיב של Cloud Storage שבו ייכתבו הארטיפקטים שנוצרו על ידי צינור עיבוד הנתונים שלנו. אנחנו משתמשים כאן באזור us-central1, אבל אם השתמשתם באזור אחר כשיצרתם את הקטגוריה, עליכם לעדכן את המשתנה REGION בקוד הבא:
PATH=%env PATH
%env PATH={PATH}:/home/jupyter/.local/bin
REGION="us-central1"
PIPELINE_ROOT = f"{BUCKET_NAME}/pipeline_root/"
PIPELINE_ROOT
אחרי הרצת הקוד שלמעלה, ספריית השורש של צינור עיבוד הנתונים אמורה להדפיס. זהו המיקום ב-Cloud Storage שאליו ייכתבו הארטיפקטים מצינור עיבוד הנתונים. הוא יהיה בפורמט gs://YOUR-BUCKET-NAME/pipeline_root/
5. הגדרת משימה של אימון מודל בהתאמה אישית
לפני שמגדירים את צינור עיבוד הנתונים, צריך לכתוב את הקוד של המשימה לאימון המודל בהתאמה אישית. כדי לאמן את המודל, נשתמש במערך הנתונים של למידת מכונה יבש ב-UCI, מהסוגים הבאים: KOKLU, M ו-OZKAN, I.A., (2020), "Multiclass Classification of Dry Beans Using Computer Vision and Machine Learning Techniques", Computers and Electronics in Agriculture, 174, 105507. DOI
בשלב הראשון בצינור עיבוד הנתונים ניצור מערך נתונים מנוהל ב-Vertex AI באמצעות טבלת BigQuery שמכילה גרסה של נתוני ה-beans האלה. מערך הנתונים יועבר כקלט למשימה האימון שלנו. בקוד האימון שלנו תהיה גישה למשתנה סביבה כדי לגשת למערך הנתונים המנוהל הזה.
כך נגדיר את משימה האימון בהתאמה אישית:
- כתיבת מודל
DecisionTreeClassifierשל Scikit-learn לסיווג סוגי שעועית בנתונים שלנו - אריזה של קוד האימון בקונטיינר של Docker והעברה שלו ל-Container Registry
לאחר מכן נוכל להפעיל משימה של Vertex AI Training ישירות מצינור עיבוד הנתונים שלנו. קדימה, מתחילים!
שלב 1: הגדרת קוד האימון שלנו בקונטיינר ב-Docker
במכונה של ה-notebooks, פותחים את מרכז האפליקציות ובוחרים באפשרות Terminal:
לאחר מכן, מריצים את הפקודה הבאה כדי להגדיר ספרייה שבה תוסיפו את הקוד בקונטיינר:
mkdir traincontainer
cd traincontainer
touch Dockerfile
mkdir trainer
touch trainer/train.py
אחרי שמריצים את הפקודות האלה, בצד ימין אמורה להופיע ספרייה בשם traincontainer/ (יכול להיות שתצטרכו ללחוץ על סמל הרענון כדי לראות אותה). בספרייה traincontainer/ יופיעו הפריטים הבאים:
+ Dockerfile
+ trainer/
+ train.py
השלב הראשון בתהליך הכנסת הקוד לקונטיינרים הוא ליצור קובץ Dockerfile. ב-Dockerfile שלנו נכלול את כל הפקודות הנדרשות להרצת קובץ האימג'. הקוד יטמיע את כל הספריות שבהן אנחנו משתמשים ויגדיר את נקודת הכניסה לקוד האימון שלנו. פותחים את קובץ ה-Docker שיצרתם ומוסיפים את הפרטים הבאים:
FROM gcr.io/deeplearning-platform-release/sklearn-cpu.0-23
WORKDIR /
# Copies the trainer code to the docker image.
COPY trainer /trainer
RUN pip install sklearn google-cloud-bigquery joblib pandas google-cloud-storage
# Sets up the entry point to invoke the trainer.
ENTRYPOINT ["python", "-m", "trainer.train"]
כדי לשמור קבצים בזמן העריכה שלהם במכונה של המחברות, אפשר להשתמש ב-ctrl+s.
לאחר מכן, פותחים את הקובץ train.py. זה המקום שבו נוסיף את קוד האימון. מעתיקים את הטקסט הבא אל train.py. הפונקציה הזו מאחזרת את הנתונים ממערך הנתונים המנוהל שלנו, מעבירה אותם ל-Pandas DataFrame, מאומנת מודל של Scikit-learn ומעלה את המודל המאומן ל-Cloud Storage:
from sklearn.tree import DecisionTreeClassifier
from sklearn.metrics import roc_curve
from sklearn.model_selection import train_test_split
from google.cloud import bigquery
from google.cloud import storage
from joblib import dump
import os
import pandas as pd
bqclient = bigquery.Client()
storage_client = storage.Client()
def download_table(bq_table_uri: str):
prefix = "bq://"
if bq_table_uri.startswith(prefix):
bq_table_uri = bq_table_uri[len(prefix):]
table = bigquery.TableReference.from_string(bq_table_uri)
rows = bqclient.list_rows(
table,
)
return rows.to_dataframe(create_bqstorage_client=False)
# These environment variables are from Vertex AI managed datasets
training_data_uri = os.environ["AIP_TRAINING_DATA_URI"]
test_data_uri = os.environ["AIP_TEST_DATA_URI"]
# Download data into Pandas DataFrames, split into train / test
df = download_table(training_data_uri)
test_df = download_table(test_data_uri)
labels = df.pop("Class").tolist()
data = df.values.tolist()
test_labels = test_df.pop("Class").tolist()
test_data = test_df.values.tolist()
# Define and train the Scikit model
skmodel = DecisionTreeClassifier()
skmodel.fit(data, labels)
score = skmodel.score(test_data, test_labels)
print('accuracy is:',score)
# Save the model to a local file
dump(skmodel, "model.joblib")
# Upload the saved model file to GCS
bucket = storage_client.get_bucket("YOUR_GCS_BUCKET")
model_directory = os.environ["AIP_MODEL_DIR"]
storage_path = os.path.join(model_directory, "model.joblib")
blob = storage.blob.Blob.from_string(storage_path, client=storage_client)
blob.upload_from_filename("model.joblib")
אחר כך חוזרים ל-notebook ומריצים את הפקודה הבאה כדי להחליף את YOUR_GCS_BUCKET מהסקריפט שלמעלה בשם של הקטגוריה שלכם ב-Cloud Storage:
BUCKET = BUCKET_NAME[5:] # Trim the 'gs://' before adding to train script
!sed -i -r 's@YOUR_GCS_BUCKET@'"$BUCKET"'@' traincontainer/trainer/train.py
אם אתם מעדיפים, תוכלו לעשות זאת באופן ידני. אם כן, חשוב לא לכלול את gs:// בשם הקטגוריה כשמעדכנים את הסקריפט.
עכשיו קוד האימון נמצא בקונטיינר של Docker, ואנחנו מוכנים להריץ את האימון ב-Cloud.
שלב 2: דחיפה של הקונטיינר ל-Container Registry
לאחר השלמת קוד ההכשרה, אנחנו מוכנים להעביר אותו ל-Google Container Registry. בהמשך, כשנתקין את רכיב האימון בצינור עיבוד הנתונים, נכוון את Vertex Pipelines לקונטיינר הזה.
חוזרים ל-Terminal, ומהרמה הבסיסית (root) של הספרייה traincontainer/ מגדירים משתנה עם ה-URI של קובץ האימג' בקונטיינר ב-Container Registry.
PROJECT_ID=$(gcloud config get-value project)
IMAGE_URI="gcr.io/$PROJECT_ID/scikit:v1"
לאחר מכן, מריצים את הפקודה הבאה כדי ליצור את מאגר התגים:
docker build ./ -t $IMAGE_URI
בשלב האחרון, מעבירים את הקונטיינר ל-Container Registry:
docker push $IMAGE_URI
נכנסים לקטע Container Registry במסוף Cloud כדי לוודא שהקונטיינר נמצא שם. החיפוש ייראה בערך כך:
6. הגדרה של משימת חיזוי באצווה
בשלב האחרון בצינור עיבוד הנתונים שלנו ירוץ תהליך של חיזוי באצווה. כדי שזה יעבוד, אנחנו צריכים לספק קובץ CSV ב-Cloud Storage שמכיל את הדוגמאות שאנחנו רוצים לקבל עליהן חיזויים. ניצור את קובץ ה-CSV הזה ביומן שלנו ונעתיק אותו ל-Cloud Storage באמצעות כלי שורת הפקודה gsutil.
העתקת דוגמאות לחיזוי באצווה ל-Cloud Storage
הקובץ הבא מכיל 3 דוגמאות מכל כיתה במערך הנתונים של השעועעים. הדוגמה הבאה לא כוללת את העמודה Class כי זה מה שהמודל שלנו ינבא. כדי ליצור את קובץ ה-CSV הזה באופן מקומי ביומן, מריצים את הפקודה הבאה:
%%writefile batch_examples.csv
Area,Perimeter,MajorAxisLength,MinorAxisLength,AspectRation,Eccentricity,ConvexArea,EquivDiameter,Extent,Solidity,roundness,Compactness,ShapeFactor1,ShapeFactor2,ShapeFactor3,ShapeFactor4
23288,558.113,207.567738,143.085693,1.450653336,0.7244336162,23545,172.1952453,0.8045881703,0.9890847314,0.9395021523,0.8295857874,0.008913077034,0.002604069884,0.6882125787,0.9983578734
23689,575.638,205.9678003,146.7475015,1.403552348,0.7016945718,24018,173.6714472,0.7652721693,0.9863019402,0.8983750474,0.8431970773,0.00869465998,0.002711119968,0.7109813112,0.9978994889
23727,559.503,189.7993849,159.3717704,1.190922235,0.5430731512,24021,173.8106863,0.8037601626,0.9877607094,0.952462433,0.9157600082,0.007999299741,0.003470231343,0.8386163926,0.9987269085
31158,641.105,212.0669751,187.1929601,1.132879009,0.4699241567,31474,199.1773023,0.7813134733,0.989959967,0.9526231013,0.9392188582,0.0068061806,0.003267009878,0.8821320637,0.9993488983
32514,649.012,221.4454899,187.1344232,1.183349841,0.5346736437,32843,203.4652564,0.7849831,0.9899826447,0.9700068737,0.9188051492,0.00681077351,0.002994124691,0.8442029022,0.9989873701
33078,659.456,235.5600775,178.9312328,1.316483846,0.6503915309,33333,205.2223615,0.7877214708,0.9923499235,0.9558229607,0.8712102818,0.007121351881,0.002530662194,0.7590073551,0.9992209221
33680,683.09,256.203255,167.9334938,1.525623324,0.7552213942,34019,207.081404,0.80680321,0.9900349805,0.9070392732,0.8082699962,0.007606985006,0.002002710402,0.6533003868,0.9966903078
33954,716.75,277.3684803,156.3563259,1.773951126,0.825970469,34420,207.9220419,0.7994819873,0.9864613597,0.8305492781,0.7496238998,0.008168948587,0.001591181142,0.5619359911,0.996846984
36322,719.437,272.0582306,170.8914975,1.591993952,0.7780978465,36717,215.0502424,0.7718560075,0.9892420405,0.8818487005,0.7904566678,0.007490177594,0.001803782407,0.6248217437,0.9947124371
36675,742.917,285.8908964,166.8819538,1.713132487,0.8119506999,37613,216.0927123,0.7788277766,0.9750618137,0.8350248381,0.7558572692,0.0077952528,0.001569528272,0.5713202115,0.9787472145
37454,772.679,297.6274753,162.1493177,1.835514817,0.8385619338,38113,218.3756257,0.8016695205,0.9827093118,0.7883332637,0.7337213257,0.007946480356,0.001420623993,0.5383469838,0.9881438654
37789,766.378,313.5680678,154.3409867,2.031657789,0.8704771226,38251,219.3500608,0.7805870567,0.9879218844,0.8085170916,0.6995293312,0.008297866252,0.001225659709,0.4893412853,0.9941740339
47883,873.536,327.9986493,186.5201272,1.758516115,0.822571799,48753,246.9140116,0.7584464543,0.9821549443,0.7885506623,0.7527897207,0.006850002074,0.00135695419,0.5666923636,0.9965376533
49777,861.277,300.7570338,211.6168613,1.42123379,0.7105823885,50590,251.7499649,0.8019106536,0.9839296304,0.843243269,0.8370542883,0.00604208839,0.001829706116,0.7006598815,0.9958014989
49882,891.505,357.1890036,179.8346914,1.986207449,0.8640114945,51042,252.0153467,0.7260210171,0.9772736178,0.7886896753,0.7055518063,0.007160679276,0.001094585314,0.4978033513,0.9887407248
53249,919.923,325.3866286,208.9174205,1.557489212,0.7666552108,54195,260.3818974,0.6966846347,0.9825445152,0.7907120655,0.8002231025,0.00611066177,0.001545654241,0.6403570138,0.9973491406
61129,964.969,369.3481688,210.9473449,1.750902193,0.8208567513,61796,278.9836198,0.7501135067,0.9892064211,0.8249553283,0.7553404711,0.006042110436,0.001213219664,0.5705392272,0.9989583843
61918,960.372,353.1381442,224.0962377,1.575832543,0.7728529173,62627,280.7782864,0.7539207091,0.9886790043,0.8436218213,0.7950947556,0.005703319619,0.00140599258,0.6321756704,0.9962029945
141953,1402.05,524.2311633,346.3974998,1.513380332,0.7505863011,143704,425.1354762,0.7147107987,0.9878152313,0.9074598849,0.8109694843,0.003692991084,0.0009853172185,0.6576715044,0.9953071199
145285,1440.991,524.9567463,353.0769977,1.486805285,0.7400216694,146709,430.0960442,0.7860466375,0.9902937107,0.8792413513,0.8192980608,0.003613289371,0.001004269363,0.6712493125,0.9980170255
146153,1476.383,526.1933264,356.528288,1.475881001,0.7354662103,149267,431.3789276,0.7319360978,0.9791380546,0.8425962592,0.8198107159,0.003600290972,0.001003163512,0.6720896099,0.991924286
לאחר מכן מעתיקים את הקובץ לקטגוריה ב-Cloud Storage:
!gsutil cp batch_examples.csv $BUCKET_NAME
נתייחס לקובץ הזה בשלב הבא, כשנגדיר את צינור עיבוד הנתונים.
7. פיתוח צינור עיבוד נתונים עם רכיבים מוכנים מראש
עכשיו, אחרי שקוד האימון נמצא בענן, אנחנו מוכנים להפעיל אותו מצינור עיבוד הנתונים שלנו. צינור עיבוד הנתונים (pipeline) שתגדירו ישתמש בשלושה רכיבים מוכנים מראש מהספרייה google_cloud_pipeline_components שהתקנתם קודם. הרכיבים המוגדרים מראש האלה מפשטים את הקוד שצריך לכתוב כדי להגדיר את צינור עיבוד הנתונים, ומאפשרים לנו להשתמש בשירותי Vertex AI כמו אימון מודלים וחיזוי באצווה.
כך יפעל צינור עיבוד הנתונים בן שלושת השלבים:
- יצירת מערך נתונים מנוהל ב-Vertex AI
- הרצת משימת אימון על Vertx AI באמצעות הקונטיינר בהתאמה אישית שהגדרנו
- הרצת משימה של חיזוי באצווה במודל הסיווג שעבר אימון ב-Scikit-learn
שלב 1: הגדרת צינור עיבוד הנתונים שלנו
מכיוון שאנחנו משתמשים ברכיבים שנוצרו מראש, אנחנו יכולים להגדיר את צינור עיבוד הנתונים כולו בהגדרת צינור עיבוד הנתונים. מוסיפים את הטקסט הבא לתא ב-notebook:
@pipeline(name="automl-beans-custom",
pipeline_root=PIPELINE_ROOT)
def pipeline(
bq_source: str = "bq://sara-vertex-demos.beans_demo.large_dataset",
bucket: str = BUCKET_NAME,
project: str = PROJECT_ID,
gcp_region: str = REGION,
bq_dest: str = "",
container_uri: str = "",
batch_destination: str = ""
):
dataset_create_op = gcc_aip.TabularDatasetCreateOp(
display_name="tabular-beans-dataset",
bq_source=bq_source,
project=project,
location=gcp_region
)
training_op = gcc_aip.CustomContainerTrainingJobRunOp(
display_name="pipeline-beans-custom-train",
container_uri=container_uri,
project=project,
location=gcp_region,
dataset=dataset_create_op.outputs["dataset"],
staging_bucket=bucket,
training_fraction_split=0.8,
validation_fraction_split=0.1,
test_fraction_split=0.1,
bigquery_destination=bq_dest,
model_serving_container_image_uri="us-docker.pkg.dev/vertex-ai/prediction/sklearn-cpu.0-24:latest",
model_display_name="scikit-beans-model-pipeline",
machine_type="n1-standard-4",
)
batch_predict_op = gcc_aip.ModelBatchPredictOp(
project=project,
location=gcp_region,
job_display_name="beans-batch-predict",
model=training_op.outputs["model"],
gcs_source_uris=["{0}/batch_examples.csv".format(BUCKET_NAME)],
instances_format="csv",
gcs_destination_output_uri_prefix=batch_destination,
machine_type="n1-standard-4"
)
שלב 2: הידור והפעלה של צינור עיבוד הנתונים
עכשיו, אחרי שהגדרתם את צינור עיבוד הנתונים, אתם מוכנים לקמפל אותו. הפקודה הבאה תיצור קובץ JSON שמשמש להפעלת צינור עיבוד הנתונים:
compiler.Compiler().compile(
pipeline_func=pipeline, package_path="custom_train_pipeline.json"
)
בשלב הבא יוצרים משתנה TIMESTAMP. נשתמש בו במזהה המשימה:
from datetime import datetime
TIMESTAMP = datetime.now().strftime("%Y%m%d%H%M%S")
לאחר מכן מגדירים את המשימה בצינור עיבוד הנתונים, ומעבירים כמה פרמטרים ספציפיים לפרויקט:
pipeline_job = aiplatform.PipelineJob(
display_name="custom-train-pipeline",
template_path="custom_train_pipeline.json",
job_id="custom-train-pipeline-{0}".format(TIMESTAMP),
parameter_values={
"project": PROJECT_ID,
"bucket": BUCKET_NAME,
"bq_dest": "bq://{0}".format(PROJECT_ID),
"container_uri": "gcr.io/{0}/scikit:v1".format(PROJECT_ID),
"batch_destination": "{0}/batchpredresults".format(BUCKET_NAME)
},
enable_caching=True,
)
לבסוף, מריצים את המשימה כדי ליצור הרצת צינור עיבוד נתונים חדשה:
pipeline_job.submit()
אחרי הרצת התא הזה, אמורים להופיע יומנים עם קישור להצגת ההרצה של צינור עיבוד הנתונים במסוף:
עוברים לקישור הזה. אפשר לגשת אליו גם דרך מרכז הבקרה של צינורות עיבוד נתונים. צינור עיבוד הנתונים אמור להיראות כך בסיום:
הרצה של צינור עיבוד הנתונים הזה תימשך 5-10 דקות, אבל אתם יכולים להמשיך לשלב הבא לפני שהוא יסתיים. בהמשך נסביר מה קורה בכל אחד מהשלבים האלה בצינור עיבוד הנתונים.
8. הסבר על הפעלת צינור עיבוד הנתונים
בואו נתעמק בכל אחד משלושת השלבים בצינור עיבוד הנתונים.
שלב 1 בצינור עיבוד הנתונים: יצירת מערך נתונים מנוהל
בשלב הראשון בצינור עיבוד הנתונים שלנו נוצר מערך נתונים מנוהל ב-Vertex AI. אם לוחצים על הקישור הבא למערך הנתונים בקטע Pipelines במסוף:
מערך הנתונים יופיע ב-Vertex AI, ויכלול קישור למקור הנתונים ב-BigQuery ומידע על העמודות השונות במערך הנתונים. אחרי שמעלים מערך נתונים מנוהל ל-Vertex AI, אפשר להשתמש בו לאימון של מודלים של AutoML או של מודלים מותאמים אישית.
במשימות של מודלים בהתאמה אישית שמשתמשות במערכי נתונים מנוהלים, מערכת Vertex AI מעבירה משתני סביבה מיוחדים למשימות האימון ומטפלת בפיצול הנתונים לקבוצות אימון ובדיקה. נשתמש בזה בשלב הבא בצינור עיבוד הנתונים.
שלב 2 בצינור עיבוד הנתונים: אימון מודל ב-Vertex AI Training
בזמן שמשימת האימון המותאמת אישית פועלת, אתם יכולים ללחוץ כדי לצפות ביומנים ישירות במסוף Vertex Pipelines:
אפשר לראות פרטים על משימה האימון בהתאמה אישית גם במרכז הבקרה של Vertex AI Training. בסיום משימה האימון, ייווצר משאב מודל ב-Vertex AI. לאחר מכן נוכל לפרוס את המודל הזה לנקודת קצה (endpoint) כדי לבצע חיזויים אונליין, או ליצור משימה של חיזוי באצווה. נבצע את הפעולה הזו בשלב הבא בצינור עיבוד הנתונים.
שלב 3: הרצת משימת חיזוי באצווה במודל שלנו
בסיום, צינור עיבוד הנתונים שלנו יקבל תחזיות לגבי הדוגמאות שהעברנו באמצעות קובץ CSV. בסיום המשימה של חיזוי האצווה, מערכת Vertex AI תכתוב קובץ CSV במיקום שציינתם ב-Cloud Storage. כשהשלב הזה של צינור עיבוד הנתונים יתחיל לפעול, תוכלו לעבור לקטע Batch Predictions במסוף Vertex AI כדי לראות את המשימה שנוצרה.
כשתהליך העבודה יושלם, לוחצים עליו כדי לראות את כתובת ה-URL של תחזיות האצווה ב-Cloud Storage:
לוחצים על הקישור הזה כדי לעבור לספריית Cloud Storage שבה נמצאות תוצאות החיזוי, ואז לוחצים כדי להוריד אחד מהקבצים מסוג prediction.results. בקובץ אמורות להופיע שורות שנראות כך:
{"instance": [33954.0, 716.75, 277.3684803, 156.3563259, 1.773951126, 0.825970469, 34420.0, 207.9220419, 0.7994819873, 0.9864613597, 0.8305492781, 0.7496238998, 0.008168948587, 0.001591181142, 0.5619359911, 0.996846984], "prediction": "HOROZ"}
הוא כולל את ערכי המאפיינים של מופע מסוים, יחד עם הסיווג שהמודל שלנו ניבא. בדוגמה הזו, המודל שלנו חושב שמדובר בשעועית 'HOROZ'.
זהו, סיימתם את שיעור ה-Lab!
🎉 כל הכבוד! 🎉
למדתם איך להשתמש ב-Vertex AI כדי:
- שימוש ב-Kubeflow Pipelines SDK כדי לפתח צינורות עיבוד נתונים מקצה לקצה עם רכיבים מותאמים אישית
- הרצת צינורות עיבוד נתונים ב-Vertex Pipelines והפעלת צינורות עיבוד נתונים עם ה-SDK
- הצגה וניתוח של תרשים Vertex Pipelines במסוף
- שימוש ברכיבים מוכנים מראש של צינורות עיבוד נתונים כדי להוסיף שירותי Vertex AI לצינור עיבוד הנתונים
- תזמון משימות חוזרות בצינור עיבוד נתונים
מידע נוסף על החלקים השונים של Vertex זמין במסמכי העזרה.
9. הסרת המשאבים
כדי שלא תחויבו, מומלץ למחוק את המשאבים שנוצרו במהלך הסדנה.
שלב 1: עצירת המכונה של Notebooks או מחיקת המכונה
אם אתם רוצים להמשיך להשתמש במחברת שיצרתם במעבדה הזו, מומלץ לכבות אותה כשהיא לא בשימוש. בממשק המשתמש של Notebooks במסוף Cloud, בוחרים את ה-notebook ואז לוחצים על Stop. כדי למחוק את המכונה לגמרי, בוחרים באפשרות מחיקה:
שלב 2: מוחקים את הקטגוריה ב-Cloud Storage
כדי למחוק את הקטגוריה של האחסון, עוברים לתפריט הניווט במסוף Cloud, לוחצים על Storage, בוחרים את הקטגוריה ולוחצים על Delete:
