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

מודלים של יצירת אב טיפוס ב-notebooks של AI Platform

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

בשיעור ה-Lab הזה תלמדו על כלים שונים ב-AI Platform Notebooks שבעזרתם תוכלו לבחון את הנתונים שלכם וליצור אב טיפוס של מודלים של למידת מכונה.

מה תלמדו

תלמדו איך:

יצירת מכונה של AI Platform Notebooks והתאמה אישית שלה
מעקב אחר הקוד של המחברות באמצעות git, שמשולב ישירות ב-AI Platform Notebooks
שימוש בכלי What-If בתוך המחברות

העלות הכוללת להרצת הסדנה הזו ב-Google Cloud היא כ-$1. כאן אפשר למצוא פרטים מלאים על התמחור של AI Platform Notebooks.

2. יצירת מכונה של 'שירות ניסוי ופיתוח של AI Platform'

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

שלב 2: מפעילים את Compute Engine API

עוברים אל Compute Engine ובוחרים באפשרות Enable (הפעלה) אם היא עדיין לא מופעלת. תצטרכו את זה כדי ליצור את מכונה של המחברות.

שלב 3: יצירת מכונה של מחברת

עוברים אל הקטע AI Platform Notebooks במסוף Cloud ולוחצים על New Instance. לאחר מכן בוחרים את סוג המכונה העדכני ביותר של TensorFlow 2 Enterprise ללא GPUs:

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

ב-AI Platform Notebooks יש הרבה אפשרויות התאמה אישית, כולל: האזור שבו המכונה פרוסה, סוג התמונה, גודל המכונה, מספר המעבדים מסוג GPU ועוד. נשתמש בברירת המחדל לאזור ולסביבה. להגדרת המכונה, נשתמש במכונה מסוג n1-standard-8:

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

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

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

לוחצים לחיצה כפולה על ספריית codelab שנוצרה לאחרונה, ובוחרים ב-notebook של Python 3 במרכז האפליקציות:

משנים את שם ה-notebook ל-demo.ipynb או לשם אחר שרוצים לתת לו.

שלב 4: ייבוא חבילות Python

יוצרים תא חדש ב-notebook ומביאים את הספריות שבהן נשתמש ב-codelab הזה:

import pandas as pd
import tensorflow as tf
from tensorflow.keras import Sequential
from tensorflow.keras.layers import Dense

import numpy as np
import json

from sklearn.model_selection import train_test_split
from sklearn.utils import shuffle
from google.cloud import bigquery
from witwidget.notebook.visualization import WitWidget, WitConfigBuilder

3. חיבור נתוני BigQuery למחברת

BigQuery, מחסן הנתונים (data warehouse) של Google Cloud לנתונים גדולים, מאפשר לכם לחקור מערכי נתונים רבים שזמינים לכולם. AI Platform Notebooks תומך בשילוב ישיר עם BigQuery ללא צורך באימות.

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

שלב 1: מורידים את נתוני BigQuery למחברת

נשתמש בספריית הלקוח של Python ל-BigQuery כדי להוריד את הנתונים ל-DataFrame של Pandas. מערך הנתונים המקורי הוא בנפח 21GB ומכיל 123 מיליון שורות. כדי לפשט את העניינים, נשתמש רק ב-10,000 שורות ממערך הנתונים.

יוצרים את השאילתה ומציגים תצוגה מקדימה של DataFrame שנוצר באמצעות הקוד הבא. כאן אנחנו מקבלים 4 מאפיינים ממערך הנתונים המקורי, יחד עם משקל התינוק (הדבר שהמודל שלנו ינבא). מערך הנתונים חוזר שנים רבות אחורה, אבל במודל הזה נשתמש רק בנתונים מ-2000 ואילך:

query="""
SELECT
  weight_pounds,
  is_male,
  mother_age,
  plurality,
  gestation_weeks
FROM
  publicdata.samples.natality
WHERE year > 2000
LIMIT 10000
"""
df = bigquery.Client().query(query).to_dataframe()
df.head()

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

df.describe()

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

df['is_male'].value_counts()

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

שלב 2: הכנת מערך הנתונים לאימון

עכשיו, אחרי שהורדנו את מערך הנתונים ל-notebook בתור Pandas DataFrame, אנחנו יכולים לבצע עיבוד מקדים ולחלק אותו לקבוצות אימון ובדיקה.

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

df = df.dropna()
df = shuffle(df, random_state=2)

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

labels = df['weight_pounds']
data = df.drop(columns=['weight_pounds'])
data['is_male'] = data['is_male'].astype(int)

עכשיו, אם תציגו תצוגה מקדימה של מערך הנתונים שלנו על ידי הפעלת data.head(), אמורים להופיע ארבע התכונות שבהן נשתמש לאימון.

4. איך מאתחלים את Git

ל-AI Platform Notebooks יש שילוב ישיר עם git, כך שתוכלו לבצע בקרת גרסאות ישירות בסביבת היומן. אפשר להשתמש באפשרות הזו כדי לשמור קוד ישירות בממשק המשתמש של ה-notebook, או דרך ה-Terminal שזמין ב-JupyterLab. בקטע הזה נאתחל מאגר git ב-notebook שלנו ונבצע את השמירה הראשונה דרך ממשק המשתמש.

שלב 1: יצירת מאגר git

בתיקייה של codelab, בוחרים באפשרות Git ואז באפשרות Init בסרגל התפריטים העליון ב-JupyterLab:

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

שלב 2: ביצוע השמירה הראשונה

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

מסמנים את התיבה לצד קובץ היומן demo.ipynb כדי להעביר אותו לשלב ההכנה לשמירה (אפשר להתעלם מהספרייה .ipynb_checkpoints/). מזינים הודעת השמה בתיבת הטקסט ולוחצים על סימן הווי כדי לשמור את השינויים:

מזינים את השם ואת כתובת האימייל כשמתבקשים לעשות זאת. לאחר מכן, חוזרים לכרטיסייה History כדי לראות את השמירה הראשונה:

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

5. יצירה ואימון של מודל TensorFlow

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

שלב 1: חלוקת הנתונים לקבוצות אימון ובדיקה

נשתמש בכלי train_test_split של Scikit Learn כדי לפצל את הנתונים לפני בניית המודל:

x,y = data,labels
x_train,x_test,y_train,y_test = train_test_split(x,y)

עכשיו אנחנו מוכנים ליצור את מודל TensorFlow שלנו.

שלב 2: פיתוח ואימון של מודל TensorFlow

נבנה את המודל הזה באמצעות ממשק ה-API של המודל Sequential של tf.keras, שמאפשר לנו להגדיר את המודל כמקבץ של שכבות. כל הקוד שדרוש לנו כדי ליצור את המודל שלנו מופיע כאן:

model = Sequential([
    Dense(64, activation='relu', input_shape=(len(x_train.iloc[0]),)),
    Dense(32, activation='relu'),
    Dense(1)]
)

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

model.compile(optimizer=tf.keras.optimizers.RMSprop(),
              loss=tf.keras.losses.MeanSquaredError(),
              metrics=['mae', 'mse'])

אפשר להשתמש בפונקציה model.summary() של Keras כדי לראות את הצורה ואת מספר הפרמטרים שניתן לאמן במודל בכל שכבה.

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

model.fit(x_train, y_train, epochs=10, validation_split=0.1)

שלב 3: יצירת תחזיות על דוגמאות לבדיקה

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

num_examples = 10
predictions = model.predict(x_test[:num_examples])

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

for i in range(num_examples):
    print('Predicted val: ', predictions[i][0])
    print('Actual val: ',y_test.iloc[i])
    print()

שלב 4: משתמשים ב-git diff ומבצעים השמירה של השינויים

עכשיו, אחרי שביצעת כמה שינויים במחברת, אפשר לנסות את התכונה git diff שזמינה בממשק המשתמש של git ב-Notebooks. עכשיו, מחברת demo.ipynb אמורה להופיע בקטע 'שונה' בממשק המשתמש. מעבירים את העכבר מעל שם הקובץ ולוחצים על סמל ההשוואה:

כך תוכלו לראות את ההבדלים בין השינויים, כמו בדוגמה הבאה:

הפעם נבצע את השינויים באמצעות שורת הפקודה ב-Terminal. בתפריט Git בסרגל התפריטים העליון של JupyterLab, בוחרים באפשרות Git Command in Terminal. אם הכרטיסייה git בסרגל הצד הימני פתוחה בזמן הריצה של הפקודות הבאות, תוכלו לראות את השינויים ב-UI של git.

במכונה החדשה בטרמינל, מריצים את הפקודה הבאה כדי להעביר את קובץ ה-notebook לשלב ההכנה לשמירה:

git add demo.ipynb

לאחר מכן מריצים את הפקודה הבאה כדי לבצע את השינויים (אפשר להשתמש בכל הודעה שרוצים):

git commit -m "Build and train TF model"

לאחר מכן, ההוספה האחרונה שלכם אמורה להופיע בהיסטוריה:

6. שימוש בכלי 'מה אם' ישירות מהמחברות

הכלי 'מה אם' הוא ממשק חזותי אינטראקטיבי שעוזר להמחיש את מערכי הנתונים ולהבין טוב יותר את הפלט של מודלים של למידת מכונה. זהו כלי בקוד פתוח שנוצר על ידי צוות PAIR ב-Google. הוא פועל עם כל סוג של מודל, אבל יש לו כמה תכונות שנוצרו במיוחד עבור Cloud AI Platform.

הכלי 'מה אם' מותקן מראש במכונות של Cloud AI Platform Notebooks עם TensorFlow. כאן נשתמש בו כדי לראות את הביצועים הכוללים של המודל ולבדוק את ההתנהגות שלו בנקודות נתונים מקבוצת הבדיקות שלנו.

שלב 1: הכנת נתונים לכלי 'מה אם'

כדי להפיק את המקסימום מהכלי 'מה אם', נשלח לו דוגמאות מקבוצת הבדיקות שלנו יחד עם תוויות האמת המוכחת (ground truth) של הדוגמאות האלה (y_test). כך נוכל להשוות בין התחזית של המודל לבין האמת המוכחת. מריצים את שורת הקוד הבאה כדי ליצור DataFrame חדש עם דוגמאות הבדיקה והתוויות שלהן:

wit_data = pd.concat([x_test, y_test], axis=1)

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

def custom_predict(examples_to_infer):
    preds = model.predict(examples_to_infer)
    return preds

שלב 2: יוצרים מופע של הכלי 'מה אם'

כדי ליצור מופע של הכלי 'מה אם', נעביר אליו 500 דוגמאות מקבוצת נתוני הבדיקה המקונצנטרת, יחד עם תוויות האמת הידועה שיצרנו זה עתה. אנחנו יוצרים מופע של WitConfigBuilder כדי להגדיר את הכלי, מעבירים לו את הנתונים שלנו, את פונקציית החיזוי בהתאמה אישית שהגדרנו למעלה, יחד עם היעד (הדבר שאנחנו צופים) וסוג המודל:

config_builder = (WitConfigBuilder(wit_data[:500].values.tolist(), data.columns.tolist() + ['weight_pounds'])
  .set_custom_predict_fn(custom_predict)
  .set_target_feature('weight_pounds')
  .set_model_type('regression'))
WitWidget(config_builder, height=800)

כשהכלי 'מה אם' נטען, אמור להופיע משהו כזה:

בציר x אפשר לראות את נקודות נתוני הבדיקה שמפוזרות לפי ערך המשקל הצפוי של המודל, weight_pounds.

שלב 3: בודקים את התנהגות המודל באמצעות הכלי 'מה אם'

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

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

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

לאחר מכן, מסמנים את הלחצן Partial dependence plots (תרשימי תלות חלקית) בצד ימין. כך אפשר לראות איך כל תכונה משפיעה על התחזית של המודל. לדוגמה, ככל שמשך ההיריון מתארך, גם משקל התינוק הצפוי שהמודל שלנו חוזה עולה:

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

7. אופציונלי: מחברים את מאגר ה-Git המקומי ל-GitHub

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

שלב 1: יוצרים מאגר חדש ב-GitHub

יוצרים מאגר חדש בחשבון GitHub. נותנים לו שם ותיאור, מחליטים אם הוא יהיה גלוי לכולם ובוחרים באפשרות Create repository (לא צריך לאתחל אותו באמצעות קובץ README). בדף הבא תלמדו איך לדחוף מאגר קיים משורת הפקודה.

פותחים חלון Terminal ומוסיפים את המאגר החדש כמאגר מרוחק. מחליפים את username בכתובת ה-URL של המאגר שבהמשך בשם המשתמש שלכם ב-GitHub, ואת your-repo בשם של המאגר שיצרתם:

git remote add origin git@github.com:username/your-repo.git

שלב 2: אימות ב-GitHub במכונה של notebooks

בשלב הבא תצטרכו לבצע אימות ב-GitHub מתוך מכונה של notebook. התהליך משתנה בהתאם להגדרת האימות הדו-שלבי ב-GitHub.

אם אתם לא בטוחים מאיפה להתחיל, תוכלו לפעול לפי השלבים במסמכי העזרה של GitHub כדי ליצור מפתח SSH ואז להוסיף את המפתח החדש ל-GitHub.

שלב 3: מוודאים שקישרתם את המאגר ב-GitHub בצורה נכונה

כדי לוודא שהכול מוגדר כמו שצריך, מריצים את הפקודה git remote -v במסוף. המאגר החדש אמור להופיע כמאגר מרוחק. אחרי שרואים את כתובת ה-URL של המאגר ב-GitHub ומבצעים אימות ב-GitHub מה-notebook, אפשר לדחוף ישירות ל-GitHub מהמכונה של ה-notebook.

כדי לסנכרן את מאגר ה-Git המקומי של היומן עם מאגר ה-GitHub החדש שיצרתם, לוחצים על לחצן ההעלאה לענן בחלק העליון של סרגל הצד של Git:

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

בכרטיסייה 'היסטוריה' בממשק המשתמש של Git ב-Notebooks, אפשר לראות אם השמירות המקומיות מסונכרנות עם GitHub. בדוגמה הזו, origin/master תואם למאגר שלנו ב-GitHub:

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

8. מזל טוב!

עשיתם הרבה בשיעור ה-Lab הזה 👏👏👏

לסיכום, למדתם איך:

יצירת מכונה מותאמת אישית של AI Platform Notebook
איך מפעילים מאגר מקומי של git במכונה הזו, מוסיפים התחייבויות באמצעות ממשק המשתמש של git או שורת הפקודה של git, מציגים את ההבדלים בין גרסאות ב-git בממשק המשתמש של git ב-Notebook
יצירה ואימון של מודל פשוט ב-TensorFlow 2
שימוש בכלי What-If במכונה של Notebook
חיבור מאגר ה-Git של Notebook למאגר חיצוני ב-GitHub

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

אם אתם רוצים להמשיך להשתמש ב-notebook הזה, מומלץ לכבות אותו כשלא משתמשים בו. בממשק המשתמש של Notebooks במסוף Cloud, בוחרים את המחברות ואז בוחרים באפשרות Stop:

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

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