1. סקירה כללית
בשיעור ה-Lab הזה תלמדו להשתמש ב-Vertex AI כדי ליצור צינור עיבוד נתונים לאימון מודל Keras בהתאמה אישית ב-TensorFlow. לאחר מכן נשתמש בפונקציונליות החדשה שזמינה ב-Vertex AI Experiments כדי לעקוב אחרי הפעלות של מודלים ולהשוות ביניהן, כדי לזהות איזה שילוב של היפר-פרמטרים מניב את הביצועים הטובים ביותר.
מה לומדים
תלמדו איך:
- אימון מודל Keras בהתאמה אישית לחיזוי דירוגי שחקנים (למשל, רגרסיה)
- שימוש ב-Kubeflow Pipelines SDK ליצירת צינורות עיבוד נתונים של למידת מכונה שניתן להתאים לעומס
- יצירה והפעלה של צינור עיבוד נתונים בן 5 שלבים שמטמיע נתונים מ-Cloud Storage, מדרג את הנתונים, מאמן את המודל, מעריך אותם ושומר את המודל שנוצר בחזרה ב-Cloud Storage
- שימוש ב-Vertex ML Metadata לשמירת ארטיפקטים של מודלים, כמו מודלים ומדדי מודלים
- להשתמש בניסויים ב-Vertex AI כדי להשוות תוצאות של הפעלות שונות של צינורות עיבוד נתונים
העלות הכוללת להרצת הסדנה הזו ב-Google Cloud היא כ-$1.
2. מבוא ל-Vertex AI
במעבדה הזו נעשה שימוש במוצרי ה-AI החדשים ביותר שזמינים ב-Google Cloud. Vertex AI משלב את הצעות למידת המכונה ב-Google Cloud ליצירת חוויית פיתוח חלקה. בעבר, היה אפשר לגשת למודלים שהותאמו אישית ולמודלים שהותאמו באמצעות AutoML דרך שירותים נפרדים. המוצר החדש משלב את שניהם ב-API אחד, יחד עם מוצרים חדשים אחרים. אפשר גם להעביר פרויקטים קיימים ל-Vertex AI.
Vertex AI כולל מוצרים רבים ושונים לתמיכה בתהליכי עבודה של למידת מכונה מקצה לקצה. שיעור ה-Lab הזה יתמקד במוצרים הבאים: Experiments, Pipelines, ML Metadata ו-Workbench.
3. סקירה כללית של תרחיש לדוגמה
נשתמש במערך נתונים פופולרי של כדורגל שמקורו בסדרת משחקי הווידאו FIFA של EA Sports. הוא כולל יותר מ-25,000 משחקי כדורגל ו-10,000 שחקנים בעונות 2008-2016. הנתונים עברו עיבוד מראש מראש כדי שיהיה לכם קל יותר להתחיל לעבוד. מערך הנתונים הזה יהיה בשימוש לאורך כל הסדנה, ועכשיו אפשר למצוא אותו בקטגוריה ציבורית ב-Cloud Storage. בהמשך הסדנה נספק פרטים נוספים על אופן הגישה למערך הנתונים. המטרה הסופית שלנו היא לחזות את הדירוג הכולל של שחקן על סמך פעולות שונות במשחק, כמו חסימות ובעיטות עונשין.
למה הניסויים ב-Vertex AI מועילים במדעי הנתונים?
מדע הנתונים הוא ניסיוני בטבעו, אחרי הכול, הם נקראים מדענים. מדעני נתונים טובים מבוססים על השערות, ומשתמשים בניסיון ובטעות כדי לבדוק השערות שונות, בתקווה שהחזרות החוזרות יניבו מודל עם ביצועים טובים יותר.
צוותי מדע הנתונים אימצו את הניסוי, אבל לעתים קרובות הם מתקשים לעקוב אחרי העבודה שלהם ואחרי 'הסוד' שהתגלה להם במהלך הניסויים. יכולות להיות לכך כמה סיבות:
- מעקב אחרי משימות אימון יכול להיות מסורבל, ולכן קל לאבד את הקשר בין מה שעובד לבין מה שלא עובד.
- הבעיה הזו הולכת וגוברת כשבודקים צוות של מדע נתונים, כי יכול להיות שלא כל החברים בצוות עוקבים אחרי ניסויים או אפילו משתפים את התוצאות שלהם עם אחרים.
- תיעוד הנתונים גוזל זמן, ורוב הצוותים משתמשים בשיטות ידניות (למשל, גיליונות או מסמכים) שהתוצאה שלהן היא חוסר עקביות ולא מידע שצריך ללמוד ממנו.
tl;dr: הניסויים של Vertex AI עושים את העבודה בשבילכם ועוזרים לכם לעקוב בקלות אחרי הניסויים ולהשוות ביניהם
למה כדאי להשתמש בניסויים של Vertex AI לגיימינג?
משחקים היו תמיד זירת ניסוי ללמידת מכונה ולניסויים ב-ML. משחקים יוצרים מיליארדי אירועים בזמן אמת ביום, אבל הם גם משתמשים בכל הנתונים האלה על ידי ניצול של למידת מכונה וניסויים ב-ML כדי לשפר את חוויות המשחק, לשמר שחקנים ולהעריך את השחקנים השונים בפלטפורמה. לכן חשבנו שמערך נתונים של גיימינג מתאים היטב לתרגיל הניסויים הכולל שלנו.
4. הגדרת הסביבה
כדי להריץ את הקודלה הזה, צריך פרויקט ב-Google Cloud Platform שבו החיוב מופעל. כדי ליצור פרויקט, יש לפעול לפי ההוראות האלה.
שלב 1: מפעילים את ממשק ה-API של Compute Engine
עוברים אל Compute Engine ובוחרים באפשרות Enable (הפעלה) אם היא עדיין לא מופעלת.
שלב 2: מפעילים את Vertex AI API
עוברים אל הקטע Vertex AI במסוף Cloud ולוחצים על Enable Vertex AI API.
שלב 3: יצירת מכונה של Vertex AI Workbench
בקטע Vertex AI במסוף Cloud, לוחצים על Workbench:
מפעילים את Notebooks API, אם הוא לא פועל.
אחרי ההפעלה, לוחצים על מנהלי מחברות:
לאחר מכן בוחרים באפשרות מחברות חדשה.
נותנים שם ל-notebook ולוחצים על הגדרות מתקדמות.
בקטע 'הגדרות מתקדמות', מפעילים את ההגדרה 'כיבוי במצב חוסר פעילות' ומגדירים את מספר הדקות ל-60. המשמעות היא שהמחשב הנייד יכבה באופן אוטומטי כשלא משתמשים בו, כדי שלא תחויבו בעלויות מיותרות.
שלב 4: פותחים את ה-Notebook
אחרי יצירת המכונה, בוחרים באפשרות Open JupyterLab.
שלב 5: אימות (בפעם הראשונה בלבד)
בפעם הראשונה שתשתמשו במכונה חדשה, תתבקשו לבצע אימות. כדי לעשות זאת, פועלים לפי השלבים בממשק המשתמש.
שלב 6: בוחרים את הליבה המתאימה
ב-Managed Notebooks יש כמה ליבות בממשק משתמש אחד. בוחרים את הליבה של Tensorflow 2 (מקומי).
5. שלבי ההגדרה הראשונית ב-Notebook
תצטרכו לבצע סדרת פעולות נוספות כדי להגדיר את הסביבה ב-notebook לפני פיתוח צינור עיבוד הנתונים. השלבים האלה כוללים: התקנת חבילות נוספות, הגדרת משתנים, יצירת קטגוריה של אחסון בענן, העתקת מערך הנתונים של המשחקים מקטגוריית אחסון ציבורית, וייבוא ספריות והגדרת קבועים נוספים.
שלב 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
לאחר מכן, צריך להפעיל מחדש את Notebook Kernel כדי שתוכלו להשתמש בחבילות שהורדתם בתוך המחברות.
# 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
אין להשתמש בקטגוריה במספר אזורים לאימון באמצעות 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
תצטרכו לציין קטגוריית ת staging ב-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
נגדיר גם קבועים נוספים שנתייחס אליהם בהמשך המחברות, כמו נתיבי הקבצים לנתוני האימון.
#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. אפשר להשתמש בקוד הבא כדי לראות את הפרמטרים שמשויכים להרצות ואת המצב הנוכחי שלהן.
# 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 ליצירת צינורות עיבוד נתונים של למידת מכונה שניתן להתאים לעומס
- יצירת צינור עיבוד נתונים בן 5 שלבים להטמעת נתונים מ-GCS, התאמת הנתונים לעומס, אימון המודל, הערכה שלו ושמירת המודל שנוצר ב-GCS
- שימוש ב-Vertex ML Metadata לשמירת ארטיפקטים של מודלים, כמו מודלים ומדדי מודלים
- שימוש ב-Vertex AI Experiments כדי להשוות בין התוצאות של ההרצות השונות של צינורות עיבוד הנתונים
מידע נוסף על החלקים השונים של Vertex זמין במסמכי העזרה.
8. הסרת המשאבים
כדי שלא תחויבו, מומלץ למחוק את המשאבים שנוצרו במהלך הסדנה.
שלב 1: עצירת המכונה של Notebooks או מחיקת המכונה
אם אתם רוצים להמשיך להשתמש במחברת שיצרתם במעבדה הזו, מומלץ לכבות אותה כשהיא לא בשימוש. בממשק המשתמש של Notebooks במסוף Cloud, בוחרים את המחברות ואז בוחרים באפשרות Stop. אם רוצים למחוק את המכונה לגמרי, בוחרים באפשרות Delete:
שלב 2: מוחקים את הקטגוריה ב-Cloud Storage
כדי למחוק את קטגוריית האחסון, באמצעות תפריט הניווט במסוף Cloud, עוברים אל Storage (אחסון), בוחרים את הקטגוריה ולוחצים על סמל המחיקה:
