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

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

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

מה תלמדו

נסביר לכם איך:

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

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

2. מבוא ל-Vertex AI

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

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

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

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

יש לכם משוב על Vertex AI? אתם יכולים לשלוח אותו בדף התמיכה.

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

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

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

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

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

הפעלת Cloud Shell

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

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

הפעלת Cloud Shell

בפינה הימנית העליונה של מסוף Cloud, לוחצים על הלחצן הבא כדי להפעיל את Cloud Shell:

הפעלת Cloud Shell

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

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

תפריט Vertex AI

לאחר מכן, בקטע notebooks בניהול המשתמשים, לוחצים על New Notebook:

יצירת notebook חדש

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

מכונה של TFE

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

פתיחת מסמך ה-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, יוצרים notebook על ידי בחירה ב-Python 3.

יצירת notebook ב-Python3

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

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__))"

לאחר מכן, מוודאים שגרסת ה-SDK של Vertex AI היא 1.6.2 ואילך:

!pip list | grep aiplatform

הגדרת מזהה הפרויקט והקטגוריה

במהלך הסדנה הזו תצטרכו להפנות למזהה הפרויקט ב-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"

ייבוא ספריות

מוסיפים את הקוד הבא כדי לייבא את הספריות שבהן נשתמש במהלך הקודלאב:

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

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

  • get_dataframe: אחזור נתונים מטבלה ב-BigQuery והמרה שלהם ל-DataFrame של Pandas
  • train_sklearn_model: שימוש ב-Pandas DataFrame כדי לאמן ולייצא מודל של Scikit Learn, יחד עם כמה מדדים
  • deploy_model: פריסת מודל Scikit Learn שיוצאו לנקודת קצה ב-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)

נבחן לעומק את מה שקורה ברכיב הזה:

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

הגדרה והידור של צינור עיבוד הנתונים

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

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

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

run1.submit()

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

run2.submit()

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

כתובת URL להפעלת צינור עיבוד נתונים

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

צינור עיבוד נתונים של sklearn שהושלם

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

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

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

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

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

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

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

מדדי מודל

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

הצגת שושלת

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

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

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

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

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

השוואת פעולות הרצה בממשק המשתמש של Pipelines

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

השוואה בין פעולות

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

מדדי השוואה

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

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

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

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

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

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

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

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

סינון אובייקטים והצגה ב-DataFrame

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

תוצג הודעה שדומה להודעה הבאה:

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

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

זהו, סיימתם את שיעור ה-Lab!

🎉 מזל טוב! 🎉

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

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

מידע נוסף על החלקים השונים של Vertex זמין במסמכי העזרה.

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

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

עצירה או מחיקה של מופע של notebooks

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

עצירת המופע

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

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

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

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

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

מחיקת אחסון