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

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

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

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

מה לומדים

נסביר לכם איך:

יצירה והתאמה אישית של מכונה של notebooks ב-AI Platform
עוקבים אחרי קוד קובצי ה-notebook באמצעות Git, שמשולב ישירות ב-notebooks של AI Platform
משתמשים בכלי What-If (אם) ב-notebook.

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

2. יצירת מכונה של AI Platform Notebooks

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

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

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

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

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

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

ל-notebooks של AI Platform יש הרבה אפשרויות שונות להתאמה אישית, כולל: האזור שבו המכונה נפרסת, סוג התמונה, גודל המכונה, מספר יחידות ה-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 ל-notebook

מערכי נתונים רבים זמינים באופן ציבורי ב-BigQuery, מחסן הנתונים (Big Data) של Google Cloud. קובצי notebook של AI Platform תומכים בשילוב ישיר עם BigQuery בלי לדרוש אימות.

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

שלב 1: הורדת נתוני BigQuery ל-notebook שלנו

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

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

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()

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

df['is_male'].value_counts()

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

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

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

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

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

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

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

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

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

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

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

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

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

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

5. פיתוח ואימון של מודל TensorFlow

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

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

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

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

עכשיו אנחנו מוכנים לבנות את מודל TensorFlow!

שלב 2: יצירה ואימון של מודל TensorFlow

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

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() ולהעביר לה את נתוני האימון ואת התוויות שלנו. כאן נשתמש בפרמטר האופציונלי verification_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 ושמירת השינויים

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

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

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

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

git add demo.ipynb

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

git commit -m "Build and train TF model"

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

6. משתמשים בכלי What-If ישירות מה-notebook

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

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

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

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

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

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

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

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

אנחנו ניצור את הכלי What-If (אם) על ידי העברתו 500 דוגמאות ממערך הנתונים המשורשר של מערך הנתונים + תוויות ground ground שיצרנו. אנחנו יוצרים מופע של 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: בודקים את התנהגות המודל באמצעות הכלי What-If

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

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

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

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

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

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

לסיום, נלמד איך לחבר את ה-Git repo במכונה של ה-notebook שלנו למאגר בחשבון 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 במכונת ה-notebook

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

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

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

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

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

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

בכרטיסייה History (היסטוריה) של Notebooks git UI, אתם יכולים לראות אם ההתחייבויות המקומיות שלכם מסונכרנות עם GitHub. בדוגמה הזו, origin/master תואם למאגר שלנו ב-GitHub:

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

8. מזל טוב!

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

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

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

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

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

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

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