1. סקירה כללית
בשיעור ה-Lab הזה תלמדו איך להריץ משימת אימון מודלים בהתאמה אישית באמצעות Kubeflow Pipelines SDK ב-Vertex Pipelines.
מה לומדים
נסביר לכם איך:
- שימוש ב-Kubeflow Pipelines SDK כדי לפתח צינורות עיבוד נתונים ניתנים להתאמה של למידת מכונה
- יצירה ויצירת קונטיינרים של משימה מותאמת אישית לאימון מודל של Scikit-learn שמשתמשת במערכי נתונים מנוהלים של Vertex AI, ותרוץ באימון של Vertex AI בתוך צינור עיבוד נתונים
- הרצת משימת חיזוי באצווה בתוך Vertex Pipelines
- להשתמש ברכיבים מוכנים מראש לאינטראקציה עם שירותי Vertex AI, שמסופקים דרך הספרייה
google_cloud_pipeline_components
העלות הכוללת של הפעלת שיעור ה-Lab הזה ב-Google Cloud היא כ-5$.
2. מבוא ל-Vertex AI
בשיעור ה-Lab הזה נעשה שימוש ב-Vertex AI, פלטפורמת למידת המכונה המנוהלת שלנו מקצה לקצה ב-Google Cloud. Vertex AI משלב הצעות למידת מכונה של Google בכל Google Cloud, ומאפשר חוויית פיתוח חלקה. בנוסף לאימון מודלים ולשירותי פריסה, Vertex AI כולל גם מגוון מוצרי MLOps, כולל Vertex Pipelines (המוקד של שיעור ה-Lab הזה), Model Monitoring, Feature Store ועוד. אתם יכולים לראות את כל המוצרים של Vertex AI בתרשים הבא.
יש לך משוב? אפשר למצוא אותו בדף התמיכה.
למה צינורות עיבוד נתונים של למידת מכונה שימושיים?
לפני שנצלול לעומק, נסביר למה כדאי להשתמש בצינור עיבוד נתונים. נניח שאתם מפתחים תהליך עבודה של למידת מכונה שכולל עיבוד נתונים, אימון מודל, כוונון היפר-פרמטרים, הערכה ופריסת מודלים. לכל אחד מהשלבים האלה עשויים להיות יחסי תלות שונים, ואם תתייחסו לתהליך העבודה כולו כמונולית, הדבר עלול להיות קשה יותר. כשתתחילו לבצע התאמה לעומס של תהליך למידת המכונה (ML), יכול להיות שתרצו לשתף עם אחרים בצוות את תהליך העבודה של למידת המכונה כדי שהם יוכלו להריץ אותו ולתרום קוד. ללא תהליך מהימן וניתן לשחזור, הדבר עלול להיות קשה. בצינורות עיבוד נתונים, כל שלב בתהליך למידת המכונה הוא קונטיינר משלו. כך תוכלו לפתח שלבים באופן עצמאי ולעקוב אחרי הקלט והפלט מכל שלב בדרך של שחזור. תוכלו גם לתזמן או להפעיל הפעלות של צינור עיבוד הנתונים על סמך אירועים אחרים בסביבת הענן שלכם, כמו הפעלת צינור עיבוד נתונים כשיש נתוני אימון חדשים.
The tl;dr: צינורות עיבוד נתונים עוזרים לפשט ולשחזר את תהליכי העבודה שלכם ללמידת מכונה.
3. הגדרה של סביבת הענן
כדי להריץ את ה-Codelab הזה צריך פרויקט ב-Google Cloud Platform שהחיוב מופעל בו. כדי ליצור פרויקט, יש לפעול לפי ההוראות האלה.
שלב 1: הפעלת Cloud Shell
בשיעור ה-Lab הזה תלמדו במסגרת סשן של Cloud Shell, שהוא תרגום פקודות שמתארח במכונה וירטואלית שרצה בענן של Google. באותה מידה תוכלו להריץ את הקטע הזה באופן מקומי במחשב שלכם, אבל השימוש ב-Cloud Shell מאפשר לכולם ליהנות מחוויה שניתן לשחזר בסביבה עקבית. אחרי שיעור ה-Lab, אתם יכולים לנסות שוב את הקטע הזה במחשב.
הפעלת Cloud Shell
בצד שמאל למעלה ב-Cloud Console, לוחצים על הלחצן שלמטה כדי Activate Cloud Shell (הפעלה של Cloud Shell):
אם לא הפעלתם את Cloud Shell בעבר, יוצג לכם מסך ביניים (בחלק הנגלל) שמתאר מהו. במקרה כזה, לוחצים על המשך (וזה לא יקרה שוב). כך נראה המסך החד-פעמי:
ההקצאה וההתחברות ל-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
בשלב הבא ניתן לחשבון שירות המחשוב שלנו גישה לקטגוריה הזו. כך תבטיחו של-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 (עם LTS) ללא GPUs:
משתמשים באפשרויות ברירת המחדל ואז לוחצים על יצירה.
שלב 5: פותחים את ה-notebook
אחרי שיוצרים את המכונה, בוחרים באפשרות Open JupyterLab:
4. הגדרה של Vertex Pipelines
יש כמה ספריות נוספות שנצטרך להתקין כדי להשתמש ב-Vertex Pipelines:
- Kubeflow Pipelines: זה ה-SDK שבו נשתמש כדי לפתח את צינור עיבוד הנתונים שלנו. ב-Vertex Pipelines יש תמיכה בצינורות עיבוד נתונים שפועלים ב-Kubeflow Pipelines וגם ב-TFX.
- רכיבי Google Cloud Pipeline: הספרייה הזו מספקת רכיבים מוכנים מראש כדי להקל על האינטראקציה עם שירותי Vertex AI מהשלבים של צינור עיבוד הנתונים.
שלב 1: יצירת notebook ב-Python והתקנת ספריות
קודם כול, יוצרים מחברת באמצעות בחירה ב-Python 3 מתפריט מרכז האפליקציות במכונה של ה-notebook (אפשר לגשת אליו בלחיצה על הסמל + בפינה הימנית העליונה של ה-notebook):
כדי לגשת לתפריט של מרכז האפליקציות, לוחצים על הסימן + בפינה הימנית העליונה של מכונת ה-notebook.
כדי להתקין את שני השירותים שבהם נשתמש בשיעור ה-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)
לבסוף, מוודאים שהתקנתם את החבילות בצורה תקינה. הגרסה של KFP SDK צריכה להיות >=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: ייבוא ספריות
צריך להוסיף את הפריטים הבאים כדי לייבא את הספריות שבהן נשתמש ב-Codelab הזה:
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), "סיווג רב-סיווגי של שעועית יבשה באמצעות ראייה ממוחשבת וטכניקות למידת מכונה".בליחולים, 174, 105507. DOI.
בשלב הראשון בצינור עיבוד הנתונים ליצירת מערך נתונים מנוהל ב-Vertex AI באמצעות טבלת BigQuery שמכילה גרסה של נתוני ה-Beans האלה. מערך הנתונים יועבר כקלט למשימת האימון שלנו. בקוד האימון שלנו תהיה גישה למשתנה סביבה כדי לגשת למערך הנתונים המנוהל הזה.
כך נגדיר את משימת האימון המותאמת אישית:
- כתיבת מודל
DecisionTreeClassifierשל Scikit-learn כדי לסווג שעועית בנתונים בנתונים שלנו - אורזים את קוד האימון בקונטיינר של Docker ודוחפים אותו ל-Container Registry
משם נוכל להתחיל משימת הכשרה של Vertex AI ישירות מצינור עיבוד הנתונים שלנו. קדימה, מתחילים!
שלב 1: הגדרת קוד האימון שלנו בקונטיינר ב-Docker
במכונה של ה-notebooks, פותחים את מרכז האפליקציות ובוחרים באפשרות Terminal:
לאחר מכן מריצים את הפקודה הבאה כדי להגדיר ספרייה שאליה מוסיפים את הקוד בקונטיינר:
mkdir traincontainer
cd traincontainer
touch Dockerfile
mkdir trainer
touch trainer/train.py
אחרי שמריצים את הפקודות האלה, אמורה להופיע ספרייה בשם traincontainer/ שנוצרה בצד ימין (יכול להיות שצריך ללחוץ על סמל הרענון כדי לראות אותה). הפריטים הבאים יופיעו בספריית traincontainer/:
+ Dockerfile
+ trainer/
+ train.py
השלב הראשון ביצירת קונטיינרים לקוד שלנו הוא יצירת קובץ Docker. בקובץ ה-Docker נכלול את כל הפקודות הנדרשות כדי להריץ את קובץ האימג' שלנו. הוא יתקין את כל הספריות שבהן אנחנו משתמשים ויגדיר את נקודת הכניסה לקוד האימון שלנו. פותחים את קובץ ה-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"]
כדי לשמור קבצים בזמן שעורכים אותם במכונה של ה-notebook, אפשר להשתמש ב-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, ואנחנו מוכנים להריץ אימון בענן.
שלב 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 הזה ב-notebook ונעתיק אותו ל-Cloud Storage באמצעות כלי שורת הפקודה gsutil.
העתקת דוגמאות לחיזוי באצווה ל-Cloud Storage
הקובץ הבא מכיל 3 דוגמאות מכל כיתה במערך הנתונים של שעועית. הדוגמה שלמטה לא כוללת את העמודה Class כי זה מה שהמודל שלנו יחזה. מריצים את הפקודה הבאה כדי ליצור את קובץ ה-CSV הזה באופן מקומי ב-notebook:
%%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. פיתוח צינור עיבוד נתונים עם רכיבים מוכנים מראש
עכשיו, כשקוד האימון נמצא בענן, אנחנו מוכנים לקרוא לו מצינור עיבוד הנתונים שלנו. בצינור עיבוד הנתונים שנגדיר ייעשה שימוש בשלושה רכיבים מוכנים מראש מספריית 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
בזמן שמשימת האימון המותאמת אישית פועלת, אתם יכולים ללחוץ כדי לצפות ביומנים ישירות במסוף Vertex Pipelines:
אפשר גם לראות פרטים על משימת האימון המותאמת אישית במרכז הבקרה להדרכה של Vertex AI. בסיום משימת האימון, ייווצר משאב של מודל ב-Vertex AI. לאחר מכן נוכל לפרוס את המודל הזה בנקודת קצה לתחזיות אונליין או ליצור משימת חיזוי באצווה, שאותו נבצע בשלב הבא בצינור עיבוד הנתונים.
שלב 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. הסרת המשאבים
כדי שלא תחויבו, מומלץ למחוק את המשאבים שנוצרו בשיעור ה-Lab הזה.
שלב 1: מפסיקים או מוחקים את המכונה של Notebooks
אם אתם רוצים להמשיך להשתמש ב-notebook שיצרתם בשיעור ה-Lab הזה, מומלץ להשבית אותו כשהוא לא בשימוש. בממשק המשתמש של Notebooks במסוף Cloud, בוחרים את ה-notebook ואז לוחצים על Stop. כדי למחוק את המכונה לגמרי, בוחרים באפשרות מחיקה:
שלב 2: מחיקת הקטגוריה של Cloud Storage
כדי למחוק את קטגוריית האחסון, באמצעות תפריט הניווט במסוף Cloud, עוברים אל Storage (אחסון), בוחרים את הקטגוריה ולוחצים על סמל המחיקה:
