שימוש במטא-נתונים של Vertex ML עם צינורות עיבוד נתונים

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

בשיעור ה-Lab הזה תלמדו איך לנתח מטא-נתונים מהרצות של Vertex Pipelines באמצעות Vertex ML Metadata.

מה לומדים

במאמר הזה נסביר איך:

  • שימוש ב-Kubeflow Pipelines SDK כדי ליצור צינור ML שיוצר מערך נתונים ב-Vertex AI, ומאמן ופורס מודל Scikit-learn בהתאמה אישית במערך הנתונים הזה
  • כתיבת רכיבים מותאמים אישית של צינורות שמייצרים ארטיפקטים ומטא-נתונים
  • השוואה בין הרצות של צינורות עיבוד נתונים ב-Vertex, גם במסוף Cloud וגם באופן פרוגרמטי
  • מעקב אחר שרשרת המקור של פריטי מידע שנוצרו על ידי צינור עיבוד נתונים
  • שאילתה על המטא-נתונים של הפעלת צינור עיבוד הנתונים

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

2. מבוא ל-Vertex AI

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

בנוסף לשירותי אימון ופריסה של מודלים, Vertex AI כולל גם מגוון מוצרי MLOps, כולל Vertex Pipelines,‏ ML Metadata,‏ Model Monitoring,‏ Feature Store ועוד. בתרשים שלמטה אפשר לראות את כל המוצרים של Vertex AI.

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

ה-Lab הזה מתמקד ב-Vertex Pipelines וב-Vertex ML Metadata.

אם יש לכם משוב על Vertex AI, תוכלו להיעזר בדף התמיכה.

למה צינורות עיבוד נתונים של למידת מכונה שימושיים?

לפני שמתחילים, כדאי להבין למה כדאי להשתמש בצינור. נניח שאתם בונים תהליך עבודה של למידת מכונה שכולל עיבוד נתונים, אימון מודל, כוונון היפר-פרמטרים, הערכה ופריסת מודל. לכל אחד מהשלבים האלה יכולות להיות תלויות שונות, וזה יכול להיות מסובך אם מתייחסים לכל תהליך העבודה כמקשה אחת. כשמתחילים להרחיב את תהליך למידת המכונה, כדאי לשתף את תהליך העבודה של למידת המכונה עם חברי צוות אחרים כדי שהם יוכלו להריץ אותו ולתרום קוד. ללא תהליך אמין שניתן לשחזור, זה יכול להיות קשה. בצינורות, כל שלב בתהליך למידת המכונה הוא קונטיינר משלו. כך תוכלו לפתח שלבים בנפרד ולעקוב אחרי הקלט והפלט מכל שלב בצורה שניתנת לשחזור. אפשר גם לתזמן או להפעיל הרצות של צינור הנתונים על סמך אירועים אחרים בסביבת Cloud, כמו הפעלה של הרצת צינור נתונים כשנתוני אימון חדשים זמינים.

בקיצור: צינורות עיבוד נתונים עוזרים לכם ליצור אוטומציה של תהליך העבודה של למידת המכונה ולשחזר אותו.

3. הגדרה של סביבת ענן

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

הפעלת Cloud Shell

בשיעור ה-Lab הזה תעבדו בסשן של Cloud Shell, שהוא מתורגמן פקודות שמתארח במכונה וירטואלית שפועלת בענן של Google. אפשר להריץ את הקטע הזה בקלות במחשב שלכם, אבל השימוש ב-Cloud Shell מאפשר לכולם גישה לחוויה שניתנת לשחזור בסביבה עקבית. אחרי הסדנה, אתם מוזמנים לנסות שוב את החלק הזה במחשב שלכם.

מתן הרשאה ל-Cloud Shell

הפעלת Cloud Shell

בפינה הימנית העליונה של Cloud Console, לוחצים על הלחצן Activate Cloud Shell (הפעלת Cloud Shell):

הפעלת Cloud Shell

אם זו הפעם הראשונה שאתם מפעילים את Cloud Shell, יוצג לכם מסך ביניים (מתחת לקו הקיפול) עם תיאור של הכלי. במקרה כזה, לוחצים על המשך (והמסך הזה לא יוצג לכם יותר). כך נראה המסך החד-פעמי:

הגדרה של Cloud Shell

הקצאת המשאבים והחיבור ל-Cloud Shell נמשכים רק כמה רגעים.

Cloud Shell init

המכונה הווירטואלית הזו כוללת את כל הכלים שדרושים למפתחים. יש בה ספריית בית בנפח מתמיד של 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 שמכיל את השם של פרויקט בענן הנוכחי. נשתמש בזה במקומות שונים במהלך שיעור ה-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, אבל אתם יכולים להשתמש באזור אחר (פשוט צריך להחליף אותו בכל מקום בשיעור). אם כבר יש לכם קטגוריה, אתם יכולים לדלג על השלב הזה.

כדי ליצור קטגוריה, מריצים את הפקודות הבאות במסוף 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

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

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

תפריט Vertex AI

משם, בnotebooks בניהול המשתמשים, לוחצים על New Notebook:

יצירת מחברת חדשה

לאחר מכן בוחרים את סוג האינסטנס TensorFlow Enterprise 2.3 (with LTS) without GPUs:

מופע TFE

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

פתיחת Notebook

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

פתיחת Notebook

4. הגדרה של Vertex Pipelines

כדי להשתמש ב-Vertex Pipelines, צריך להתקין עוד כמה ספריות:

  • ‫Kubeflow Pipelines: זהו ה-SDK שבו נשתמש כדי לבנות את צינור עיבוד הנתונים. ב-Vertex Pipelines יש תמיכה בהרצת צינורות עיבוד נתונים שנבנו באמצעות Kubeflow Pipelines או TFX.
  • ‫Vertex AI SDK: ערכת ה-SDK הזו מייעלת את החוויה של קריאה ל-Vertex AI API. נשתמש בו כדי להריץ את צינור העיבוד ב-Vertex AI.

יצירת מחברת Python והתקנת ספריות

קודם כל, בתפריט של מרכז האפליקציות במופע Notebook, יוצרים מחברת על ידי בחירה באפשרות Python 3:

יצירת מחברת Python3

כדי להתקין את שני השירותים שבהם נשתמש בשיעור ה-Lab הזה, קודם צריך להגדיר את דגל המשתמש בתא של מחברת:

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. יצירת צינור של 3 שלבים עם רכיבים בהתאמה אישית

ה-Lab הזה מתמקד בהבנת מטא-נתונים מהרצות של צינורות נתונים. כדי לעשות את זה, נצטרך צינור עיבוד נתונים להרצה ב-Vertex Pipelines, וזה המקום שבו נתחיל. במאמר הזה נגדיר צינור של 3 שלבים עם הרכיבים המותאמים אישית הבאים:

  • ‫get_dataframe: אחזור נתונים מטבלה ב-BigQuery והמרה שלהם ל-Pandas DataFrame
  • ‫train_sklearn_model: שימוש ב-Pandas DataFrame כדי לאמן ולייצא מודל Scikit Learn, יחד עם כמה מדדים
  • ‫deploy_model: פריסת מודל Scikit Learn שיוצא לנקודת קצה ב-Vertex AI

בצינור הזה נשתמש במערך הנתונים של שעועית יבשה מ-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.

זהו מערך נתונים טבלאי, ובצינור הנתונים שלנו נשתמש במערך הנתונים כדי לאמן, להעריך ולפרוס מודל 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 שאליו ייכתב הרכיב שעבר קומפילציה. אחרי שמריצים את התא, הקובץ אמור להיכתב למופע של המחברת. אם רוצים לשתף את הרכיב הזה עם מישהו, אפשר לשלוח לו את קובץ ה-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-learn

בשלב הזה ניקח את קובץ ה-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 שבו אנחנו רוצים להשתמש לנתוני האימון. הפעלת צינור העיבוד הזו תשתמש בגרסה קטנה יותר של מערך הנתונים beans:

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,
)

לבסוף, מפעילים את צינורות עיבוד הנתונים בשתי ההרצות. מומלץ לעשות את זה בשני תאים נפרדים של מחברת כדי לראות את הפלט של כל הרצה.

run1.submit()

לאחר מכן, מפעילים את הריצה השנייה:

run2.submit()

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

כתובת ה-URL של הפעלת צינור

כשהתהליך יסתיים (הצינור הזה פועל במשך כ-10 עד 15 דקות בכל הפעלה), תראו משהו כזה:

פייפליין sklearn שהושלם

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

6. הסבר על ארטיפקטים ועל מקורות בצינורות

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

הרחבת החפצים וסמלי התרבות

לחיצה על ארטיפקט תציג פרטים נוספים עליו, כולל ה-URI שלו. לדוגמה, אם תלחצו על ארטיפקט vertex_endpoint, יוצג לכם ה-URI שבו אפשר למצוא את נקודת הקצה שפרסתם במסוף Vertex AI:

פרטי פריט מידע שנוצר בתהליך פיתוח (Artifact) של נקודת קצה

Metrics ארטיפקט מאפשר להעביר מדדים מותאמים אישית שמשויכים לשלב מסוים בצינור. ברכיב sklearn_train של צינור עיבוד הנתונים שלנו, תיעדנו מדדים לגבי הדיוק, המסגרת והגודל של מערך הנתונים של המודל שלנו. כדי לראות את הפרטים האלה, לוחצים על ארטיפקט המדדים:

מדדים של מודלים

לכל ארטיפקט יש שיוך, שמתאר את הארטיפקטים האחרים שהוא מקושר אליהם. לוחצים שוב על ארטיפקט vertex_endpoint של צינור הנתונים ואז על הלחצן הצגת שושלת:

הצגת שרשרת המקור

תיפתח כרטיסייה חדשה שבה אפשר לראות את כל הארטיפקטים שמקושרים לארטיפקט שבחרתם. גרף השושלת ייראה בערך כך:

תרשים של שרשרת נקודות הקצה

כאן מוצגים המודל, המדדים ומערך הנתונים שמשויכים לנקודת הקצה הזו. למה זה מועיל? יכול להיות שיש לכם מודל שפריסתם בכמה נקודות קצה, או שאתם צריכים לדעת מהו מערך הנתונים הספציפי ששימש לאימון המודל שפריסתם בנקודת הקצה שאתם בודקים. תרשים השושלת עוזר לכם להבין כל ארטיפקט בהקשר של שאר המערכת שלכם ללמידת מכונה. אפשר גם לגשת לנתוני השושלת באופן פרוגרמטי, כמו שנסביר בהמשך ב-Codelab הזה.

7. השוואה בין הרצות של צינורות עיבוד נתונים

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

השוואה בין הרצות בממשק המשתמש של Pipelines

במסוף Cloud, עוברים אל לוח הבקרה של צינורות הנתונים. כך תוכלו לקבל סקירה כללית של כל הפעלת צינורות שביצעתם. בודקים את שתי ההרצות האחרונות ואז לוחצים על הלחצן השוואה בחלק העליון:

השוואה בין הרצות

הפעולה הזו תוביל אותנו לדף שבו נוכל להשוות בין פרמטרים של קלט ומדדים של כל אחת מההרצות שבחרנו. שימו לב להבדלים בין הטבלאות ב-BigQuery, הגדלים של מערכי הנתונים וערכי הדיוק בשתי ההרצות האלה:

מדדי השוואה

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

השוואה בין הרצות באמצעות Vertex AI SDK

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

אפשר להשתמש ב-method‏ aiplatform.get_pipeline_df() כדי לגשת למטא נתונים של ההרצה. בשלב הזה, נקבל מטא-נתונים של שתי ההרצות האחרונות של אותו צינור ונשמור אותם ב-Pandas DataFrame. הפרמטר pipeline כאן מתייחס לשם שנתנו לצינור שלנו בהגדרת צינור:

df = aiplatform.get_pipeline_df(pipeline="mlmd-pipeline")
df

כשמדפיסים את DataFrame, רואים משהו כזה:

Pipeline metrics 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()

אתם אמורים לראות משהו כזה:

תרשים מטא-נתונים של Matplotlib

8. שאילתת מדדים של צינור עיבוד נתונים

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

קבלת כל פריטי המידע שנוצרו בתהליך פיתוח (Artifact) של מודל

כדי לשלוח שאילתות לגבי ארטיפקטים בדרך הזו, ניצור MetadataServiceClient:

API_ENDPOINT = "{}-aiplatform.googleapis.com".format(REGION)
metadata_client = aiplatform_v1.MetadataServiceClient(
  client_options={
      "api_endpoint": API_ENDPOINT
  }
)

לאחר מכן, נשלח בקשת list_artifacts לנקודת הקצה הזו ונעביר מסנן שמציין אילו ארטיפקטים אנחנו רוצים לקבל בתגובה. קודם כל, נביא את כל הארטיפקטים בפרויקט שהם מודלים. כדי לעשות את זה, מריצים את הפקודה הבאה ב-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

יהיה נחמד אם נוכל להמחיש בקלות רבה יותר את שאילתת הארטיפקט שמתקבלת. בשלב הבא, נחפש את כל פריטי המידע שנוצרו אחרי 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

יוצג לכם משהו כזה:

מסגרת נתונים של ארטיפקט מסונן

אפשר גם לסנן את הארטיפקטים לפי קריטריונים אחרים, בנוסף לאלה שניסיתם כאן.

סיימתם את שיעור ה-Lab.

‫🎉 איזה כיף! 🎉

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

  • שימוש ב-Kubeflow Pipelines SDK כדי ליצור צינור ML שיוצר מערך נתונים ב-Vertex AI, ומאמן ופורס מודל Scikit-learn בהתאמה אישית במערך הנתונים הזה
  • כתיבת רכיבים מותאמים אישית של צינורות שמייצרים ארטיפקטים ומטא-נתונים
  • השוואה בין הרצות של צינורות עיבוד נתונים ב-Vertex, גם במסוף Cloud וגם באופן פרוגרמטי
  • מעקב אחר שרשרת המקור של פריטי מידע שנוצרו על ידי צינור עיבוד נתונים
  • שאילתה על המטא-נתונים של הפעלת צינור עיבוד הנתונים

מידע נוסף על חלקים שונים ב-Vertex זמין בתיעוד.

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

כדי שלא תחויבו, מומלץ למחוק את המשאבים שנוצרו במהלך הסדנה הזו.

הפסקה או מחיקה של מופע Notebooks

אם רוצים להמשיך להשתמש במחברת שיצרתם בסדנה הזו, מומלץ להשבית אותה כשלא משתמשים בה. בממשק המשתמש של Notebooks במסוף Cloud, בוחרים את ה-Notebook ואז בוחרים באפשרות Stop (עצירה). אם רוצים למחוק את המופע לגמרי, בוחרים באפשרות מחיקה:

עצירת מכונה

מחיקת נקודות הקצה ב-Vertex AI

כדי למחוק את נקודת הקצה שפרסתם, עוברים לקטע Endpoints במסוף Vertex AI ולוחצים על סמל המחיקה:

למחוק נקודות קצה

מחיקת קטגוריה של Cloud Storage

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

מחיקת האחסון