1. סקירה כללית
בשיעור ה-Lab הזה תלמדו איך לנתח מטא-נתונים מהפעלות של Vertex Pipelines באמצעות Vertex ML Metadata.
מה לומדים
נסביר לכם איך:
- להשתמש ב-Kubeflow Pipelines SDK כדי לפתח צינור עיבוד נתונים של למידת מכונה שיוצר מערך נתונים ב-Vertex AI, ולאמן ופורס מודל Scikit-learn בהתאמה אישית על מערך הנתונים הזה
- לכתוב רכיבים של צינור עיבוד נתונים בהתאמה אישית שיוצרים ארטיפקטים ומטא-נתונים
- השוואה בין הפעלות של Vertex Pipelines במסוף Cloud וגם באופן פרוגרמטי
- מעקב אחר השושלת של ארטיפקטים שנוצרים על ידי צינור עיבוד נתונים
- שליחת שאילתות למטא-נתונים של הרצת צינור עיבוד הנתונים
העלות הכוללת של הפעלת שיעור ה-Lab הזה ב-Google Cloud היא כ-$2.
2. מבוא ל-Vertex AI
בשיעור ה-Lab הזה נעשה שימוש במוצר ה-AI החדש ביותר שזמין ב-Google Cloud. Vertex AI משלב את הצעות למידת המכונה ב-Google Cloud ליצירת חוויית פיתוח חלקה. בעבר, ניתן היה לגשת למודלים שעברו אימון באמצעות AutoML ומודלים בהתאמה אישית דרך שירותים נפרדים. המוצר החדש משלב את כל ממשקי ה-API האלה בממשק API אחד, לצד מוצרים חדשים אחרים. תוכלו גם להעביר פרויקטים קיימים ל-Vertex AI.
בנוסף לאימון מודלים ולשירותי פריסה, Vertex AI כולל גם מגוון מוצרי MLOps, כולל Vertex Pipelines, ML Metadata, Model Monitoring, Feature Store ועוד. אתם יכולים לראות את כל המוצרים של Vertex AI בתרשים הבא.
שיעור ה-Lab הזה מתמקד ב-Vertex Pipelines וב-Vertex ML Metadata.
אם יש לכם משוב על Vertex AI, עיינו בדף התמיכה.
למה צינורות עיבוד נתונים של למידת מכונה שימושיים?
לפני שנצלול לעומק, נסביר למה כדאי להשתמש בצינור עיבוד נתונים. נניח שאתם מפתחים תהליך עבודה של למידת מכונה שכולל עיבוד נתונים, אימון מודל, כוונון היפר-פרמטרים, הערכה ופריסת מודלים. לכל אחד מהשלבים האלה עשויים להיות יחסי תלות שונים, ואם תתייחסו לתהליך העבודה כולו כמונולית, הדבר עלול להיות קשה יותר. כשתתחילו לבצע התאמה לעומס של תהליך למידת המכונה (ML), יכול להיות שתרצו לשתף עם אחרים בצוות את תהליך העבודה של למידת המכונה כדי שהם יוכלו להריץ אותו ולתרום קוד. ללא תהליך מהימן וניתן לשחזור, הדבר עלול להיות קשה. בצינורות עיבוד נתונים, כל שלב בתהליך למידת המכונה הוא קונטיינר משלו. כך תוכלו לפתח שלבים באופן עצמאי ולעקוב אחרי הקלט והפלט מכל שלב בדרך של שחזור. תוכלו גם לתזמן או להפעיל הפעלות של צינור עיבוד הנתונים על סמך אירועים אחרים בסביבת הענן שלכם, כמו הפעלת צינור עיבוד נתונים כשיש נתוני אימון חדשים.
The tl;dr: צינורות עיבוד נתונים עוזרים לכם לבצע אוטומציה ולשחזר את תהליך העבודה שלכם בלמידת מכונה.
3. הגדרה של סביבת הענן
כדי להריץ את ה-Codelab הזה צריך פרויקט ב-Google Cloud Platform שהחיוב מופעל בו. כדי ליצור פרויקט, יש לפעול לפי ההוראות האלה.
הפעלת 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
פלט הפקודה
Credentialed Accounts
ACTIVE ACCOUNT
* <my_account>@<my_domain.com>
To set the active account, run:
$ gcloud config set account `ACCOUNT`
מריצים את הפקודה הבאה ב-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
הפעלת ממשקי 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.
יצירת קטגוריה של 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
יצירת מכונה של Vertex AI Workbench
בקטע Vertex AI במסוף Cloud, לוחצים על Workbench:
משם, בתוך מחברות בניהול המשתמשים, לוחצים על מחברת חדשה:
לאחר מכן בוחרים בסוג המכונה TensorFlow Enterprise 2.3 (עם LTS) ללא GPUs:
משתמשים באפשרויות ברירת המחדל ואז לוחצים על יצירה.
פותחים את ה-notebook.
אחרי שיוצרים את המכונה, בוחרים באפשרות Open JupyterLab:
4. הגדרה של Vertex Pipelines
יש כמה ספריות נוספות שנצטרך להתקין כדי להשתמש ב-Vertex Pipelines:
- Kubeflow Pipelines: זה ה-SDK שבו נשתמש כדי לפתח את צינור עיבוד הנתונים שלנו. ב-Vertex Pipelines יש תמיכה בצינורות עיבוד נתונים שפועלים ב-Kubeflow Pipelines וגם ב-TFX.
- Vertex AI SDK: ערכת ה-SDK הזו מבצעת אופטימיזציה של חוויית הקריאה ל-Vertex AI API. נשתמש בו כדי להריץ את צינור עיבוד הנתונים שלנו על Vertex AI.
יצירת notebook ב-Python והתקנת ספריות
קודם כול, בתפריט מרכז האפליקציות במכונה של ה-Notebook, יוצרים notebook על ידי בחירה ב-Python 3:
כדי להתקין את שני השירותים שבהם נשתמש בשיעור ה-Lab הזה, קודם צריך להגדיר את דגל המשתמש בתא ב-notebook:
USER_FLAG = "--user"
לאחר מכן מריצים את הפקודה הבאה מה-notebook:
!pip3 install {USER_FLAG} google-cloud-aiplatform==1.7.0
!pip3 install {USER_FLAG} kfp==1.8.9
לאחר התקנת החבילות, תצטרכו להפעיל מחדש את הליבה:
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__))"
לאחר מכן מוודאים שהגרסה של Vertex AI SDK היא 1.6.2 ומעלה:
!pip list | grep aiplatform
הגדרת מזהה הפרויקט והקטגוריה
בשיעור ה-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"
ייבוא ספריות
צריך להוסיף את הפריטים הבאים כדי לייבא את הספריות שבהן נשתמש ב-Codelab הזה:
import matplotlib.pyplot as plt
import pandas as pd
from kfp.v2 import compiler, dsl
from kfp.v2.dsl import pipeline, component, Artifact, Dataset, Input, Metrics, Model, Output, InputPath, OutputPath
from google.cloud import aiplatform
# We'll use this namespace for metadata querying
from google.cloud import aiplatform_v1
הגדירו קבועים
הדבר האחרון שאנחנו צריכים לעשות לפני פיתוח צינור עיבוד הנתונים שלנו הוא להגדיר משתנים קבועים. 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. יצירת צינור עיבוד נתונים תלת-שלבי עם רכיבים מותאמים אישית
שיעור ה-Lab הזה יתמקד בהבנת מטא-נתונים מהפעלות של צינורות עיבוד נתונים. לשם כך, אנחנו זקוקים לצינור עיבוד נתונים שירוץ ב-Vertex Pipelines, שם נתחיל. כאן נגדיר צינור עיבוד נתונים תלת-שלבי עם הרכיבים המותאמים אישית הבאים:
get_dataframe: אחזור נתונים מטבלה ב-BigQuery והמרתם ל-Pandas DataFrametrain_sklearn_model: שימוש ב-Pandas DataFrame כדי לאמן ולייצא מודל Scikit Learning, יחד עם מדדים מסוימיםdeploy_model: פריסה של מודל Scikit Learning המיוצא לנקודת קצה ב-Vertex AI
בצינור עיבוד הנתונים הזה נשתמש במערך הנתונים של שעועית אמריקאית של UCI, מהסוגים הבאים: KOKLU, M. ו-OZKAN, I.A, (2020), "סיווג רב-סיווגי של שעועית יבשה באמצעות ראייה ממוחשבת וטכניקות למידת מכונה".בליחולים, 174, 105507. DOI.
זה מערך נתונים של טבלה, ובצינור עיבוד הנתונים שלנו נשתמש במערך הנתונים כדי לאמן, להעריך ולפרוס מודל Scikit-learn שמסווג שעועית לאחד מ-7 סוגים על סמך המאפיינים שלהם. קדימה, מתחילים לתכנת!
יצירת רכיבים המבוססים על פונקציות של Python
באמצעות KFP SDK אנחנו יכולים ליצור רכיבים על סמך פונקציות Python. נשתמש בו ל-3 הרכיבים בצינור עיבוד הנתונים הזה.
הורדת נתוני BigQuery והמרה לקובץ CSV
קודם כל נבנה את הרכיב get_dataframe:
@component(
packages_to_install=["google-cloud-bigquery", "pandas", "pyarrow", "db-dtypes"],
base_image="python:3.9",
output_component_file="create_dataset.yaml"
)
def get_dataframe(
bq_table: str,
output_data_path: OutputPath("Dataset")
):
from google.cloud import bigquery
import pandas as pd
import os
project_number = os.environ["CLOUD_ML_PROJECT_ID"]
bqclient = bigquery.Client(project=project_number)
table = bigquery.TableReference.from_string(
bq_table
)
rows = bqclient.list_rows(
table
)
dataframe = rows.to_dataframe(
create_bqstorage_client=True,
)
dataframe = dataframe.sample(frac=1, random_state=2)
dataframe.to_csv(output_data_path)
בואו נבחן מקרוב את מה שקורה ברכיב הזה:
- כלי העיצוב
@componentמרכיב את הפונקציה הזו לרכיב כשצינור עיבוד הנתונים פועל. הקוד הזה ישמש אותך בכל פעם שכותבים רכיב מותאם אישית. - הפרמטר
base_imageמציין את קובץ האימג' בקונטיינר שבו הרכיב הזה ישתמש. - ברכיב הזה ייעשה שימוש בכמה ספריות Python, שצוינו באמצעות הפרמטר
packages_to_install. - הפרמטר
output_component_fileהוא אופציונלי ומציין את קובץ ה-yaml שבו צריך לכתוב את הרכיב שעבר הידור. אחרי שמריצים את התא, הקובץ אמור להופיע במכונה של ה-notebook. כדי לשתף את הרכיב הזה עם מישהו, אפשר לשלוח לו את קובץ ה-yaml שנוצר ולבקש ממנו לטעון אותו עם הפרטים הבאים:
# This is optional, it shows how to load a component from a yaml file
# dataset_component = kfp.components.load_component_from_file('./create_dataset.yaml')
- בשלב הבא, הרכיב הזה משתמש בספריית הלקוח של BigQuery Python כדי להוריד את הנתונים שלנו מ-BigQuery ל-Pandas DataFrame, ואז יוצר ארטיפקט של הנתונים האלה כקובץ CSV. זה יועבר כקלט לרכיב הבא שלנו
יצירת רכיב לאימון מודל למידת Scikit
ברכיב הזה ניקח את קובץ ה-CSV שיצרנו קודם ונשתמש בו כדי לאמן מודל עץ החלטות של Scikit-learn. הרכיב הזה מייצא את מודל ה-Scikit שנוצר, יחד עם ארטיפקט Metrics שכולל את הדיוק של המודל, המסגרת והגודל של מערך הנתונים ששימש לאימון שלו:
@component(
packages_to_install=["sklearn", "pandas", "joblib", "db-dtypes"],
base_image="python:3.9",
output_component_file="beans_model_component.yaml",
)
def sklearn_train(
dataset: Input[Dataset],
metrics: Output[Metrics],
model: Output[Model]
):
from sklearn.tree import DecisionTreeClassifier
from sklearn.metrics import roc_curve
from sklearn.model_selection import train_test_split
from joblib import dump
import pandas as pd
df = pd.read_csv(dataset.path)
labels = df.pop("Class").tolist()
data = df.values.tolist()
x_train, x_test, y_train, y_test = train_test_split(data, labels)
skmodel = DecisionTreeClassifier()
skmodel.fit(x_train,y_train)
score = skmodel.score(x_test,y_test)
print('accuracy is:',score)
metrics.log_metric("accuracy",(score * 100.0))
metrics.log_metric("framework", "Scikit Learn")
metrics.log_metric("dataset_size", len(df))
dump(skmodel, model.path + ".joblib")
הגדרת רכיב להעלאה ופריסה של המודל ל-Vertex AI
לבסוף, הרכיב האחרון תיקח את המודל שעבר אימון מהשלב הקודם, יעלה אותו ל-Vertex AI ונפרס אותו בנקודת קצה:
@component(
packages_to_install=["google-cloud-aiplatform"],
base_image="python:3.9",
output_component_file="beans_deploy_component.yaml",
)
def deploy_model(
model: Input[Model],
project: str,
region: str,
vertex_endpoint: Output[Artifact],
vertex_model: Output[Model]
):
from google.cloud import aiplatform
aiplatform.init(project=project, location=region)
deployed_model = aiplatform.Model.upload(
display_name="beans-model-pipeline",
artifact_uri = model.uri.replace("model", ""),
serving_container_image_uri="us-docker.pkg.dev/vertex-ai/prediction/sklearn-cpu.0-24:latest"
)
endpoint = deployed_model.deploy(machine_type="n1-standard-4")
# Save data to the output params
vertex_endpoint.uri = endpoint.resource_name
vertex_model.uri = deployed_model.resource_name
אנחנו משתמשים ב-Vertex AI SDK כדי להעלות את המודל באמצעות מאגר תגים שנוצר מראש לחיזוי. לאחר מכן, המודל פורס את המודל בנקודת קצה ומחזיר את מזהי ה-URI גם למשאבים של המודל וגם למשאבים של נקודת הקצה. בהמשך Codelab זה תלמדו על המשמעות של החזרת נתונים אלה כארטיפקטים.
הגדרה והרכבת של צינור עיבוד הנתונים
עכשיו, אחרי שהגדרנו את שלושת הרכיבים, ניצור את ההגדרה של צינור עיבוד הנתונים. כאן מוסבר איך ארטיפקטים של קלט ופלט עוברים בין השלבים:
@pipeline(
# Default pipeline root. You can override it when submitting the pipeline.
pipeline_root=PIPELINE_ROOT,
# A name for the pipeline.
name="mlmd-pipeline",
)
def pipeline(
bq_table: str = "",
output_data_path: str = "data.csv",
project: str = PROJECT_ID,
region: str = REGION
):
dataset_task = get_dataframe(bq_table)
model_task = sklearn_train(
dataset_task.output
)
deploy_task = deploy_model(
model=model_task.outputs["model"],
project=project,
region=region
)
הקוד הבא ייצור קובץ JSON שבו תשתמשו כדי להפעיל את צינור עיבוד הנתונים:
compiler.Compiler().compile(
pipeline_func=pipeline, package_path="mlmd_pipeline.json"
)
התחלת שתי הפעלות של צינור עיבוד נתונים
בשלב הבא נתחיל שתי פעילויות בצינור עיבוד הנתונים שלנו. קודם נגדיר חותמת זמן שתשמש למזהי המשימות בצינור עיבוד הנתונים:
from datetime import datetime
TIMESTAMP = datetime.now().strftime("%Y%m%d%H%M%S")
חשוב לזכור שצינור עיבוד הנתונים שלנו מקבל פרמטר אחד כשאנחנו מריצים אותו: ה-bq_table שאנחנו רוצים להשתמש בו לנתוני אימון. הפעלת צינור עיבוד הנתונים הזו תשתמש בגרסה קטנה יותר של מערך הנתונים של שעועית:
run1 = aiplatform.PipelineJob(
display_name="mlmd-pipeline",
template_path="mlmd_pipeline.json",
job_id="mlmd-pipeline-small-{0}".format(TIMESTAMP),
parameter_values={"bq_table": "sara-vertex-demos.beans_demo.small_dataset"},
enable_caching=True,
)
בשלב הבא, יוצרים הפעלה נוספת של צינור עיבוד נתונים באמצעות גרסה גדולה יותר של אותו מערך נתונים.
run2 = aiplatform.PipelineJob(
display_name="mlmd-pipeline",
template_path="mlmd_pipeline.json",
job_id="mlmd-pipeline-large-{0}".format(TIMESTAMP),
parameter_values={"bq_table": "sara-vertex-demos.beans_demo.large_dataset"},
enable_caching=True,
)
לבסוף, מתחילים להריץ את צינורות עיבוד הנתונים בשתי ההפעלות. מומלץ לעשות זאת בשני תאי notebook נפרדים כדי לראות את הפלט של כל הרצה.
run1.submit()
לאחר מכן, מתחילים את ההפעלה השנייה:
run2.submit()
אחרי הרצת התא הזה, יופיע קישור לצפייה בכל צינור עיבוד נתונים במסוף Vertex AI. אפשר לפתוח את הקישור הזה כדי לראות פרטים נוספים על צינור עיבוד הנתונים שלכם:
כשהתהליך יסתיים (צינור עיבוד הנתונים הזה נמשך בין 10 ל-15 דקות בכל הפעלה), תראו משהו כזה:
עכשיו, אחרי שסיימתם שתי הפעלות של צינור עיבוד נתונים, אתם מוכנים לבחון מקרוב את ארטיפקטים, המדדים והשתלשלות של צינורות עיבוד הנתונים.
6. הבנת ארטיפקטים של צינור עיבוד נתונים ושושלת
בתרשים של צינור עיבוד הנתונים, תוכלו לראות תיבות קטנות אחרי כל שלב. אלה ארטיפקטים, או פלט שנוצר משלב של צינור עיבוד נתונים. יש הרבה סוגים של פריטי מידע שנוצרו בתהליך הפיתוח (Artifact). בצינור עיבוד הנתונים הספציפי הזה יש לנו מערך נתונים, מדדים, מודל ופריטי מידע שנוצרו בתהליך הפיתוח (Artifact) של נקודות הקצה. לוחצים על פס ההזזה Expand Artifacts (הרחבת פריטי מידע) בחלק העליון של ממשק המשתמש כדי לראות פרטים נוספים על כל אחד מהפריטים:
בלחיצה על פריט מידע שנוצר בתהליך הפיתוח (Artifact) יוצגו פרטים נוספים לגביו, כולל ה-URI שלו. לדוגמה, לחיצה על ארטיפקט vertex_endpoint תציג את ה-URI שבו תוכלו למצוא את נקודת הקצה שנפרסה במסוף Vertex AI:
ארטיפקט Metrics מאפשר להעביר מדדים מותאמים אישית שמשויכים לשלב מסוים בצינור עיבוד הנתונים. ברכיב sklearn_train בצינור עיבוד הנתונים שלנו תיעדנו מדדים לגבי דיוק המודל, המסגרת וגודל מערך הנתונים. אפשר ללחוץ על פריט המידע שנוצר בתהליך הפיתוח (Artifact) של המדדים כדי לראות את הפרטים האלה:
לכל פריט מידע שנוצר בתהליך הפיתוח (Artifact) יש שושלת, שמתארת את פריטי המידע האחרים שהוא מקושר אליהם. לוחצים שוב על ארטיפקט vertex_endpoint של צינור עיבוד הנתונים ואז לוחצים על הלחצן View Lineage:
הפעולה הזו תפתח כרטיסייה חדשה שבה יופיעו כל פריטי המידע שנוצרו בתהליך הפיתוח (Artifact) שמקושרים לנכס שנבחר. תרשים ההשתלשלות ייראה בערך כך:
כאן מוצגים המודל, המדדים ומערך הנתונים שמשויכים לנקודת הקצה הזו. למה זה שימושי? יכול להיות שיש לכם מודל שנפרס בכמה נקודות קצה, או שאתם צריכים לדעת איזה מערך נתונים ספציפי משמש לאימון המודל שנפרס לנקודת הקצה שעליה אתם מסתכלים. תרשים ההשתלשלות עוזר לכם להבין כל פריט מידע שנוצר בתהליך הפיתוח (Artifact) בהקשר של שאר מערכת למידת המכונה שלכם. אפשר גם לגשת לשושלת באופן פרוגרמטי, כפי שמתואר בהמשך ב-Codelab הזה.
7. תשוו בין הפעלות של צינורות עיבוד נתונים
רוב הסיכויים שצינור עיבוד נתונים אחד יופעל מספר פעמים, אולי עם פרמטרים שונים של קלט, נתונים חדשים או אנשים מכל הצוות שלך. כדי לעקוב אחרי פעילות של צינורות עיבוד נתונים, אפשר להשוות ביניהם לפי מדדים שונים. בקטע הזה נציג שתי דרכים להשוואה בין הפעלות.
השוואת הפעלות בממשק המשתמש של Pipelines
במסוף Cloud, נכנסים למרכז הבקרה של Pipelines. תראו סקירה כללית של כל הרצה של צינור עיבוד נתונים שביצעתם. בודקים את שתי ההפעלות האחרונות ולוחצים על הלחצן השוואה בחלק העליון:
פעולה זו תעביר אותנו לדף שבו ניתן להשוות בין פרמטרים וערכים של קלט לכל אחת מההפעלות שבחרנו. בשתי הריצות האלה, שימו לב לטבלאות השונות של BigQuery, לגדלים של מערכי הנתונים ולערכי הדיוק השונים:
הפונקציונליות הזו של ממשק המשתמש מאפשרת להשוות בין יותר משתי הפעלות, ואפילו הרצה של צינורות עיבוד נתונים שונים.
השוואת הפעלות עם Vertex AI SDK
במקרים רבים של הפעלות של צינורות עיבוד נתונים, כדאי שתהיה לכם דרך לקבל את מדדי ההשוואה האלה באופן פרוגרמטי, כדי לחקור לעומק את פרטי המדדים וליצור תצוגות חזותיות.
אפשר להשתמש ב-method aiplatform.get_pipeline_df() כדי לגשת למטא-נתונים של ההרצה. כאן נקבל מטא-נתונים לשתי ההפעלות האחרונות של אותו צינור עיבוד נתונים ונטענו אותו ל-Pandas DataFrame. הפרמטר pipeline כאן מתייחס לשם שנתתם לצינור עיבוד הנתונים שלנו בהגדרת צינור עיבוד הנתונים שלנו:
df = aiplatform.get_pipeline_df(pipeline="mlmd-pipeline")
df
כשתדפיסו את ה-DataFrame, תראו משהו כזה:
הפעלנו כאן רק את צינור עיבוד הנתונים פעמיים, אבל אפשר לדמיין כמה מדדים יהיו לך אם יהיו לך יותר הפעלות. בשלב הבא ניצור תצוגה חזותית מותאמת אישית באמצעות matplotlib כדי לראות את הקשר בין דיוק המודל שלנו לבין כמות הנתונים ששימשו לאימון.
מריצים את הפקודה הבאה בתא notebook חדש:
plt.plot(df["metric.dataset_size"], df["metric.accuracy"],label="Accuracy")
plt.title("Accuracy and dataset size")
plt.legend(loc=4)
plt.show()
אתם אמורים לראות משהו כזה:
8. שליחת שאילתות למדדים של צינור עיבוד הנתונים
בנוסף לקבלת DataFrame של כל מדדי צינורות עיבוד הנתונים, יכול להיות שתרצו לשלוח שאילתות באופן פרוגרמטי של ארטיפקטים שנוצרו במערכת למידת המכונה שלכם. משם תוכלו ליצור מרכז בקרה מותאם אישית או לאפשר למשתמשים אחרים בארגון לקבל פרטים על פריטי מידע ספציפיים.
מתבצע אחזור של כל פריטי המידע שנוצרו בתהליך הפיתוח (Artifact) של המודלים
כדי להריץ שאילתות על פריטי מידע שנוצרו בתהליך הפיתוח (Artifact) באופן הזה, ניצור MetadataServiceClient:
API_ENDPOINT = "{}-aiplatform.googleapis.com".format(REGION)
metadata_client = aiplatform_v1.MetadataServiceClient(
client_options={
"api_endpoint": API_ENDPOINT
}
)
בשלב הבא, נשלח בקשת list_artifacts לנקודת הקצה הזו ונעביר מסנן שמציין אילו פריטי מידע נרצה לקבל בתשובה שלנו. קודם כול, נציג את כל פריטי המידע שנוצרו בתהליך הפיתוח (Artifact) בפרויקט שהם מודלים. כדי לעשות זאת, מריצים את הפקודה הבאה ב-notebook:
MODEL_FILTER="schema_title = \"system.Model\""
artifact_request = aiplatform_v1.ListArtifactsRequest(
parent="projects/{0}/locations/{1}/metadataStores/default".format(PROJECT_ID, REGION),
filter=MODEL_FILTER
)
model_artifacts = metadata_client.list_artifacts(artifact_request)
תגובת model_artifacts שמתקבלת מכילה אובייקט שניתן לחזור עליו לכל ארטיפקט של המודל בפרויקט, יחד עם המטא-נתונים המשויכים לכל מודל.
סינון אובייקטים והצגה ב-DataFrame
יעזור לנו יותר לדמיין את השאילתה של פריט המידע שנוצר בתהליך הפיתוח (Artifact) שמתקבלת. בשלב הבא נאסוף את כל פריטי המידע שנוצרו בתהליך הפיתוח (Artifact) שנוצרו אחרי 10 באוגוסט 2021 במצב LIVE. לאחר שנריץ את הבקשה הזו, נציג את התוצאות ב-Pandas DataFrame. קודם מבצעים את הבקשה:
LIVE_FILTER = "create_time > \"2021-08-10T00:00:00-00:00\" AND state = LIVE"
artifact_req = {
"parent": "projects/{0}/locations/{1}/metadataStores/default".format(PROJECT_ID, REGION),
"filter": LIVE_FILTER
}
live_artifacts = metadata_client.list_artifacts(artifact_req)
לאחר מכן, מציגים את התוצאות ב-DataFrame:
data = {'uri': [], 'createTime': [], 'type': []}
for i in live_artifacts:
data['uri'].append(i.uri)
data['createTime'].append(i.create_time)
data['type'].append(i.schema_title)
df = pd.DataFrame.from_dict(data)
df
תראו משהו כזה:
אפשר גם לסנן פריטי מידע שנוצרו בתהליך הפיתוח (Artifact) לפי קריטריונים אחרים, בנוסף למה שניסיתם כאן.
זהו, סיימתם את שיעור ה-Lab!
🎉 כל הכבוד! 🎉
למדתם איך להשתמש ב-Vertex AI כדי:
- להשתמש ב-Kubeflow Pipelines SDK כדי לפתח צינור עיבוד נתונים של למידת מכונה שיוצר מערך נתונים ב-Vertex AI, ולאמן ופורס מודל Scikit-learn בהתאמה אישית על מערך הנתונים הזה
- לכתוב רכיבים של צינור עיבוד נתונים בהתאמה אישית שיוצרים ארטיפקטים ומטא-נתונים
- השוואה בין הפעלות של Vertex Pipelines במסוף Cloud וגם באופן פרוגרמטי
- מעקב אחר השושלת של ארטיפקטים שנוצרים על ידי צינור עיבוד נתונים
- שליחת שאילתות למטא-נתונים של הרצת צינור עיבוד הנתונים
כדי לקבל מידע נוסף על החלקים השונים ב-Vertex, אתם יכולים לעיין במסמכי העזרה.
9. הסרת המשאבים
כדי שלא תחויבו, מומלץ למחוק את המשאבים שנוצרו בשיעור ה-Lab הזה.
עצירה או מחיקה של מופע של notebooks
אם אתם רוצים להמשיך להשתמש ב-notebook שיצרתם בשיעור ה-Lab הזה, מומלץ להשבית אותו כשהוא לא בשימוש. בממשק המשתמש של Notebooks במסוף Cloud, בוחרים את ה-notebook ואז לוחצים על Stop. כדי למחוק את המכונה לגמרי, בוחרים באפשרות מחיקה:
מחיקת נקודות הקצה של Vertex AI
כדי למחוק את נקודת הקצה שפרסתם, עוברים לקטע Endpoints במסוף Vertex AI ולוחצים על סמל המחיקה:
מחיקת הקטגוריה של Cloud Storage
כדי למחוק את קטגוריית האחסון, באמצעות תפריט הניווט במסוף Cloud, עוברים אל Storage (אחסון), בוחרים את הקטגוריה ולוחצים על סמל המחיקה:
