1. סקירה כללית
בשיעור ה-Lab הזה תשתמשו ב-Vertex AI כדי ליצור פייפליין שמכשיר מודל Keras בהתאמה אישית ב-TensorFlow. לאחר מכן נשתמש בפונקציונליות החדשה שזמינה ב-Vertex AI Experiments כדי לעקוב אחרי הרצות של מודלים ולהשוות ביניהן, כדי לזהות את השילוב של ההיפר-פרמטרים שמניב את הביצועים הכי טובים.
מה לומדים
במאמר הזה נסביר איך:
- אימון מודל Keras מותאם אישית לחיזוי דירוגים של שחקנים (למשל, רגרסיה)
- שימוש ב-Kubeflow Pipelines SDK כדי לבנות צינורות עיבוד נתונים של למידת מכונה (ML) שניתנים להרחבה
- יצירה והפעלה של צינור (pipeline) בן 5 שלבים שקולט נתונים מ-Cloud Storage, משנה את קנה המידה של הנתונים, מאמן את המודל, מעריך אותו ושומר את המודל שנוצר בחזרה ב-Cloud Storage
- שימוש ב-Vertex ML Metadata כדי לשמור ארטיפקטים של מודלים, כמו מודלים ומדדי מודלים
- שימוש ב-Vertex AI Experiments כדי להשוות בין התוצאות של ההרצות השונות של צינורות עיבוד הנתונים
העלות הכוללת להרצת שיעור ה-Lab הזה ב-Google Cloud היא בערך 1$.
2. מבוא ל-Vertex AI
בשיעור ה-Lab הזה נעשה שימוש במוצר ה-AI החדש ביותר שזמין ב-Google Cloud. Vertex AI משלב את מוצרי ה-ML ב-Google Cloud לחוויית פיתוח חלקה. בעבר, היה אפשר לגשת למודלים שאומנו באמצעות AutoML ולמודלים בהתאמה אישית דרך שירותים נפרדים. המוצר החדש משלב את שניהם ב-API אחד, יחד עם מוצרים חדשים אחרים. אפשר גם להעביר פרויקטים קיימים אל Vertex AI.
Vertex AI כולל מוצרים רבים ושונים לתמיכה בתהליכי עבודה של למידת מכונה מקצה לקצה. בשיעור ה-Lab הזה נתמקד במוצרים שמודגשים בהמשך: Experiments, Pipelines, ML Metadata ו-Workbench.
3. סקירה כללית של תרחיש לדוגמה
נשתמש במערך נתונים פופולרי של כדורגל שמקורו בסדרת משחקי הווידאו FIFA של EA Sports. הוא כולל יותר מ-25,000 משחקי כדורגל ויותר מ-10,000 שחקנים מהעונות 2008-2016. הנתונים עברו עיבוד מראש כדי שתוכלו להתחיל לעבוד איתם בקלות. במהלך שיעור ה-Lab הזה תשתמשו במערך הנתונים הזה, שזמין עכשיו בקטגוריה של Cloud Storage ציבורית. בהמשך ה-codelab נסביר איך לגשת למערך הנתונים. המטרה הסופית שלנו היא לחזות את הדירוג הכולל של שחקן על סמך פעולות שונות במשחק, כמו חטיפות כדור ועבירות.
למה כדאי להשתמש ב-Vertex AI Experiments למדעי הנתונים?
מדע הנתונים הוא ניסיוני באופיו – אחרי הכול, קוראים להם מדענים. מדעני נתונים טובים מונחים על ידי היפותזות, והם משתמשים בשיטת הניסוי והטעייה כדי לבדוק היפותזות שונות בתקווה שסדרת איטרציות תניב מודל עם ביצועים טובים יותר.
צוותי מדע נתונים משתמשים בניסויים, אבל לעיתים קרובות מתקשים לעקוב אחרי העבודה שלהם ואחרי ה "מרכיב הסודי" שהם גילו באמצעות הניסויים. יש כמה סיבות לכך:
- מעקב אחרי משימות אימון יכול להיות מסובך, ולכן קל לאבד את ההבנה מה עובד ומה לא.
- הבעיה הזו מחמירה כשמסתכלים על צוות מדעי נתונים, כי יכול להיות שלא כל חברי הצוות עוקבים אחרי ניסויים או אפילו משתפים את התוצאות שלהם עם אחרים.
- איסוף הנתונים הוא תהליך שלוקח הרבה זמן, ורוב הצוותים משתמשים בשיטות ידניות (למשל, גיליונות אלקטרוניים או מסמכים) שמובילות למידע לא עקבי ולא מלא.
tl;dr: התכונה Vertex AI Experiments מבצעת את העבודה בשבילכם, ועוזרת לכם לעקוב אחרי הניסויים ולהשוות ביניהם בקלות רבה יותר
למה כדאי להשתמש ב-Vertex AI Experiments בתחום הגיימינג?
היסטורית, משחקים היו מגרש משחקים ללמידת מכונה ולניסויים ב-ML. המשחקים לא רק מייצרים מיליארדי אירועים בזמן אמת בכל יום, אלא גם משתמשים בכל הנתונים האלה באמצעות למידת מכונה וניסויים של למידת מכונה כדי לשפר את חוויית המשחק, לשמר את השחקנים ולהעריך את השחקנים השונים בפלטפורמה שלהם. לכן חשבנו שמערך נתונים של משחקים יתאים היטב לתרגיל הניסויים הכולל שלנו.
4. הגדרת הסביבה
כדי להפעיל את ה-codelab הזה, צריך פרויקט ב-Google Cloud Platform שמופעל בו חיוב. כדי ליצור פרויקט, פועלים לפי ההוראות האלה.
שלב 1: הפעלת Compute Engine API
עוברים אל Compute Engine ובוחרים באפשרות הפעלה אם הוא עדיין לא מופעל.
שלב 2: הפעלת Vertex AI API
עוברים אל הקטע Vertex AI במסוף Cloud ולוחצים על הפעלת Vertex AI API.
שלב 3: יצירת מכונה של Vertex AI Workbench
בקטע Vertex AI במסוף Cloud, לוחצים על Workbench:
מפעילים את Notebooks API אם הוא עדיין לא מופעל.
אחרי ההפעלה, לוחצים על מחברות מנוהלות:
לאחר מכן בוחרים באפשרות מחברת חדשה.
נותנים שם למחברת ולוחצים על הגדרות מתקדמות.
בקטע 'הגדרות מתקדמות', מפעילים את ההגדרה 'כיבוי במצב לא פעיל' ומגדירים את מספר הדקות ל-60. המשמעות היא שמחברת ה-notebook תיסגר אוטומטית כשלא משתמשים בה, כדי שלא תצטברו עלויות מיותרות.
שלב 4: פותחים את המחברת
אחרי שהמופע נוצר, בוחרים באפשרות Open JupyterLab.
שלב 5: אימות (בפעם הראשונה בלבד)
בפעם הראשונה שמשתמשים במופע חדש, תופיע בקשה לבצע אימות. פועלים לפי השלבים בממשק המשתמש.
שלב 6: בוחרים את ליבת המערכת המתאימה
במחברות מנוהלות יש כמה ליבות בממשק משתמש אחד. בוחרים את ליבת Tensorflow 2 (מקומית).
5. שלבי ההגדרה הראשונית ב-Notebook
תצטרכו לבצע סדרה של שלבים נוספים כדי להגדיר את הסביבה בתוך ה-notebook לפני שתבנו את הפייפליין. השלבים האלה כוללים: התקנת חבילות נוספות, הגדרת משתנים, יצירת קטגוריה של Cloud Storage, העתקת קבוצת הנתונים של הגיימינג ממאגר אחסון ציבורי, ייבוא ספריות והגדרת קבועים נוספים.
שלב 1: התקנת חבילות נוספות
נצטרך להתקין תלות בחבילות נוספות שלא מותקנות כרגע בסביבת המחברת. דוגמה אחת היא KFP SDK.
!pip3 install --user --force-reinstall 'google-cloud-aiplatform>=1.15' -q --no-warn-conflicts
!pip3 install --user kfp -q --no-warn-conflicts
לאחר מכן תצטרכו להפעיל מחדש את ליבת המחברת כדי שתוכלו להשתמש בחבילות שהורדתם במחברת.
# Automatically restart kernel after installs
import os
if not os.getenv("IS_TESTING"):
# Automatically restart kernel after installs
import IPython
app = IPython.Application.instance()
app.kernel.do_shutdown(True)
שלב 2: הגדרת משתנים
אנחנו רוצים להגדיר את PROJECT_ID. אם אתם לא יודעים מהו Project_ID, יכול להיות שתוכלו לקבל את PROJECT_ID באמצעות gcloud.
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)
אחרת, מגדירים את PROJECT_ID כאן.
if PROJECT_ID == "" or PROJECT_ID is None:
PROJECT_ID = "[your-project-id]" # @param {type:"string"}
נרצה גם להגדיר את המשתנה REGION, שבו נשתמש בהמשך ה-notebook. בהמשך מפורטים האזורים שנתמכים ב-Vertex AI. מומלץ לבחור את האזור הקרוב אליכם ביותר.
- אמריקה: us-central1
- אירופה: europe-west4
- אסיה והפאסיפיק: asia-east1
אל תשתמשו בקטגוריה של Cloud Storage שפועלת במספר אזורים לאימון באמצעות Vertex AI. לא כל האזורים תומכים בכל השירותים של Vertex AI. מידע נוסף על אזורים ב-Vertex AI
#set your region
REGION = "us-central1" # @param {type: "string"}
לבסוף, נגדיר משתנה TIMESTAMP. המשתנה הזה משמש כדי למנוע התנגשויות בשמות בין משתמשים במשאבים שנוצרו. יוצרים TIMESTAMP לכל סשן של מכונה ומצרפים אותו לשם של המשאבים שיוצרים במדריך הזה.
#set timestamp to avoid collisions between multiple users
from datetime import datetime
TIMESTAMP = datetime.now().strftime("%Y%m%d%H%M%S")
שלב 3: יצירת קטגוריה של Cloud Storage
תצטרכו לציין קטגוריית אחסון זמני ב-Cloud Storage ולהשתמש בה. בדלי ההעברה הזמנית נשמרים כל הנתונים שמשויכים לקבוצת הנתונים ולמשאבי המודל שלכם, בכל הסשנים.
מגדירים את השם של הקטגוריה ב-Cloud Storage. שמות הקטגוריות חייבים להיות ייחודיים באופן גלובלי בכל הפרויקטים ב-Google Cloud, כולל אלה שמחוץ לארגון שלכם.
#set cloud storage bucket
BUCKET_NAME = "[insert bucket name here]" # @param {type:"string"}
BUCKET_URI = f"gs://{BUCKET_NAME}"
אם הקטגוריה שלכם עדיין לא קיימת, אתם יכולים להריץ את התא הבא כדי ליצור אותה ב-Cloud Storage.
! gsutil mb -l $REGION -p $PROJECT_ID $BUCKET_URI
אחר כך תוכלו להריץ את התא הבא כדי לוודא שיש לכם גישה לקטגוריה של Cloud Storage.
#verify access
! gsutil ls -al $BUCKET_URI
שלב 4: מעתיקים את מערך הנתונים בנושא גיימינג
כמו שציינו קודם, תשתמשו במערך נתונים פופולרי של משחקי גיימינג מתוך משחקי הווידאו המצליחים של EA Sports, FIFA. אנחנו כבר ביצענו את העיבוד המקדים בשבילכם, כך שכל מה שאתם צריכים לעשות הוא להעתיק את קבוצת הנתונים ממאגר האחסון הציבורי ולהעביר אותו למאגר שיצרתם.
# copy the data over to your cloud storage bucket
DATASET_URI = "gs://cloud-samples-data/vertex-ai/structured_data/player_data"
!gsutil cp -r $DATASET_URI $BUCKET_URI
שלב 5: ייבוא ספריות והגדרת קבועים נוספים
בשלב הבא נרצה לייבא את הספריות שלנו ל-Vertex AI, ל-KFP וכו'.
import logging
import os
import time
logger = logging.getLogger("logger")
logging.basicConfig(level=logging.INFO)
import kfp.v2.compiler as compiler
# Pipeline Experiments
import kfp.v2.dsl as dsl
# Vertex AI
from google.cloud import aiplatform as vertex_ai
from kfp.v2.dsl import Artifact, Input, Metrics, Model, Output, component
from typing import NamedTuple
נגדיר גם קבועים נוספים שנתייחס אליהם בהמשך ה-notebook, כמו נתיבי הקבצים של נתוני האימון.
#import libraries and define constants
# Experiments
TASK = "regression"
MODEL_TYPE = "tensorflow"
EXPERIMENT_NAME = f"{PROJECT_ID}-{TASK}-{MODEL_TYPE}-{TIMESTAMP}"
# Pipeline
PIPELINE_URI = f"{BUCKET_URI}/pipelines"
TRAIN_URI = f"{BUCKET_URI}/player_data/data.csv"
LABEL_URI = f"{BUCKET_URI}/player_data/labels.csv"
MODEL_URI = f"{BUCKET_URI}/model"
DISPLAY_NAME = "experiments-demo-gaming-data"
BQ_DATASET = "player_data"
BQ_LOCATION = "US"
VIEW_NAME = 'dataset_test'
PIPELINE_JSON_PKG_PATH = "experiments_demo_gaming_data.json"
PIPELINE_ROOT = f"gs://{BUCKET_URI}/pipeline_root"
6. בואו נבנה את צינור עיבוד הנתונים
עכשיו אפשר להתחיל ליהנות ולהשתמש ב-Vertex AI כדי ליצור את צינור העיבוד לאימון. אנחנו נא初始化 את Vertex AI SDK, נגדיר את משימת האימון כרכיב של פייפליין, נבנה את הפייפליין, נשלח את ההרצה של הפייפליין ונשתמש ב-Vertex AI SDK כדי להציג ניסויים ולעקוב אחרי הסטטוס שלהם.
שלב 1: אתחול Vertex AI SDK
מאתחלים את Vertex AI SDK ומגדירים את PROJECT_ID ואת BUCKET_URI.
#initialize vertex AI SDK
vertex_ai.init(project=PROJECT_ID, staging_bucket=BUCKET_URI)
שלב 2: הגדרת משימת האימון כרכיב של פייפליין
כדי להתחיל להריץ את הניסויים שלנו, נצטרך לציין את משימת האימון על ידי הגדרתה כרכיב של פייפליין. צינור עיבוד הנתונים יקבל נתוני אימון והיפרפרמטרים (לדוגמה, DROPOUT_RATE, LEARNING_RATE, EPOCHS) כקלט, ויוציא מדדי מודל (לדוגמה, MAE ו-RMSE) וארטיפקט של מודל.
@component(
packages_to_install=[
"numpy==1.21.0",
"pandas==1.3.5",
"scikit-learn==1.0.2",
"tensorflow==2.9.0",
]
)
def custom_trainer(
train_uri: str,
label_uri: str,
dropout_rate: float,
learning_rate: float,
epochs: int,
model_uri: str,
metrics: Output[Metrics],
model_metadata: Output[Model],
):
# import libraries
import logging
import uuid
from pathlib import Path as path
import pandas as pd
import tensorflow as tf
from tensorflow import keras
from tensorflow.keras.models import Sequential
from tensorflow.keras.layers import Dense
from tensorflow.keras.layers import Dropout
from tensorflow.keras.metrics import Metric
from sklearn.metrics import accuracy_score
from sklearn.model_selection import train_test_split
from sklearn.preprocessing import StandardScaler
from sklearn.metrics import mean_absolute_error
import numpy as np
from math import sqrt
import os
import tempfile
# set variables and use gcsfuse to update prefixes
gs_prefix = "gs://"
gcsfuse_prefix = "/gcs/"
train_path = train_uri.replace(gs_prefix, gcsfuse_prefix)
label_path = label_uri.replace(gs_prefix, gcsfuse_prefix)
model_path = model_uri.replace(gs_prefix, gcsfuse_prefix)
def get_logger():
logger = logging.getLogger(__name__)
logger.setLevel(logging.INFO)
handler = logging.StreamHandler()
handler.setFormatter(
logging.Formatter("%(asctime)s - %(name)s - %(levelname)s - %(message)s")
)
logger.addHandler(handler)
return logger
def get_data(
train_path: str,
label_path: str
) -> (pd.DataFrame):
#load data into pandas dataframe
data_0 = pd.read_csv(train_path)
labels_0 = pd.read_csv(label_path)
#drop unnecessary leading columns
data = data_0.drop('Unnamed: 0', axis=1)
labels = labels_0.drop('Unnamed: 0', axis=1)
#save as numpy array for reshaping of data
labels = labels.values
data = data.values
# Split the data
labels = labels.reshape((labels.size,))
train_data, test_data, train_labels, test_labels = train_test_split(data, labels, test_size=0.2, shuffle=True, random_state=7)
#Convert data back to pandas dataframe for scaling
train_data = pd.DataFrame(train_data)
test_data = pd.DataFrame(test_data)
train_labels = pd.DataFrame(train_labels)
test_labels = pd.DataFrame(test_labels)
#Scale and normalize the training dataset
scaler = StandardScaler()
scaler.fit(train_data)
train_data = pd.DataFrame(scaler.transform(train_data), index=train_data.index, columns=train_data.columns)
test_data = pd.DataFrame(scaler.transform(test_data), index=test_data.index, columns=test_data.columns)
return train_data,train_labels, test_data, test_labels
""" Train your Keras model passing in the training data and values for learning rate, dropout rate,and the number of epochs """
def train_model(
learning_rate: float,
dropout_rate: float,
epochs: float,
train_data: pd.DataFrame,
train_labels: pd.DataFrame):
# Train tensorflow model
param = {"learning_rate": learning_rate, "dropout_rate": dropout_rate, "epochs": epochs}
model = Sequential()
model.add(Dense(500, input_dim=train_data.shape[1], activation= "relu"))
model.add(Dropout(param['dropout_rate']))
model.add(Dense(100, activation= "relu"))
model.add(Dense(50, activation= "relu"))
model.add(Dense(1))
model.compile(
tf.keras.optimizers.Adam(learning_rate= param['learning_rate']),
loss='mse',
metrics=[tf.keras.metrics.RootMeanSquaredError(),tf.keras.metrics.MeanAbsoluteError()])
model.fit(train_data, train_labels, epochs= param['epochs'])
return model
# Get Predictions
def get_predictions(model, test_data):
dtest = pd.DataFrame(test_data)
pred = model.predict(dtest)
return pred
# Evaluate predictions with MAE
def evaluate_model_mae(pred, test_labels):
mae = mean_absolute_error(test_labels, pred)
return mae
# Evaluate predictions with RMSE
def evaluate_model_rmse(pred, test_labels):
rmse = np.sqrt(np.mean((test_labels - pred)**2))
return rmse
#Save your trained model in GCS
def save_model(model, model_path):
model_id = str(uuid.uuid1())
model_path = f"{model_path}/{model_id}"
path(model_path).parent.mkdir(parents=True, exist_ok=True)
model.save(model_path + '/model_tensorflow')
# Main ----------------------------------------------
train_data, train_labels, test_data, test_labels = get_data(train_path, label_path)
model = train_model(learning_rate, dropout_rate, epochs, train_data,train_labels )
pred = get_predictions(model, test_data)
mae = evaluate_model_mae(pred, test_labels)
rmse = evaluate_model_rmse(pred, test_labels)
save_model(model, model_path)
# Metadata ------------------------------------------
#convert numpy array to pandas series
mae = pd.Series(mae)
rmse = pd.Series(rmse)
#log metrics and model artifacts with ML Metadata. Save metrics as a list.
metrics.log_metric("mae", mae.to_list())
metrics.log_metric("rmse", rmse.to_list())
model_metadata.uri = model_uri
שלב 3: בניית צינור המכירות
עכשיו נגדיר את תהליך העבודה באמצעות Domain Specific Language (DSL) שזמין ב-KFP ונבצע קומפילציה של צינור עיבוד הנתונים לקובץ JSON.
# define our workflow
@dsl.pipeline(name="gaming-custom-training-pipeline")
def pipeline(
train_uri: str,
label_uri: str,
dropout_rate: float,
learning_rate: float,
epochs: int,
model_uri: str,
):
custom_trainer(
train_uri,label_uri, dropout_rate,learning_rate,epochs, model_uri
)
#compile our pipeline
compiler.Compiler().compile(pipeline_func=pipeline, package_path="gaming_pipeline.json")
שלב 4: שולחים את ההרצה של הצינור
העבודה הקשה כבר מאחורינו – הגדרנו את הרכיב והגדרנו את צינור העיבוד. אנחנו מוכנים לשלוח ריצות שונות של צינור הנתונים שציינו למעלה. כדי לעשות זאת, נצטרך להגדיר את הערכים של ההיפר-פרמטרים השונים באופן הבא:
runs = [
{"dropout_rate": 0.001, "learning_rate": 0.001,"epochs": 20},
{"dropout_rate": 0.002, "learning_rate": 0.002,"epochs": 25},
{"dropout_rate": 0.003, "learning_rate": 0.003,"epochs": 30},
{"dropout_rate": 0.004, "learning_rate": 0.004,"epochs": 35},
{"dropout_rate": 0.005, "learning_rate": 0.005,"epochs": 40},
]
אחרי שמגדירים את הפרמטרים העל, אפשר להשתמש ב-for loop כדי להזין בהצלחה את ההרצות השונות של צינור העיבוד:
for i, run in enumerate(runs):
job = vertex_ai.PipelineJob(
display_name=f"{EXPERIMENT_NAME}-pipeline-run-{i}",
template_path="gaming_pipeline.json",
pipeline_root=PIPELINE_URI,
parameter_values={
"train_uri": TRAIN_URI,
"label_uri": LABEL_URI,
"model_uri": MODEL_URI,
**run,
},
)
job.submit(experiment=EXPERIMENT_NAME)
שלב 5: שימוש ב-Vertex AI SDK כדי להציג ניסויים
Vertex AI SDK מאפשר לכם לעקוב אחרי הסטטוס של הפעלות פייפליין. אפשר גם להשתמש בו כדי להחזיר פרמטרים ומדדים של הפעלות של צינור עיבוד הנתונים ב-Vertex AI Experiment. אפשר להשתמש בקוד הבא כדי לראות את הפרמטרים שמשויכים להרצות ואת המצב הנוכחי שלהן.
# see state/status of all the pipeline runs
vertex_ai.get_experiment_df(EXPERIMENT_NAME)
אפשר להשתמש בקוד שבהמשך כדי לקבל עדכונים על הסטטוס של הפעלות פייפליין.
#check on current status
while True:
pipeline_experiments_df = vertex_ai.get_experiment_df(EXPERIMENT_NAME)
if all(
pipeline_state != "COMPLETE" for pipeline_state in pipeline_experiments_df.state
):
print("Pipeline runs are still running...")
if any(
pipeline_state == "FAILED"
for pipeline_state in pipeline_experiments_df.state
):
print("At least one Pipeline run failed")
break
else:
print("Pipeline experiment runs have completed")
break
time.sleep(60)
אפשר גם להתקשר למשימות ספציפיות בצינור באמצעות run_name.
# Call the pipeline runs based on the experiment run name
pipeline_experiments_df = vertex_ai.get_experiment_df(EXPERIMENT_NAME)
job = vertex_ai.PipelineJob.get(pipeline_experiments_df.run_name[0])
print(job.resource_name)
print(job._dashboard_uri())
לבסוף, אפשר לרענן את הסטטוס של ההרצות במרווחי זמן קבועים (למשל כל 60 שניות) כדי לראות את השינויים בסטטוס מ-RUNNING ל-FAILED או ל-COMPLETE.
# wait 60 seconds and view state again
import time
time.sleep(60)
vertex_ai.get_experiment_df(EXPERIMENT_NAME)
7. זיהוי הריצה עם הביצועים הכי טובים
מעולה, עכשיו יש לנו את התוצאות של הרצת צינורות הנתונים. יכול להיות שאתם שואלים את עצמכם מה אפשר ללמוד מהתוצאות. הפלט מהניסויים צריך להכיל חמש שורות, אחת לכל הרצה של צינור העיבוד. הוא ייראה בערך כך:
המדדים MAE ו-RMSE הם מדדים של שגיאת החיזוי הממוצעת של המודל, ולכן ברוב המקרים רצוי ששני המדדים האלה יהיו נמוכים. מפלט הנתונים של Vertex AI Experiments אפשר לראות שהריצה הכי מוצלחת שלנו בשני המדדים הייתה הריצה האחרונה עם dropout_rate של 0.001, learning_rate אם 0.001, והמספר הכולל של epochs היה 20. על סמך הניסוי הזה, הפרמטרים האלה של המודל ישמשו בסופו של דבר בסביבת הייצור, כי הם מניבים את הביצועים הכי טובים של המודל.
סיימתם את שיעור ה-Lab.
🎉 איזה כיף! 🎉
למדתם איך להשתמש ב-Vertex AI כדי:
- אימון מודל Keras מותאם אישית לחיזוי דירוגים של שחקנים (למשל, רגרסיה)
- שימוש ב-Kubeflow Pipelines SDK כדי לבנות צינורות עיבוד נתונים של למידת מכונה (ML) שניתנים להרחבה
- ליצור ולהריץ צינור (pipeline) בן 5 שלבים שקולט נתונים מ-GCS, משנה את קנה המידה של הנתונים, מאמן את המודל, מעריך אותו ושומר את המודל שנוצר בחזרה ב-GCS
- שימוש ב-Vertex ML Metadata כדי לשמור ארטיפקטים של מודלים, כמו מודלים ומדדי מודלים
- שימוש ב-Vertex AI Experiments כדי להשוות בין התוצאות של ההרצות השונות של צינורות עיבוד הנתונים
מידע נוסף על החלקים השונים של Vertex זמין בתיעוד.
8. הסרת המשאבים
כדי שלא תחויבו, מומלץ למחוק את המשאבים שנוצרו במהלך שיעור ה-Lab הזה.
שלב 1: מפסיקים או מוחקים את מופע Notebooks
אם אתם רוצים להמשיך להשתמש ב-notebook שיצרתם בשיעור Lab הזה, מומלץ לכבות אותו כשאתם לא משתמשים בו. בממשק המשתמש של Notebooks במסוף Cloud, בוחרים את ה-Notebook ואז בוחרים באפשרות Stop (עצירה). אם רוצים למחוק את המופע לגמרי, בוחרים באפשרות מחיקה:
שלב 2: מוחקים את קטגוריית Cloud Storage
כדי למחוק את קטגוריית האחסון, בתפריט הניווט ב-Cloud Console, עוברים אל Storage, בוחרים את הקטגוריה ולוחצים על Delete:
