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

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

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

מה תלמדו

במאמר הזה נסביר איך:

יצירה והתאמה אישית של מופע של 'שירות ניסוי ופיתוח של AI Platform'
מעקב אחרי קוד ה-notebook באמצעות git, שמשולב ישירות ב-AI Platform Notebooks
שימוש ב-What-If Tool ב-notebook

העלות הכוללת להרצת שיעור ה-Lab הזה ב-Google Cloud היא בערך 1$‎. כאן אפשר למצוא פרטים מלאים על התמחור של מחברות AI Platform.

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

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

שלב 2: הפעלת Compute Engine API

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

שלב 3: יצירת מופע של מחברת

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

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

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

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

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

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

לוחצים לחיצה כפולה על ספריית Codelab החדשה שנוצרה כדי להיכנס אליה, ואז בוחרים במחברת 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 למחברת

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

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

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

נשתמש בספריית הלקוח של Python ל-BigQuery כדי להוריד את הנתונים ל-Pandas DataFrame. מערך הנתונים המקורי הוא בנפח 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()

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

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

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

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

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, או דרך הטרמינל שזמין ב-JupyterLab. בקטע הזה נאחל מאגר git במחברת שלנו ונבצע את השמירה הראשונה באמצעות ממשק המשתמש.

שלב 1: הפעלת מאגר git

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

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

שלב 2: ביצוע הקומיט הראשון

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

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

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

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

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

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

שלב 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

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

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

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

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

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

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

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 במחברות. ה-notebook demo.ipynb אמור להופיע עכשיו בקטע 'השתנה' בממשק המשתמש. מעבירים את העכבר מעל שם הקובץ ולוחצים על סמל ההשוואה:

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

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

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

git add demo.ipynb

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

git commit -m "Build and train TF model"

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

6. שימוש ב-What-If Tool ישירות מ-Notebook

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

כלי ה-What-If מותקן מראש במופעים של מחברות AI Platform ב-Cloud עם TensorFlow. במקרה הזה נשתמש בו כדי לראות את הביצועים הכוללים של המודל ולבדוק את ההתנהגות שלו בנקודות נתונים מתוך קבוצת נתונים לבדיקה.

שלב 1: הכנת הנתונים לשימוש בכלי What-If Tool

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

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

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

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

שלב 2: יצירת מופע של הכלי What-If

ניצור מופע של הכלי What-If Tool על ידי העברת 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)

אחרי שה-What-If Tool נטען, אמור להופיע משהו כזה:

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

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

יש הרבה דברים מגניבים שאפשר לעשות עם What-If Tool. במאמר הזה נסביר על כמה מהם. קודם כל, נסתכל על הכלי לעריכת נקודות נתונים. אפשר לבחור כל נקודה על הגרף כדי לראות את המאפיינים שלה ולשנות את ערכי המאפיינים. מתחילים בלחיצה על נקודה על הגרף כלשהי:

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

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

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

בקישורים שבתחילת הקטע הזה יש עוד רעיונות לשימוש בכלי What-If.

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

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

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

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

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

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

שלב 2: אימות ב-GitHub במופע של מחברות

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

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

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

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

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

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

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

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

8. מזל טוב!

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

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

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

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

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

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

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