דף זה תורגם על ידי Cloud Translation API.

Vertex AI:שימוש בתרחישים של חיזוי בהתאמה אישית עם Sklearn כדי לעבד מראש נתונים של תחזיות ולפרסם אותם

1. מבוא

בשיעור ה-Lab הזה תלמדו איך להשתמש בתרחישי חיזוי מותאמים אישית ב-Vertex AI כדי לכתוב לוגיקה מותאמת אישית של עיבוד מראש ולאחר עיבוד. אומנם הדוגמה הזו מתבססת על Scikit-learn, אבל תרחישים של חיזוי בהתאמה אישית יכולים לפעול עם frameworks אחרות של למידת מכונה ב-Python כמו XGBoost, PyTorch ו-TensorFlow.

מה תלמדו

כתיבת לוגיקה של חיזוי בהתאמה אישית באמצעות תרחישים של חיזוי בהתאמה אישית
בדיקה מקומית של מאגר ההצגה והמודל בהתאמה אישית
בדיקת קונטיינר להצגת מודעות בהתאמה אישית ב-Vertex AI Predictions

2. מבוא ל-Vertex AI

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

Vertex AI כולל מוצרים רבים ושונים לתמיכה בתהליכי עבודה של למידת מכונה מקצה לקצה. שיעור ה-Lab הזה יתמקד בחיזויים וב-Workbench.

3. סקירה כללית של תרחיש השימוש

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

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

מבוא לתרחישים של חיזוי בהתאמה אישית

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

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

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

מה תפַתחו

מגדירים רשת VPC בשם beforel-vpc, שכוללת רשת משנה של סביבת העבודה שמשמשת לפריסת notebook שמנוהל על ידי משתמש ולגשת לנקודת הקצה (endpoint) של המודל ולחיזוי באינטרנט שנפרסה ב-us-central1 כפי שמתואר באיור 1 שבהמשך.

                                                                            Figure1

4. הפעלת ממשקי API של מדריכים

שלב 1: הפעלה של Compute Engine API

עוברים אל Compute Engine ובוחרים באפשרות 'הפעלה', אם היא עדיין לא מופעלת. תצטרכו את הקישור הזה כדי ליצור מכונה של ה-notebook.

שלב 2: הפעלה של Artifact Registry API

עוברים אל Artifact Registry ובוחרים באפשרות 'הפעלה', אם עדיין לא עשיתם זאת. אפשר להשתמש בו כדי ליצור מאגר להצגת מודעות בהתאמה אישית.

שלב 3: הפעלה של Vertex AI API

עוברים לקטע Vertex AI במסוף Cloud ולוחצים על Enable Vertex AI API.

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

מפעילים את Notebooks APאם הוא עדיין לא מופעל.

5. יוצרים את ה-scalel-vpc

המדריך הזה משתמש ב-$variables כדי לעזור בהטמעת ההגדרות של gcloud ב-Cloud Shell.

Inside Cloud Shell מבצעים את הפעולות הבאות:

gcloud config list project
gcloud config set project [YOUR-PROJECT-NAME]
projectid=YOUR-PROJECT-NAME
echo $projectid

יוצרים את ה-Simplel-vpc

Inside Cloud Shell מבצעים את הפעולות הבאות:

gcloud compute networks create aiml-vpc --project=$projectid --subnet-mode=custom

יצירת רשת משנה של notebook בניהול המשתמש

Inside Cloud Shell, יוצרים את רשת המשנה של שולחן העבודה.

gcloud compute networks subnets create workbench-subnet --project=$projectid --range=172.16.10.0/28 --network=aiml-vpc --region=us-central1 --enable-private-ip-google-access

הגדרת Cloud Router ו-NAT

במדריך הזה תלמדו איך להוריד חבילות תוכנה ב-Cloud NAT, כי ל-notebook שמנוהל על ידי המשתמש אין כתובת IP חיצונית. Cloud NAT מספק יכולות של תעבורת נתונים יוצאת (egress NAT), כלומר שמארחי אינטרנט לא יכולים ליזום תקשורת עם notebook שמנוהל על ידי משתמש, ולכן הוא מאובטח יותר.

בתוך Cloud Shell, יוצרים את הנתב האזורי בענן, us-central1.

gcloud compute routers create cloud-router-us-central1-aiml-nat --network aiml-vpc --region us-central1

ב-Inside Cloud Shell, יוצרים את שער הענן האזורי us-central1.

gcloud compute routers nats create cloud-nat-us-central1 --router=cloud-router-us-central1-aiml-nat --auto-allocate-nat-external-ips --nat-all-subnet-ip-ranges --region us-central1

6. יצירת ה-notebook המנוהל על ידי המשתמש

יצירת חשבון שירות שמנוהל על ידי משתמש (Notebook)

בקטע הבא תיצרו חשבון שירות בניהול משתמשים שישויך ל-Vertex Workbench (Notebook) שנעשה בו שימוש במדריך.

במדריך הזה יחולו הכללים הבאים על חשבון השירות:

יוצרים את חשבון השירות ב-Inside Cloud Shell.

gcloud iam service-accounts create user-managed-notebook-sa \
    --display-name="user-managed-notebook-sa"

ב-Inside Cloud Shell, מעדכנים את חשבון השירות עם התפקיד Storage Admin.

gcloud projects add-iam-policy-binding $projectid --member="serviceAccount:user-managed-notebook-sa@$projectid.iam.gserviceaccount.com" --role="roles/storage.admin"

ב-Inside Cloud Shell, מעדכנים את חשבון השירות עם התפקיד Vertex AI User.

gcloud projects add-iam-policy-binding $projectid --member="serviceAccount:user-managed-notebook-sa@$projectid.iam.gserviceaccount.com" --role="roles/aiplatform.user"

Inside Cloud Shell, מעדכנים את חשבון השירות עם התפקיד Artifact Registry Admin.

gcloud projects add-iam-policy-binding $projectid --member="serviceAccount:user-managed-notebook-sa@$projectid.iam.gserviceaccount.com" --role="roles/artifactregistry.admin"

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

gcloud iam service-accounts list

יוצרים את ה-notebook בניהול המשתמש

בקטע הבא, יוצרים notebook בניהול משתמש שמשלב את חשבון השירות שנוצר בעבר, user-managed-notebook-sa.

באמצעות Inside Cloud Shell, יוצרים את המכונה הפרטית של הלקוח.

gcloud notebooks instances create workbench-tutorial \
      --vm-image-project=deeplearning-platform-release \
      --vm-image-family=common-cpu-notebooks \
      --machine-type=n1-standard-4 \
      --location=us-central1-a \
      --shielded-secure-boot \
      --subnet-region=us-central1 \
      --subnet=workbench-subnet \
      --no-public-ip    --service-account=user-managed-notebook-sa@$projectid.iam.gserviceaccount.com

7. כתיבת קוד אימון

שלב 1: יצירת קטגוריה של אחסון בענן

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

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

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

PROJECT_ID='your-cloud-project'

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

BUCKET="gs://${PROJECT_ID}-cpr-bucket"
gsutil mb -l us-central1 $BUCKET

שלב 2: מודל אימון

מהטרמינל, יוצרים ספרייה חדשה בשם cpr-codelab ובתוכו cd.

mkdir cpr-codelab
cd cpr-codelab

בדפדפן הקבצים, עוברים לספריית cpr-codelab החדשה ואז משתמשים במרכז האפליקציות כדי ליצור notebook חדש של Python 3 בשם Tasks.ipynb.

עכשיו ספריית cpr-codelab אמורה להיראות כך:

+ cpr-codelab/
    + task.ipynb

ב-notebook, מדביקים את הקוד הבא.

קודם כול, כותבים קובץrequest.txt.

%%writefile requirements.txt
fastapi
uvicorn==0.17.6
joblib~=1.1.1
numpy>=1.17.3, <1.24.0
scikit-learn~=1.0.0
pandas
google-cloud-storage>=2.2.1,<3.0.0dev
google-cloud-aiplatform[prediction]>=1.18.2

במודל שתפרסו תהיה קבוצה שונה של יחסי תלות שתותקן מראש בסביבת ה-notebook. לכן כדאי לרשום את כל יחסי התלות של המודל ב-required.txt, ואז להשתמש ב-pip כדי להתקין את אותם יחסי תלות ב-notebook. לאחר מכן, תבדקו את המודל באופן מקומי לפני שתפרסו ב-Vertex AI כדי לוודא שהסביבות תואמות.

Pip מתקין את יחסי התלות ב-notebook.

!pip install -U --user -r requirements.txt

שימו לב שתצטרכו להפעיל מחדש את הליבה (kernel) בסיום ההתקנה של PIP.

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

USER_SRC_DIR = "src_dir"
!mkdir $USER_SRC_DIR
!mkdir model_artifacts

# copy the requirements to the source dir
!cp requirements.txt $USER_SRC_DIR/requirements.txt

עכשיו ספריית cpr-codelab אמורה להיראות כך:

+ cpr-codelab/
    + model_artifacts/
    + scr_dir/
        + requirements.txt
    + task.ipynb
    + requirements.txt

עכשיו, אחרי שמבנה הספריות מוגדר, הגיע הזמן לאמן מודל.

קודם כול, מייבאים את הספריות.

import seaborn as sns
import numpy as np
import pandas as pd

from sklearn import preprocessing
from sklearn.ensemble import RandomForestRegressor
from sklearn.pipeline import make_pipeline
from sklearn.compose import make_column_transformer

import joblib
import logging

# set logging to see the docker container logs
logging.basicConfig(level=logging.INFO)

לאחר מכן מגדירים את המשתנים הבאים. חשוב להחליף את הפרויקט PROJECT_ID במזהה הפרויקט ואת BUCKET_NAME בקטגוריה שיצרתם בשלב הקודם.

REGION = "us-central1"
MODEL_ARTIFACT_DIR = "sklearn-model-artifacts"
REPOSITORY = "diamonds"
IMAGE = "sklearn-image"
MODEL_DISPLAY_NAME = "diamonds-cpr"

# Replace with your project
PROJECT_ID = "{PROJECT_ID}"

# Replace with your bucket
BUCKET_NAME = "gs://{BUCKET_NAME}"

טוענים את הנתונים מספריית Seaborn ואז יוצרים שתי מסגרות נתונים, אחת עם התכונות והשנייה עם התווית.

data = sns.load_dataset('diamonds', cache=True, data_home=None)

label = 'price'

y_train = data['price']
x_train = data.drop(columns=['price'])

בואו נסתכל על נתוני האימון. אפשר לראות שכל שורה מייצגת יהלום.

x_train.head()

והתוויות, שהן המחירים התואמים.

y_train.head()

עכשיו מגדירים טרנספורמציה של עמודה ב-sklearn כדי לבצע קידוד חם אחד של התכונות הקטגוריות ומתאימים את קנה המידה של התכונות המספריות

column_transform = make_column_transformer(
    (preprocessing.OneHotEncoder(sparse=False), [1,2,3]),
    (preprocessing.StandardScaler(), [0,4,5,6,7,8]))

מגדירים את מודל היער האקראי

regr = RandomForestRegressor(max_depth=10, random_state=0)

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

my_pipeline = make_pipeline(column_transform, regr)

להתאים את צינור עיבוד הנתונים לנתוני האימון

my_pipeline.fit(x_train, y_train)

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

my_pipeline.predict([[0.23, 'Ideal', 'E', 'SI2', 61.5, 55.0, 3.95, 3.98, 2.43]])

עכשיו אפשר לשמור את צינור עיבוד הנתונים ב-model_artifacts dir ולהעתיק אותו לקטגוריה של Cloud Storage

joblib.dump(my_pipeline, 'model_artifacts/model.joblib')

!gsutil cp model_artifacts/model.joblib {BUCKET_NAME}/{MODEL_ARTIFACT_DIR}/

שלב 3: שמירת פריט מידע שנוצר בתהליך עיבוד מראש

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

clarity_dict={"Flawless": "FL",
              "Internally Flawless": "IF",
              "Very Very Slightly Included": "VVS1",
              "Very Slightly Included": "VS2",
              "Slightly Included": "S12",
              "Included": "I3"}

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

import json
with open("model_artifacts/preprocessor.json", "w") as f:
    json.dump(clarity_dict, f)

!gsutil cp model_artifacts/preprocessor.json {BUCKET_NAME}/{MODEL_ARTIFACT_DIR}/

עכשיו ספריית cpr-codelab המקומית אמורה להיראות כך:

+ cpr-codelab/
    + model_artifacts/
        + model.joblib
        + preprocessor.json
    + scr_dir/
        + requirements.txt
    + task.ipynb
    + requirements.txt

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

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

מאגר תגים בהתאמה אישית מכיל את 3 קטעי הקוד הבאים:

שרת המודלים (הקוד הזה ייווצר באופן אוטומטי על ידי ה-SDK ויישמר ב-scr_dir/)

שרת ה-HTTP שמארח את המודל
אחראי להגדרת מסלולים/יציאות וכו'.

מטפל בבקשות

אחראי להיבטים של שרת האינטרנט לטיפול בבקשה, כגון פעולת deserialization לגוף הבקשה, וסידור מחדש של התגובה, הגדרת כותרות תגובה וכו'.
בדוגמה הזו תשתמשו ב-handler שמוגדר כברירת מחדל, google.cloud.aiplatform.prediction.handler.PredictionHandler שסופק ב-SDK.

כלי חיזוי

אחראי ללוגיקת למידת המכונה בעיבוד בקשת חיזוי.

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

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

הגרסה הזו של תרחישי חיזוי בהתאמה אישית כוללת חיזויי XGBoost ו-Sklearn לשימוש חוזר. אבל אם אתם צריכים להשתמש במסגרת אחרת, אתם יכולים ליצור מסגרת משלכם על ידי יצירת תת-סיווג של חיזוי הבסיס.

אתם יכולים לראות דוגמה לחיזוי ה-Sklearn שלמטה. זה כל הקוד שצריך לכתוב כדי ליצור את השרת הזה של מודלים מותאמים אישית.

ב-notebook, מדביקים את הקוד הבא כדי ליצור מחלקה משנית של SklearnPredictor ולכתוב אותו בקובץ Python ב-src_dir/. שימו לב שבדוגמה הזו אנחנו מתאימים אישית רק את השיטות של הטעינה, של העיבוד המקדים ושל אחרי העיבוד, ולא של שיטת החיזוי.

%%writefile $USER_SRC_DIR/predictor.py

import joblib
import numpy as np
import json

from google.cloud import storage
from google.cloud.aiplatform.prediction.sklearn.predictor import SklearnPredictor


class CprPredictor(SklearnPredictor):

    def __init__(self):
        return

    def load(self, artifacts_uri: str) -> None:
        """Loads the sklearn pipeline and preprocessing artifact."""

        super().load(artifacts_uri)

        # open preprocessing artifact
        with open("preprocessor.json", "rb") as f:
            self._preprocessor = json.load(f)


    def preprocess(self, prediction_input: np.ndarray) -> np.ndarray:
        """Performs preprocessing by checking if clarity feature is in abbreviated form."""

        inputs = super().preprocess(prediction_input)

        for sample in inputs:
            if sample[3] not in self._preprocessor.values():
                sample[3] = self._preprocessor[sample[3]]
        return inputs

    def postprocess(self, prediction_results: np.ndarray) -> dict:
        """Performs postprocessing by rounding predictions and converting to str."""

        return {"predictions": [f"${value}" for value in np.round(prediction_results)]}

בואו נבחן לעומק כל אחת מהשיטות האלה.

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

בשלב הבא משתמשים ב-Vertex AI Python SDK כדי ליצור את התמונה. באמצעות תרחישי חיזוי מותאמים אישית, המערכת תיצור את קובץ ה-Docker ותיצור עבורך תמונה.

from google.cloud import aiplatform

aiplatform.init(project=PROJECT_ID, location=REGION)

import os

from google.cloud.aiplatform.prediction import LocalModel

from src_dir.predictor import CprPredictor  # Should be path of variable $USER_SRC_DIR

local_model = LocalModel.build_cpr_model(
    USER_SRC_DIR,
    f"{REGION}-docker.pkg.dev/{PROJECT_ID}/{REPOSITORY}/{IMAGE}",
    predictor=CprPredictor,
    requirements_path=os.path.join(USER_SRC_DIR, "requirements.txt"),
)

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

import json

sample = {"instances": [
  [0.23, 'Ideal', 'E', 'VS2', 61.5, 55.0, 3.95, 3.98, 2.43],
  [0.29, 'Premium', 'J', 'Internally Flawless', 52.5, 49.0, 4.00, 2.13, 3.11]]}

with open('instances.json', 'w') as fp:
    json.dump(sample, fp)

לבדוק את הקונטיינר באופן מקומי על ידי פריסת מודל מקומי.

with local_model.deploy_to_local_endpoint(
    artifact_uri = 'model_artifacts/', # local path to artifacts
) as local_endpoint:
    predict_response = local_endpoint.predict(
        request_file='instances.json',
        headers={"Content-Type": "application/json"},
    )

    health_check_response = local_endpoint.run_health_check()

אפשר לראות את תוצאות החיזוי עם:

predict_response.content

9. פריסת מודל ב-Vertex AI

אחרי שבדקתם את הקונטיינר באופן מקומי, זה הזמן להעביר את התמונה ל-Artifact Registry ולהעלות את המודל ל-Vertex AI Model Registry.

קודם צריך להגדיר את Docker לגישה ל-Artifact Registry.

!gcloud artifacts repositories create {REPOSITORY} --repository-format=docker \
--location=us-central1 --description="Docker repository"

!gcloud auth configure-docker {REGION}-docker.pkg.dev --quiet

לאחר מכן, דוחפים את התמונה.

local_model.push_image()

ומעלים את המודל.

model = aiplatform.Model.upload(local_model = local_model,
                                display_name=MODEL_DISPLAY_NAME,
                                artifact_uri=f"{BUCKET_NAME}/{MODEL_ARTIFACT_DIR}",)

אחרי שמעלים את המודל, הוא אמור להופיע במסוף:

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