1. סקירה כללית
בשיעור ה-Lab הזה תלמדו איך להריץ משימת אימון של מודל בהתאמה אישית באמצעות Kubeflow Pipelines SDK ב-Vertex Pipelines.
מה לומדים
במאמר הזה נסביר איך:
- שימוש ב-Kubeflow Pipelines SDK כדי לבנות צינורות עיבוד נתונים של למידת מכונה (ML) שניתנים להרחבה
- יצירה של משימת אימון מותאמת אישית של מודל Scikit-learn בקונטיינרים, שימוש במערכי נתונים מנוהלים של Vertex AI והפעלת המשימה ב-Vertex AI Training בתוך פייפליין
- הרצת משימת חיזוי באצווה ב-Vertex Pipelines
- שימוש ברכיבים מוכנים מראש לאינטראקציה עם שירותי Vertex AI, שזמינים דרך ספריית
google_cloud_pipeline_components
העלות הכוללת להרצת שיעור ה-Lab הזה ב-Google Cloud היא בערך 5$.
2. מבוא ל-Vertex AI
ב-Lab הזה נעשה שימוש ב-Vertex AI, פלטפורמת ה-ML המנוהלת מקצה לקצה שלנו ב-Google Cloud. Vertex AI משלב את מוצרי ה-ML של Google ב-Google Cloud לחוויית פיתוח חלקה. בנוסף לשירותי אימון ופריסה של מודלים, Vertex AI כולל גם מגוון מוצרי MLOps, כולל Vertex Pipelines (המוצר העיקרי בשיעור ה-Lab הזה), Model Monitoring, Feature Store ועוד. בדיאגרמה שלמטה אפשר לראות את כל המוצרים של Vertex AI.
אם יש לך משוב, אפשר לעיין בדף התמיכה.
למה צינורות עיבוד נתונים של למידת מכונה שימושיים?
לפני שמתחילים, כדאי להבין למה כדאי להשתמש בפייפליין. נניח שאתם בונים תהליך עבודה של למידת מכונה שכולל עיבוד נתונים, אימון מודל, כוונון היפר-פרמטרים, הערכה ופריסת מודל. לכל אחד מהשלבים האלה יכולות להיות תלויות שונות, וזה יכול להיות מסובך אם מתייחסים לכל תהליך העבודה כמקשה אחת. כשמתחילים להרחיב את תהליך ה-ML, כדאי לשתף את תהליך העבודה של ה-ML עם חברים אחרים בצוות כדי שהם יוכלו להפעיל פתרונות חכמים ולתרום קוד. ללא תהליך אמין שניתן לשחזור, זה יכול להיות קשה. בצינורות, כל שלב בתהליך למידת המכונה הוא קונטיינר משלו. כך תוכלו לפתח שלבים בנפרד ולעקוב אחרי הקלט והפלט מכל שלב בצורה שניתנת לשחזור. אפשר גם לתזמן או להפעיל הרצות של פייפליין על סמך אירועים אחרים בסביבת Cloud, כמו הפעלה של הרצת פייפליין כשנתוני אימון חדשים זמינים.
האמ;לק: צינורות עיבוד נתונים עוזרים לכם לייעל ולשחזר את תהליכי העבודה של למידת מכונה.
3. הגדרה של סביבת ענן
כדי להפעיל את ה-codelab הזה, צריך פרויקט ב-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 נמשכים רק כמה רגעים.
המכונה הווירטואלית הזו כוללת את כל הכלים שדרושים למפתחים. יש בה ספריית בית בנפח מתמיד של 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 שמכיל את השם של פרויקט בענן הנוכחי. נשתמש בזה במקומות שונים במהלך שיעור ה-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, נצטרך קטגוריית אחסון לאחסון נכסי המודל השמורים. הקטגוריה צריכה להיות אזורית. בשיעור Lab הזה אנחנו משתמשים ב-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:
משתמשים באפשרויות ברירת המחדל ולוחצים על יצירה.
שלב 5: פותחים את המחברת
אחרי שהמופע נוצר, בוחרים באפשרות Open JupyterLab:
4. הגדרה של Vertex Pipelines
כדי להשתמש ב-Vertex Pipelines, צריך להתקין עוד כמה ספריות:
- Kubeflow Pipelines: זהו ה-SDK שבו נשתמש כדי לבנות את צינור עיבוד הנתונים. ב-Vertex Pipelines יש תמיכה בהרצת צינורות עיבוד נתונים שנבנו באמצעות Kubeflow Pipelines או TFX.
- רכיבי פייפליין של Google Cloud: בספרייה הזו יש רכיבים מוכנים מראש שמקלים על האינטראקציה עם שירותי Vertex AI משלבי הפייפליין.
שלב 1: יוצרים מחברת Python ומתקינים ספריות
קודם כל, בתפריט Launcher במופע Notebook (אפשר לגשת אליו בלחיצה על סמל הפלוס בפינה הימנית העליונה של ה-Notebook), יוצרים Notebook על ידי בחירה באפשרות Python 3:
כדי לגשת לתפריט מרכז האפליקציות, לוחצים על הסימן + בפינה השמאלית העליונה של מחברת Jupyter.
כדי להתקין את שני השירותים שבהם נשתמש בשיעור ה-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 הזה תצטרכו להתייחס למזהה פרויקט בענן ולמאגר שיצרתם קודם. לאחר מכן ניצור משתנים לכל אחד מהם.
אם אתם לא יודעים מהו מזהה הפרויקט, יכול להיות שתוכלו לקבל אותו על ידי הפעלת הפקודה הבאה:
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 Machine Learning, מתוך: KOKLU, M. and OZKAN, I.A., (2020), "Multiclass Classification of Dry Beans Using Computer Vision and Machine Learning Techniques."In Computers and Electronics in Agriculture, 174, 105507. DOI.
בשלב הראשון בפייפליין ניצור קבוצת נתונים מנוהלת ב-Vertex AI באמצעות טבלה ב-BigQuery שמכילה גרסה של נתוני הפולים האלה. מערך הנתונים יועבר כקלט למשימת האימון שלנו. בקוד האימון שלנו תהיה גישה למשתנה הסביבה כדי לגשת למערך הנתונים המנוהל הזה.
כך מגדירים משימת אימון בהתאמה אישית:
- כתיבת מודל Scikit-learn
DecisionTreeClassifierלסיווג סוגי שעועית בנתונים שלנו - אורזים את קוד האימון בקונטיינר 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 נכלול את כל הפקודות שנדרשות להרצת התמונה. הסקריפט יתקין את כל הספריות שבהן אנחנו משתמשים ויגדיר את נקודת הכניסה לקוד ההדרכה. פותחים את קובץ ה-Dockerfile שיצרתם ומוסיפים את השורות הבאות:
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")
אחר כך חוזרים למחברת ומריצים את הפקודה הבאה כדי להחליף את 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 אל הקונטיינר הזה.
חוזרים לטרמינל, ובספריית הבסיס 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. פיתוח צינור עיבוד נתונים באמצעות רכיבים מוכנים מראש
עכשיו, אחרי שקוד האימון שלנו נמצא בענן, אנחנו מוכנים להפעיל אותו מהפייפליין. הפייפליין שנגדיר ישתמש בשלושה רכיבים מוכנים מראש מהספרייה google_cloud_pipeline_components שהתקנו קודם. הרכיבים המוגדרים מראש האלה מפשטים את הקוד שאנחנו צריכים לכתוב כדי להגדיר את צינור העיבוד, ויאפשרו לנו להשתמש בשירותי Vertex AI כמו אימון מודלים וחיזוי באצווה.
כך יפעל צינור המכירות בן שלושת השלבים:
- יצירת מערך נתונים מנוהל ב-Vertex AI
- הפעלת משימת אימון ב-Vertex 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. אם לוחצים על הקישור הבא של קבוצת הנתונים בקטע 'צינורות' במסוף:
מערך הנתונים יופיע ב-Vertex AI, כולל קישור למקור הנתונים ב-BigQuery ומידע על העמודות השונות במערך הנתונים. אחרי שמעלים מערך נתונים מנוהל ל-Vertex AI, אפשר להשתמש בו כדי לאמן מודל AutoML או מודל בהתאמה אישית.
במשימות של מודלים בהתאמה אישית שמשתמשים במערכי נתונים מנוהלים, מערכת Vertex AI מעבירה משתני סביבה מיוחדים למשימות האימון ומטפלת בפיצול הנתונים למערכי אימון ובדיקה. נשתמש בזה בשלב הבא של הצינור.
שלב 2 בצינור עיבוד הנתונים: אימון מודל ב-Vertex AI Training
בזמן שמשימת האימון בהתאמה אישית פועלת, אפשר ללחוץ כדי לראות את היומנים ישירות במסוף Vertex Pipelines:
אפשר גם לראות פרטים על משימת האימון המותאמת אישית בלוח הבקרה של Training ב-Vertex AI. כשפעולת האימון תסתיים, משאב מסוג Model ייווצר ב-Vertex AI. לאחר מכן נוכל לפרוס את המודל הזה לנקודת קצה כדי לקבל חיזויים אונליין, או ליצור משימת חיזוי באצווה, כפי שנעשה בשלב הבא של הפייפליין.
שלב 3 בצינור: הפעלת משימת חיזוי אצווה במודל שלנו
לבסוף, הפייפליין שלנו יקבל תחזיות לגבי הדוגמאות שהעברנו באמצעות קובץ CSV. כשמשימת החיזוי באצווה מסתיימת, מערכת Vertex AI כותבת קובץ CSV למיקום שציינו ב-Cloud Storage. כשהשלב הזה בפייפליין מתחיל לפעול, אפשר לעבור אל הקטע 'חיזוי של Vertex AI Batch' במסוף 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 Console, עוברים אל Storage, בוחרים את הקטגוריה ולוחצים על Delete:
