1. סקירה כללית
בשיעור ה-Lab הזה תשתמשו בכלי 'מה אם' כדי לנתח מודל XGBoost שהודרן על נתונים פיננסיים. אחרי ניתוח המודל, תפרסו אותו ב-Vertex AI החדש של Cloud.
מה תלמדו
תלמדו איך:
- אימון מודל XGBoost במחברת מתארחת על מערך נתונים ציבורי של משכנתאות
- ניתוח המודל באמצעות הכלי 'מה אם'
- פריסה של מודל XGBoost ב-Vertex AI
העלות הכוללת להרצת הסדנה הזו ב-Google Cloud היא כ-$1.
2. מבוא ל-Vertex AI
במעבדה הזו נעשה שימוש במוצרי ה-AI החדשים ביותר שזמינים ב-Google Cloud. Vertex AI משלב את הצעות למידת המכונה ב-Google Cloud ליצירת חוויית פיתוח חלקה. בעבר, היה אפשר לגשת למודלים שהותאמו אישית ולמודלים שהותאמו באמצעות AutoML דרך שירותים נפרדים. המוצר החדש משלב את שניהם ב-API אחד, יחד עם מוצרים חדשים אחרים. אפשר גם להעביר פרויקטים קיימים ל-Vertex AI. יש לך משוב? אפשר למצוא אותו בדף התמיכה.
Vertex AI כולל הרבה מוצרים שונים לתמיכה בתהליכי עבודה של למידת מכונה מקצה לקצה. בשיעור ה-Lab הזה נתמקד במוצרים שמודגשים בהמשך: Prediction ו-Notebooks.
3. מבוא קצר ל-XGBoost
XGBoost היא מסגרת של למידת מכונה שמשתמשת בעצים של החלטות ובשיפור שיפוע (gradient boosting) כדי ליצור מודלים חזויים. האופן שבו המודלים האלה פועלים הוא על ידי יצירת קבוצה של כמה עצי החלטות יחד על סמך הציון שמשויך לצמתי עלים שונים בעץ.
הדיאגרמה הבאה היא תצוגה חזותית של מודל פשוט של עץ החלטות, שמעריך אם כדאי לקיים משחק ספורט על סמך תחזית מזג האוויר:
למה אנחנו משתמשים ב-XGBoost במודל הזה? אומנם נמצא שרשתות נוירונים מסורתיות מניבות את הביצועים הטובים ביותר בנתונים לא מובנים כמו תמונות וטקסט, אבל עצי החלטות בדרך כלל מניבים ביצועים טובים מאוד בנתונים מובְנים כמו מערך הנתונים למשכנתאות שנשתמש בו ב-Codelab הזה.
4. הגדרת הסביבה
כדי להריץ את ה-Codelab הזה צריך פרויקט ב-Google Cloud Platform שהחיוב מופעל בו. כדי ליצור פרויקט, פועלים לפי ההוראות שמפורטות כאן.
שלב 1: מפעילים את ממשק ה-API של Compute Engine
עוברים אל Compute Engine ובוחרים באפשרות Enable (הפעלה) אם היא לא מופעלת. תצטרכו את זה כדי ליצור את מכונה של המחברות.
שלב 2: מפעילים את Vertex AI API
עוברים אל הקטע Vertex במסוף Cloud ולוחצים על Enable Vertex AI API.
שלב 3: יצירת מכונה של Notebooks
בקטע Vertex במסוף Cloud, לוחצים על Notebooks:
משם, בוחרים באפשרות מכונה חדשה. לאחר מכן בוחרים בסוג המכונה TensorFlow Enterprise 2.3 ללא מעבדי GPU:
משתמשים באפשרויות ברירת המחדל ולוחצים על Create. אחרי יצירת המכונה, בוחרים באפשרות Open JupyterLab.
שלב 4: התקנת XGBoost
אחרי שמכונת JupyterLab נפתחת, צריך להוסיף את חבילת XGBoost.
כדי לעשות זאת, בוחרים באפשרות Terminal במרכז האפליקציות:
לאחר מכן, מריצים את הפקודה הבאה כדי להתקין את הגרסה האחרונה של XGBoost שנתמכת על ידי Vertex AI:
pip3 install xgboost==1.2
בסיום התהליך, פותחים מכשיר Notebook של Python 3 מהמרכז לתוכנות. עכשיו אתם יכולים להתחיל לעבוד ב-notebook.
שלב 5: ייבוא חבילות Python
בתא הראשון של המחברות, מוסיפים את פעולות הייבוא הבאות ומריצים את התא. אפשר להריץ אותו על ידי לחיצה על לחצן החץ ימינה בתפריט העליון או על Command-Enter:
import pandas as pd
import xgboost as xgb
import numpy as np
import collections
import witwidget
from sklearn.model_selection import train_test_split
from sklearn.metrics import accuracy_score, confusion_matrix
from sklearn.utils import shuffle
from witwidget.notebook.visualization import WitWidget, WitConfigBuilder
5. הורדה ועיבוד של נתונים
נשתמש במערך נתונים של משכנתאות מ-ffiec.gov כדי לאמן מודל XGBoost. ביצענו עיבוד מקדים במערך הנתונים המקורי ויצאנו גרסה קטנה יותר שתוכלו להשתמש בה כדי לאמן את המודל. המודל יחזה אם בקשה מסוימת למשכנתה תאושר או לא.
שלב 1: מורידים את מערך הנתונים שעבר עיבוד מראש
הגדרנו גרסה של מערך הנתונים שזמינה לך ב-Google Cloud Storage. כדי להוריד אותו, מריצים את הפקודה הבאה של gsutil ב-Jupyter notebook:
!gsutil cp 'gs://mortgage_dataset_files/mortgage-small.csv' .
שלב 2: קריאת מערך הנתונים עם Pandas
לפני שנוצר את ה-DataFrame של Pandas, נוצר dict של סוג הנתונים של כל עמודה כדי ש-Pandas יקרא את מערך הנתונים בצורה נכונה:
COLUMN_NAMES = collections.OrderedDict({
'as_of_year': np.int16,
'agency_code': 'category',
'loan_type': 'category',
'property_type': 'category',
'loan_purpose': 'category',
'occupancy': np.int8,
'loan_amt_thousands': np.float64,
'preapproval': 'category',
'county_code': np.float64,
'applicant_income_thousands': np.float64,
'purchaser_type': 'category',
'hoepa_status': 'category',
'lien_status': 'category',
'population': np.float64,
'ffiec_median_fam_income': np.float64,
'tract_to_msa_income_pct': np.float64,
'num_owner_occupied_units': np.float64,
'num_1_to_4_family_units': np.float64,
'approved': np.int8
})
בשלב הבא ניצור DataFrame ונעביר לה את סוגי הנתונים שפירטנו למעלה. חשוב לערבב את הנתונים שלנו למקרה שמערך הנתונים המקורי מסודר בצורה ספציפית. לשם כך אנחנו משתמשים בכלי עזר של sklearn בשם shuffle, שיובא בתא הראשון:
data = pd.read_csv(
'mortgage-small.csv',
index_col=False,
dtype=COLUMN_NAMES
)
data = data.dropna()
data = shuffle(data, random_state=2)
data.head()
data.head() מאפשרת לנו לראות תצוגה מקדימה של חמש השורות הראשונות של מערך הנתונים ב-Pandas. אחרי שתפעילו את התא שלמעלה, התוצאה אמורה להיראות כך:
אלה התכונות שבהן נשתמש כדי לאמן את המודל שלנו. אם גוללים עד הסוף, מופיעה העמודה האחרונה approved, שהיא הערך שאנחנו מנסים לחזות. הערך 1 מציין שהבקשה אושרה, והערך 0 מציין שהיא נדחתה.
כדי לראות את ההתפלגות של הערכים שאושרו או נדחו במערך הנתונים וליצור מערך numpy של התוויות, מריצים את הפקודה הבאה:
# Class labels - 0: denied, 1: approved
print(data['approved'].value_counts())
labels = data['approved'].values
data = data.drop(columns=['approved'])
כ-66% ממערך הנתונים מכילים אפליקציות שאושרו.
שלב 3: יצירת עמודה דמה לערכים קטגוריאליים
מערך הנתונים הזה מכיל שילוב של ערכים קטגוריים ומספריים, אבל ב-XGBoost נדרש שכל המאפיינים יהיו מספריים. במקום לייצג ערכים קטגוריאליים באמצעות קידוד one-hot, נשתמש בפונקציה get_dummies של Pandas במודל XGBoost.
הפונקציה get_dummies לוקחת עמודה עם כמה ערכים אפשריים וממירה אותה לסדרה של עמודות שמכילות רק 0 ו-1. לדוגמה, אם הייתה לנו העמודה color (צבע) עם הערכים האפשריים 'blue' (כחול) ו-'red' (אדום), הפונקציה get_dummies תמיר אותה לשתי עמודות בשם 'color_blue' ו-'color_red' עם כל הערכים הבוליאניים 0 ו-1.
כדי ליצור עמודות דמה למאפיינים הקטגוריים שלנו, מריצים את הקוד הבא:
dummy_columns = list(data.dtypes[data.dtypes == 'category'].index)
data = pd.get_dummies(data, columns=dummy_columns)
data.head()
הפעם, בתצוגה המקדימה של הנתונים יוצגו תכונות בודדות (כמו purchaser_type בתמונה שבהמשך) שמפוצלות לכמה עמודות:
שלב 4: חלוקת הנתונים לקבוצות אימון ובדיקה
מושג חשוב בלמידת מכונה הוא חלוקה לאימון ולבדיקה. נשתמש ברוב הנתונים שלנו כדי לאמן את המודל, ונשאיר את השאר לצורך בדיקת המודל על נתונים שהוא לא ראה בעבר.
מוסיפים את הקוד הבא ל-notebook, שמשתמש בפונקציה Scikit-learn train_test_split כדי לפצל את הנתונים שלנו:
x,y = data.values,labels
x_train,x_test,y_train,y_test = train_test_split(x,y)
עכשיו אתם מוכנים ליצור ולאמן את המודל.
6. יצירה, אימון והערכה של מודל XGBoost
שלב 1: הגדרה ואימון של מודל XGBoost
יצירת מודל ב-XGBoost היא פשוטה. נשתמש במחלקה XGBClassifier כדי ליצור את המודל, ונצטרך רק להעביר את הפרמטר objective המתאים למשימה הסיווג הספציפית שלנו. במקרה הזה אנחנו משתמשים ב-reg:logistic כי מדובר בבעיית סיווג בינארית, ואנחנו רוצים שהמודל יניב ערך יחיד בטווח (0,1): 0 עבור 'לא אושר' ו-1 עבור 'אושר'.
הקוד הבא יוצר מודל XGBoost:
model = xgb.XGBClassifier(
objective='reg:logistic'
)
אפשר לאמן את המודל באמצעות שורת קוד אחת, על ידי קריאה לשיטה fit() והעברת נתוני האימון והתוויות אליה.
model.fit(x_train, y_train)
שלב 2: הערכת הדיוק של המודל
עכשיו אנחנו יכולים להשתמש במודל המאומן כדי ליצור תחזיות לגבי נתוני הבדיקה באמצעות הפונקציה predict().
לאחר מכן נשתמש בפונקציה accuracy_score() של Scikit-learn כדי לחשב את הדיוק של המודל שלנו על סמך הביצועים שלו בנתוני הבדיקה. נעביר אליו את ערכי האמת לצד הערכים הצפויים של המודל לכל דוגמה בקבוצת הבדיקות שלנו:
y_pred = model.predict(x_test)
acc = accuracy_score(y_test, y_pred.round())
print(acc, '\n')
רמת הדיוק אמורה להיות כ-87%, אבל היא תשתנה מעט כי תמיד יש רכיב אקראי בלמידת מכונה.
שלב 3: שומרים את המודל
כדי לפרוס את המודל, מריצים את הקוד הבא כדי לשמור אותו בקובץ מקומי:
model.save_model('model.bst')
7. שימוש בכלי What-if כדי לפרש את המודל שלך
שלב 1: יוצרים את התצוגה החזותית של הכלי 'מה אם'
כדי לחבר את הכלי What-if למודל המקומי שלכם, צריך להעביר אליו קבוצת משנה של דוגמאות לבדיקה עם ערכי הבסיס לאמת את הדוגמאות האלה. נוצר מערך Numpy של 500 דוגמאות הבדיקה שלנו, יחד עם תוויות האמת שלהן:
num_wit_examples = 500
test_examples = np.hstack((x_test[:num_wit_examples],y_test[:num_wit_examples].reshape(-1,1)))
כדי ליצור מופע של הכלי 'מה אם', פשוט יוצרים אובייקט WitConfigBuilder ומעבירים אליו את המודל שרוצים לנתח.
מכיוון שהכלי What-if מצפה לרשימת ציונים לכל כיתה במודל שלנו (במקרה הזה 2), נשתמש בשיטה predict_proba של XGBoost עם הכלי What-If:
config_builder = (WitConfigBuilder(test_examples.tolist(), data.columns.tolist() + ['mortgage_status'])
.set_custom_predict_fn(model.predict_proba)
.set_target_feature('mortgage_status')
.set_label_vocab(['denied', 'approved']))
WitWidget(config_builder, height=800)
לתשומת ליבכם: תהליך הטעינה של התצוגה החזותית יימשך דקה. כשהדף ייטען, אמורה להופיע ההודעה הבאה:
ציר ה-y מציג את החיזוי של המודל, כאשר 1 הוא חיזוי approved עם רמת ביטחון גבוהה, ו-0 הוא חיזוי denied עם רמת ביטחון גבוהה. ציר ה-x הוא רק ההתפשטות של כל נקודות הנתונים שהועלו.
שלב 2: סקירת נקודות ספציפיות על הגרף
תצוגת ברירת המחדל בכלי 'מה אם' היא הכרטיסייה עריכת נקודת נתונים. כאן אפשר ללחוץ על כל נקודה ספציפית בתרשים כדי לראות את המאפיינים שלה, לשנות את ערכי המאפיינים ולראות איך השינוי הזה משפיע על התחזית של המודל לגבי נקודה ספציפית בתרשים.
בדוגמה הבאה בחרנו נקודה על הגרף קרובה לסף של 0 .5. בקשת המשכנתא שמשויכת לנקודת הנתונים הספציפית הזו הגיעה מ-CFPB. שינינו את התכונה ל-0 ושינינו גם את הערך של agency_code_Department of Housing and Urban Development (HUD) ל-1 כדי לראות מה יקרה לחיזוי של המודל אם ההלוואה הזו תיווצר מ-HUD:
כפי שאפשר לראות בקטע הימני התחתון של הכלי 'מה אם', שינוי התכונה הזו הפחית באופן משמעותי את תחזית approved של המודל ב-32%. ייתכן שהסיבה לכך היא שהסוכנות שממנה מגיע ההלוואה משפיעה מאוד על הפלט של המודל, אבל נצטרך לבצע ניתוח נוסף כדי לוודא זאת.
בחלק השמאלי התחתון של ממשק המשתמש, אפשר לראות גם את ערך 'אמת בפועל' לכל נקודה על הגרף ולהשוות אותו לחיזוי של המודל:
שלב 3: ניתוח נגדי
לאחר מכן, לוחצים על נקודת נתונים כלשהי ומזיזים את פס ההזזה Show nearest counterfactual datapoint (הצגת נקודת הנתונים הקרובה ביותר של תרחיש חלופי) ימינה:
אם תבחרו באפשרות הזו, תוצג נקודת הנתונים שיש לה ערכי המאפיינים הדומים ביותר לנקודה המקורית שבחרתם, אבל עם תחזית הפוכה. לאחר מכן אפשר לגלול בין ערכי המאפיין כדי לראות איפה היו הבדלים בין שתי נקודות הנתונים (ההבדלים מודגשים בירוק ובכתב מודגש).
שלב 4: בדיקת תרשימים של תלות חלקית
כדי לראות איך כל מאפיין משפיע על התחזיות הכוללות של המודל, מסמנים את התיבה Partial dependence plots (תרשימים של תלות חלקית) ומוודאים שהאפשרות Global partial dependence plots (תרשימים גלובליים של תלות חלקית) מסומנת:
כאן אפשר לראות שיש סיכוי גבוה יותר לדחיית הלוואות שמקורן ב-HUD. הגרף נראה כך כי קוד הסוכנות הוא תכונה בוליאנרית, ולכן הערכים יכולים להיות רק 0 או 1.
applicant_income_thousands היא מאפיין מספרי, ובתרשים התלות החלקית אפשר לראות שהכנסה גבוהה יותר מגדילה מעט את הסבירות לאישור הבקשה, אבל רק עד כ-200,000$. אחרי 200,000$, התכונה הזו לא משפיעה על החיזוי של המודל.
שלב 5: ניתוח הביצועים הכוללים והצדקנות
לאחר מכן, עוברים לכרטיסייה ביצועים והוגנות. כאן מוצגים נתונים סטטיסטיים כוללים של הביצועים ביחס לתוצאות המודל במערך הנתונים שסופק, כולל מטריצות בלבול, עקומות PR ועקומות של ROC.
בוחרים באפשרות mortgage_status בתור המאפיין של Ground Truth כדי להציג מטריצת בלבול:
במטריצה של הבלבול מוצגים התחזיות הנכונות והשגויות של המודל שלנו כאחוז מתוך סך הכול. אם מוסיפים את הריבועים Actual / Predicted Yes (כן בפועל / חזוי כן) וActual No / Predicted No (לא בפועל / לא חזויה), למעשה מחשבים את אותו ערך בדיוק כמו המודל (במקרה הזה כ-87%, למרות שהמודל עשוי להשתנות מעט כי יש יסוד של אקראיות באימון של מודלים של למידת מכונה).
אפשר גם להתנסות בפס ההזזה של הסף, להעלות ולהוריד את ציון הסיווג החיובי שהמודל צריך להחזיר לפני שהוא מחליט לחזות את הערך approved להלוואה, ולראות איך זה משנה את הדיוק, את הזיהויים החיוביים השגויים ואת הזיהויים השליליים השגויים. במקרה כזה, רמת הדיוק הגבוהה ביותר היא סביב ערך הסף 0.55.
לאחר מכן, בתפריט הנפתח פרוסה לפי, בוחרים באפשרות loan_purpose_Home_purchase:
עכשיו יוצגו הביצועים בשתי קבוצות המשנה של הנתונים: הפלחים '0' ו'1' מייצגים את המקרים שבהם ההלוואה לא מיועדת לרכישת בית, ואת המקרים שבהם ההלוואה מיועדת לרכישת בית. כדי לבדוק אם יש הבדלים בביצועים, כדאי לבדוק את רמת הדיוק, שיעור החיובים השגויים והשליליים השגויים בין שני הפלחים.
אם מרחיבים את השורות כדי להציג את מטריצות הבלבול, אפשר לראות שהמודל צופה 'אישור' ל-70% בערך של בקשות הלוואה לרכישת בית, ורק ל-46% מההלוואות שלא לרכישת בית (אחוזים מדויקים ישתנו בהתאם למודל):
אם בוחרים באפשרות שיוך דמוגרפי מלחצני הבחירה שבצד ימין, שני ערכי הסף יותאמו כך שהמודל יחזה את הערך approved לגבי אחוז דומה של מועמדים בשני הפלחים. מה ההשפעה של הפעולה הזו על הדיוק, על תוצאות חיוביות מוטעות ועל תוצאות שליליות מוטעות בכל פרופיל?
שלב 6: ניתוח של חלוקת התכונות
לבסוף, עוברים לכרטיסייה תכונות בכלי 'מה אם'. כאן מוצגת ההתפלגות של הערכים של כל מאפיין במערך הנתונים:
אפשר להשתמש בכרטיסייה הזו כדי לוודא שמערך הנתונים מאוזן. לדוגמה, נראה שרק מעט מאוד הלוואות במערך הנתונים מקורן בסוכנות השירות החקלאי. כדי לשפר את הדיוק של המודל, יכול להיות שנוסיף עוד הלוואות מהסוכנות הזו אם הנתונים יהיו זמינים.
תיארנו כאן רק כמה רעיונות לבדיקת הכלי What-if. אתם מוזמנים להמשיך לשחק עם הכלי – יש עוד המון תחומים שאפשר לחקור.
8. פריסה של מודל ב-Vertex AI
הדגם שלנו פועל באופן מקומי, אבל יהיה נחמד אם נוכל לבצע חיזויים על סמך הדגם מכל מקום (לא רק ביומן הזה!). בשלב הזה פורסים את הקוד בענן.
שלב 1: יוצרים קטגוריה ב-Cloud Storage עבור המודל
קודם נגדיר כמה משתני סביבה שנשתמש בהם בהמשך הקודלאב. ממלאים את הערכים הבאים בשם הפרויקט ב-Google Cloud, בשם הקטגוריה של אחסון בענן שרוצים ליצור (השם חייב להיות ייחודי ברמה הגלובלית) ובשם הגרסה של הגרסה הראשונה של המודל:
# Update the variables below to your own Google Cloud project ID and GCS bucket name. You can leave the model name we've specified below:
GCP_PROJECT = 'your-gcp-project'
MODEL_BUCKET = 'gs://storage_bucket_name'
MODEL_NAME = 'xgb_mortgage'
עכשיו אנחנו מוכנים ליצור קטגוריית אחסון כדי לאחסן את קובץ המודל של XGBoost. נצביע על הקובץ הזה ב-Vertex AI כשנפרס.
מריצים את פקודת gsutil הבאה מתוך ה-notebook כדי ליצור קטגוריית אחסון אזורית:
!gsutil mb -l us-central1 $MODEL_BUCKET
שלב 2: מעתיקים את קובץ המודל ל-Cloud Storage
בשלב הבא, מעתיקים את קובץ המודל השמור של XGBoost ל-Cloud Storage. מריצים את הפקודה הבאה ב-gsutil:
!gsutil cp ./model.bst $MODEL_BUCKET
נכנסים לדפדפן האחסון במסוף Cloud כדי לוודא שהקובץ הועתק:
שלב 3: יוצרים את המודל ופורסים אותו בנקודת קצה
אנחנו כמעט מוכנים לפרוס את המודל בענן! ב-Vertex AI, מודל יכול להכיל כמה נקודות קצה. קודם נוצר מודל, אחר כך נוצר נקודת קצה בתוך המודל הזה ופורסים אותה.
קודם כול, משתמשים ב-CLI של gcloud כדי ליצור את המודל:
!gcloud beta ai models upload \
--display-name=$MODEL_NAME \
--artifact-uri=$MODEL_BUCKET \
--container-image-uri=us-docker.pkg.dev/cloud-aiplatform/prediction/xgboost-cpu.1-2:latest \
--region=us-central1
הפרמטר artifact-uri יצביע על מיקום האחסון שבו שמרתם את מודל ה-XGBoost. הפרמטר container-image-uri מאפשר ל-Vertex AI לדעת באיזה קונטיינר מובנה להשתמש לצורך הצגת המודלים. בסיום הפקודה, עוברים אל הקטע models במסוף Vertex כדי לקבל את המזהה של המודל החדש. אפשר למצוא אותו כאן:
מעתיקים את המזהה הזה ושומרים אותו במשתנה:
MODEL_ID = "your_model_id"
בשלב הזה צריך ליצור נקודת קצה (endpoint) בתוך המודל הזה. אפשר לעשות זאת באמצעות הפקודה הבאה של gcloud:
!gcloud beta ai endpoints create \
--display-name=xgb_mortgage_v1 \
--region=us-central1
בסיום, המיקום של נקודת הקצה אמור להופיע ביומן הפלט של המחברות. מחפשים את השורה שבה כתוב שנקודת הקצה נוצרה עם נתיב שנראה כך: projects/project_ID/locations/us-central1/endpoints/endpoint_ID. ואז מחליפים את הערכים הבאים במזהים של נקודת הקצה שיצרתם למעלה:
ENDPOINT_ID = "your_endpoint_id"
כדי לפרוס את נקודת הקצה, מריצים את הפקודה הבאה ב-gcloud:
!gcloud beta ai endpoints deploy-model $ENDPOINT_ID \
--region=us-central1 \
--model=$MODEL_ID \
--display-name=xgb_mortgage_v1 \
--machine-type=n1-standard-2 \
--traffic-split=0=100
פריסת נקודת הקצה תימשך כ-5 עד 10 דקות. בזמן הפריסה של נקודת הקצה, עוברים אל הקטע models במסוף. לוחצים על המודל ואמור להופיע סטטוס הפריסה של נקודת הקצה:
בסיום הפריסה, יופיע סימן וי ירוק במקום שבו נמצא סמל הטעינה.
שלב 4: בדיקת המודל שנפרס
כדי לוודא שהמודל שנפרס פועל, אפשר לבדוק אותו באמצעות gcloud כדי לבצע חיזוי. קודם כול, שומרים קובץ JSON עם דוגמה מקבוצת הבדיקות שלנו:
%%writefile predictions.json
{
"instances": [
[2016.0, 1.0, 346.0, 27.0, 211.0, 4530.0, 86700.0, 132.13, 1289.0, 1408.0, 0.0, 0.0, 0.0, 0.0, 1.0, 0.0, 1.0, 0.0, 0.0, 0.0, 0.0, 1.0, 0.0, 1.0, 0.0, 1.0, 0.0, 0.0, 0.0, 1.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 1.0, 0.0, 0.0, 1.0, 0.0]
]
}
מריצים את הפקודה הבאה ב-gcloud כדי לבדוק את המודל:
!gcloud beta ai endpoints predict $ENDPOINT_ID \
--json-request=predictions.json \
--region=us-central1
החיזוי של המודל אמור להופיע בפלט. הדוגמה הזו אושרה, לכן אמור להופיע ערך קרוב ל-1.
9. הסרת המשאבים
אם אתם רוצים להמשיך להשתמש ב-notebook הזה, מומלץ לכבות אותו כשלא משתמשים בו. בממשק המשתמש של Notebooks במסוף Cloud, בוחרים את ה-notebook ואז לוחצים על Stop (עצירה):
כדי למחוק את כל המשאבים שיצרתם בשיעור ה-Lab הזה, תוכלו פשוט למחוק את המכונה של ה-notebook במקום להפסיק אותה.
כדי למחוק את נקודת הקצה שפרסמתם, עוברים לקטע Endpoints במסוף Vertex ולוחצים על סמל המחיקה:
כדי למחוק את קטגוריית האחסון, באמצעות תפריט הניווט במסוף Cloud, עוברים אל Storage (אחסון), בוחרים את הקטגוריה ולוחצים על סמל המחיקה:
