רשתות נוירונים מלאכותיות, עם Keras ומעבדי TPU

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

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

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

שיעור ה-Lab הזה הוא חלק 3 של "Keras on TPU" סדרות. אפשר לעשות את זה בסדר הבא או בנפרד.

• צינורות נתונים במהירות TPU: tf.data.Dataset ו-TFRecords
• מודל Keras הראשון שלכם, עם למידת העברה
• [THIS LAB] רשתות קונבולוציה נוירונים, עם Keras ו-TPU
• המרות מודרניות, דחיסה, Xception, עם Keras ומעבדי TPU

מה תלמדו

• כדי לפתח מסַווג תמונות קונבולוציה באמצעות מודל Keras Sequential.
• כדי לאמן את מודל Keras ב-TPU
• כדי לכוונן את המודל באמצעות בחירה טובה של שכבות קונבולוציה.

משוב

אם תיתקלו בבעיה במעבדת הקוד הזו, נשמח לשמוע על כך. אפשר לשלוח משוב דרך 'בעיות ב-GitHub' [feedback link].

2. התחלה מהירה של Google Colaboratory

בשיעור ה-Lab הזה נעשה שימוש ב'שיתוף פעולה עם Google' ולא נדרשת הגדרה כלשהי מצדך. Colaboratory היא פלטפורמת notebook אונליין למטרות חינוכיות. השירות כולל הדרכות בחינם על מעבדים (CPU), מעבדי GPU ו-TPU.

אפשר לפתוח את ה-notebook לדוגמה ולעבור דרך שני תאים כדי להכיר את Colaboratory.

Welcome to Colab.ipynb

בחירת קצה עורפי של TPU

בתפריט Colab, בוחרים באפשרות סביבת זמן הריצה > משנים את הסוג של סביבת זמן הריצה ואז בוחרים באפשרות TPU. בשיעור ה-Lab הזה תלמדו להשתמש ב-TPU (יחידת עיבוד Tensor) חזקה, לגיבוי לצורך אימון עם האצת חומרה. החיבור לסביבת זמן הריצה יתבצע באופן אוטומטי בהפעלה הראשונה, או שאפשר להשתמש באפשרות Connect (התחברות) בפינה הימנית העליונה.

ביצוע Notebook

כדי להפעיל תאים בכל פעם, לוחצים על תא באמצעות מקש Shift-ENTER. אפשר גם להריץ את כל ה-notebook באמצעות סביבת זמן הריצה > הפעלה של הכול

תוכן העניינים

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

תאים מוסתרים

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

אימות

ל-Colab יש אפשרות לגשת לקטגוריות הפרטיות שלך ב-Google Cloud Storage בתנאי שביצעת אימות באמצעות חשבון מורשה. קטע הקוד שלמעלה יפעיל תהליך אימות.

3. [מידע] מהן יחידות עיבוד של Tensor (TPU)?

בקצרה

מערכות TPU הן מאיצי חומרה שמתמחים במשימות של למידה עמוקה (Deep Learning). בשיעור ה-Lab הזה תלמדו איך להשתמש ב-Keras וב-Tensorflow 2. מעבדי Cloud TPU זמינים בתצורה בסיסית עם 8 ליבות וגם בתצורות גדולות יותר הנקראות 'שקעי TPU'. של עד 2,048 ליבות. אפשר להשתמש בחומרה הנוספת כדי להאיץ את האימון על ידי הגדלת קבוצת האימון.

הקוד לאימון מודל על TPU ב-Keras (ומפסיקים להשתמש ב-GPU או במעבד אם ה-TPU לא זמין):

try: # detect TPUs
    tpu = tf.distribute.cluster_resolver.TPUClusterResolver.connect()
    strategy = tf.distribute.TPUStrategy(tpu)
except ValueError: # detect GPUs
    strategy = tf.distribute.MirroredStrategy() # for CPU/GPU or multi-GPU machines

# use TPUStrategy scope to define model
with strategy.scope():
  model = tf.keras.Sequential( ... )
  model.compile( ... )

# train model normally on a tf.data.Dataset
model.fit(training_dataset, epochs=EPOCHS, steps_per_epoch=...)

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

למה דווקא מעבדי TPU?

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

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

החומרה

MXU ו-VPU

ליבת TPU v2 מורכבת מיחידת הכפלת מטריצות (MXU) שמפעילה הכפלת מטריצות ויחידה לעיבוד וקטורים (VPU) לכל המשימות האחרות כמו הפעלות, softmax וכו'. ה-VPU מטפל בחישובים של float32 ו-int32. מצד שני, MXU פועל בפורמט נקודה צפה (floating-point) ברמת דיוק מעורב של 16-32 ביט.

נקודה צפה (floating-point) מעורבת ו-bfloat16

ה-MXU מחשב את הכפלת המטריצות באמצעות קלט bfloat16 ופלט float32. הצטברות ביניים מבוצעות ברמת דיוק של float32.

האימון של רשת נוירונים עמיד בדרך כלל לרעש שנוצר על ידי דיוק מופחת של נקודה צפה (floating-point). יש מקרים שבהם רעש אפילו עוזר לכלי האופטימיזציה להתכנס. בעבר נעשה שימוש בדיוק של נקודה צפה (floating-point) של 16 ביט כדי להאיץ את החישובים, אבל לפורמטים float16 ו-float32 יש טווחים שונים מאוד. הפחתת רמת הדיוק מ-float32 ל-float16 בדרך כלל מובילה לזרימה חוזרת ונשנית. קיימים פתרונות, אבל בדרך כלל נדרשת עבודה נוספת כדי שהמערכת תזהה את התכונה float16.

לכן Google השיקה את הפורמט bfloat16 במעבדי TPU. bfloat16 הוא float קטוע 32 עם אותם ביטים וטווח של מעריך בדיוק כמו float32. זאת, בנוסף לעובדה שיחידות TPU מחשבים הכפלות של מטריצות ברמת דיוק מעורבת עם קלט bfloat16 אבל פלט float32, ופירוש הדבר שבדרך כלל לא נדרשים שינויים בקוד כדי לשפר את הביצועים ברמת דיוק מופחתת.

השימוש ברמת דיוק מעורבת של bfloat16/float32 הוא ברירת המחדל במעבדי TPU. כדי להפעיל אותו, אין צורך לבצע שינויים בקוד של Tensorflow. עדיין אפשר לעבוד עם float32 במהלך הקוד. כשמבצעים הכפלה של מטריצה, ה-TPU יקצר את ערכי הקלט שלו באופן אוטומטי ל-bfloat16. המטריצה שמתקבלת היא float32.

מערך סיסטולי

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

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

Y[2,0] = X[2,0]*W[0,0] + X[2,1]*W[1,0] + X[2,2]*W[2,0] + ... + X[2,n]*W[n,0]

ב-GPU, משתמש יתכנת את מוצר הנקודה הזה ל'ליבה' של GPU. ואז לבצע אותו בכמה "ליבות" מכיוון שהם זמינים במקביל כדי לנסות ולחשב כל ערך של המטריצה שמתקבלת בבת אחת. אם המטריצה שמתקבלת היא 128x128 גדולה, יידרשו 128x128=16K "ליבות" להיות זמינים, ובדרך כלל זה לא אפשרי. למעבדי ה-GPU הגדולים ביותר יש כ-4,000 ליבות. מצד שני, TPU משתמש במינימום הנדרש של החומרה עבור יחידות המחשוב ב-MXU: רק bfloat16 x bfloat16 => float32 מכפילים, שום דבר אחר. הם כל כך קטנים ש-TPU יכול ליישם 16K מהם ב-MXU של 128x128 ולעבד את הכפלת המטריצה הזו בפעם אחת.

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

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

Cloud TPU

כאשר תבקשו " Cloud TPU גרסה 2 ב-Google Cloud Platform, מקבלים מכונה וירטואלית (VM) עם לוח TPU שמחובר ל-PCI. בלוח ה-TPU יש ארבעה שבבי TPU עם שתי ליבות. כל ליבת TPU כוללת VPU (יחידת עיבוד וקטורי) ו-MXU 128x128 (יחידת הכפלה של MatriX). ה-"Cloud TPU" הזה בדרך כלל מחובר למכונה הווירטואלית שביקשה אותה דרך הרשת. התמונה המלאה נראית כך:

איור: מכונה וירטואלית עם "Cloud TPU" שמחובר לרשת מאיץ. "The Cloud TPU" עצמה מורכבת ממכונה וירטואלית עם לוח TPU מחובר PCI עם ארבעה שבבי TPU עם שתי ליבות.

מארזי TPU

במרכזי הנתונים של Google, מערכות ה-TPU מחוברות לחיבור מחשוב בעל ביצועים גבוהים (HPC), שיכול לגרום להן להופיע כמאיץ אחד גדול מאוד. Google מכנה אותם Pods והם יכולים לכלול עד 512 ליבות TPU v2 או 2048 ליבות TPU v3.

איור: pod TPU v3. לוחות ומדפים של TPU שמחוברים דרך חיבור HPC.

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

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

התוכנה

הדרכה לקבוצות גדולות

גודל אצווה אידיאלי למעבדי TPU הוא 128 פריטי נתונים לכל ליבת TPU, אבל החומרה כבר יכולה להראות ניצול טוב מ-8 פריטי נתונים לכל ליבת TPU. חשוב לזכור של-Cloud TPU אחד יש 8 ליבות.

במעבדה הזו של הקוד נשתמש ב-Keras API. ב-Keras, המקבץ שאתם מציינים הוא גודל האצווה הגלובלי של כל ה-TPU. האצוות יפוצלו אוטומטית ל-8 ויפעלו על 8 ליבות ה-TPU.

לטיפים נוספים בנושא ביצועים, אפשר לעיין במדריך לביצועים של TPU. אם מדובר בכמויות גדולות מאוד, ייתכן שיידרש טיפול מיוחד במודלים מסוימים, ראו LARSOptimizer לפרטים נוספים.

טיפול יסודי: XLA

תוכנות Tensorflow מגדירות גרפים של מחשוב. ה-TPU לא מריץ ישירות קוד Python, אלא מריץ את תרשים החישוב שהוגדר על ידי תוכנת Tensorflow. אבל בקצרה, מהדר בשם XLA (מהדר (compiler לינארי) מואץ' ממיר את תרשים Tensorflow של צומתי החישוב לקוד של מכונת TPU. המהדר הזה מבצע גם הרבה אופטימיזציות מתקדמות בקוד שלכם ובפריסת הזיכרון שלכם. האיסוף מתבצע באופן אוטומטי כשהעבודה נשלחת ל-TPU. אין צורך לכלול XLA באופן מפורש בשרשרת ה-build.

איור: כדי לרוץ ב-TPU, תרשים החישוב שהוגדר על ידי תוכנית Tensorflow מתורגם קודם לייצוג XLA (מהידר אלגברה מואצת) ואז הידור באמצעות XLA לקוד מכונה של TPU.

שימוש במעבדי TPU ב-Keras

החל מ-Tensorflow 2.1 יש תמיכה במעבדי TPU דרך Keras API. התמיכה ב-Keras פועלת עם מעבדי TPU ושקעי TPU. דוגמה שעובדת ב-TPU, ב-GPU ובמעבדים:

try: # detect TPUs
    tpu = tf.distribute.cluster_resolver.TPUClusterResolver.connect()
    strategy = tf.distribute.TPUStrategy(tpu)
except ValueError: # detect GPUs
    strategy = tf.distribute.MirroredStrategy() # for CPU/GPU or multi-GPU machines

# use TPUStrategy scope to define model
with strategy.scope():
  model = tf.keras.Sequential( ... )
  model.compile( ... )

# train model normally on a tf.data.Dataset
model.fit(training_dataset, epochs=EPOCHS, steps_per_epoch=...)

בקטע הקוד הזה:

• TPUClusterResolver().connect() מוצא את ה-TPU ברשת. התכונה פועלת ללא פרמטרים ברוב מערכות Google Cloud (משימות AI Platform, Colaboratory, Kubeflow, מכונות וירטואליות של למידה עמוקה שנוצרו באמצעות הכלי ctpu up). המערכות האלה יודעות איפה נמצא ה-TPU שלהן בזכות משתנה הסביבה TPU_NAME. אם יוצרים TPU באופן ידני, צריך להגדיר את סביבת TPU_NAME. משתנה במכונה הווירטואלית שממנה משתמשים בו, או קוראים לפונקציה TPUClusterResolver עם פרמטרים מפורשים: TPUClusterResolver(tp_uname, zone, project)
• TPUStrategy הוא החלק שבו מיישם את ההתפלגות ואת "all-reduce" אלגוריתם לסנכרון הדרגתי.
• האסטרטגיה מיושמת באמצעות היקף. המודל חייב להיות מוגדר בתוך ההיקף() של האסטרטגיה.
• הפונקציה tpu_model.fit מצפה לאובייקט tf.data.Dataset לקלט לצורך אימון TPU.

משימות נפוצות של ניוד TPU

• במודל Tensorflow יש הרבה דרכים לטעון נתונים, אבל עבור מעבדי TPU חובה להשתמש ב-API של tf.data.Dataset.
• מעבדי TPU מהירים מאוד ומטמיעים נתונים בדרך כלל הופכים לצוואר בקבוק כשהם פועלים עליהם. במדריך הביצועים של TPU יש כלים שבהם אפשר להשתמש כדי לזהות צווארי בקבוק בנתונים וטיפים אחרים לשיפור הביצועים.
• מספרי int8 או int16 נחשבים כ-int32. ל-TPU אין חומרת מספרים שלמים שפועלת על פחות מ-32 ביטים.
• חלק מהפעולות של Tensorflow לא נתמכות. הרשימה כבר כאן. החדשות הטובות הן שההגבלה הזו חלה רק על קוד אימון, כלומר המעבר קדימה ואחורה במודל שלכם. עדיין אפשר להשתמש בכל פעולות Tensorflow בצינור עיבוד הנתונים של קלט הנתונים כי הן יבוצעו במעבד (CPU).
• tf.py_func לא נתמך ב-TPU.

4. [INFO] מסווג רשת נוירונים 101

בקצרה

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

מסווג של רשת נוירונים עשוי מכמה שכבות של נוירונים. בסיווג תמונות יכולות להיות שכבות דחוסות או שכבות עמוסות יותר. בדרך כלל הם מופעלים באמצעות פונקציית ההפעלה relu. השכבה האחרונה משתמשת בכמה נוירונים ככל שיש מחלקות, ומופעלת באמצעות softmax. לסיווג, Cross-entropy היא פונקציית loss הנפוצה ביותר. היא משווה בין התוויות המקודדות לפי one-hot (כלומר תשובות נכונות) להסתברויות שחזות רשת הנוירונים. כדי למזער את הסיכון, מומלץ לבחור כלי אופטימיזציה עם מומנטום, לדוגמה AdamOptimizer ולהתאמן על אצווה של תמונות ותוויות לאימון.

עבור מודלים שנוצרו כרצף של שכבות, Keras מציעה את Sequential API. לדוגמה, אפשר לכתוב ב-Keras מסווג תמונות שמשתמש בשלוש שכבות צפופות כך:

model = tf.keras.Sequential([
    tf.keras.layers.Flatten(input_shape=[192, 192, 3]),
    tf.keras.layers.Dense(500, activation="relu"),
    tf.keras.layers.Dense(50, activation="relu"),
    tf.keras.layers.Dense(5, activation='softmax') # classifying into 5 classes
])

# this configures the training of the model. Keras calls it "compiling" the model.
model.compile(
  optimizer='adam',
  loss= 'categorical_crossentropy',
  metrics=['accuracy']) # % of correct answers

# train the model
model.fit(dataset, ... )

רשת נוירונים צפופה

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

אפשר להזין תמונה לרשת כזו על ידי יישור ערכי ה-RGB של כל הפיקסלים שלה לווקטור ארוך ושימוש בהם כקלט. זו לא השיטה הטובה ביותר לזיהוי תמונות, אבל נשפר אותה בהמשך.

נוירונים, הפעלות, RELU

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

פונקציית ההפעלה הפופולרית ביותר נקראת RELU עבור Rectified Linear Unit (יחידה לינארית מתוקנת). זוהי פונקציה פשוטה מאוד כפי שניתן לראות בתרשים שלמעלה.

הפעלת Softmax

הרשת שלמעלה מסתיימת בשכבה של 5 נוירונים מכיוון שאנחנו מסווגים את הפרחים ל-5 קטגוריות (ורד, צבעוני, שן הארי, חיננית, חמנית). נוירונים בשכבות ביניים מופעלים באמצעות פונקציית ההפעלה הקלאסית של RELU. בשכבה האחרונה אנחנו רוצים לחשב את המספרים בין 0 ל-1, שמייצגים את ההסתברות שבה פרח זה יהיה ורד, צבעוני וכן הלאה. לשם כך נשתמש בפונקציית הפעלה שנקראת "softmax".

אפשר להחיל softmax על וקטור

למה המילה "softmax" שנקרא softmax? המעריכיות היא פונקציה במגמת עלייה תכופה. זה יגדיל את ההבדלים בין פלטי הנוירונים. לאחר מכן, כשמנורמלים את הווקטור, היבט הגדול ביותר, ששולט בנורמה, עובר נירמול לערך שקרוב ל-1, וכל שאר הרכיבים יתחלקו בערך גדול וינורמלו לערך שקרוב ל-0. הווקטור שמתקבל מראה בבירור איזו מחלקה המנצחת, ה'מקסימלית', אבל שומר על הסדר היחסי המקורי של הערכים שלו, ולכן ה'רך'.

הפסד חוצה-אנטרופיה

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

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

"One-Hot" פירושו שהתווית '3) שן הארי באמצעות וקטור של 5 ערכים, כל האפסים מלבד הערך השלישי שהוא 1. הווקטור הזה מייצג הסתברות של 100% להיות שן הארי. רשת הנוירונים שלנו גם מפיקה את התחזיות שלה בתור וקטור של 5 ערכי הסתברות. קל להשוות ביניהם.

ירידה הדרגתית

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

ה-cross-entropy הוא פונקציה של משקולות, הטיות, פיקסלים של תמונת האימון והסיווג הידוע שלה.

אם נחשב את הנגזרות החלקיות של ה-Cross-entropy ביחס לכל המשקולות ולכל ההטיות, נקבל 'הדרגתיות', המחושב עבור תמונה, תווית וערך נוכחי של משקולות והטיות. זכרו שיש לנו מיליוני משקולות והטיות, ולכן חישוב ההדרגתיות נשמע כמו עבודה רבה. למרבה המזל, Tensorflow עושה את זה בשבילנו. התכונה המתמטית של שיפוע הוא שהוא מצביע "למעלה". מכיוון שאנחנו רוצים להגיע למקום שבו ה-cross-entropy הוא נמוך, אנחנו הולכים בכיוון ההפוך. אנחנו מעדכנים את המשקל וההטיות לפי חלק מההדרגתיות. לאחר מכן אנחנו מבצעים את אותו הדבר שוב ושוב באמצעות הקבוצות הבאות של תמונות ותוויות לאימון, בלולאת אימון. אנו מקווים שזה מתכנס למקום שבו ה-cross-entropy הוא מינימלי, אם כי שום דבר לא מבטיח שהמינימום הזה ייחודי.

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

מיני-אצווה ומומנטום

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

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

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

איור: נקודת אוכף. ההדרגתיות היא 0 אך הוא לא ערך מינימלי בכל הכיוונים. (קרדיט תמונה Wikimedia: By Nicoguaro – Own work, CC BY 3.0)

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

בספריית Tensorflow יש מגוון רחב של כלי אופטימיזציה, החל מ-tf.train.GradientDescentOptimizer. כלי אופטימיזציה פופולריים מתקדמים יותר עם מומנטום מובנה הם tf.train.RMSPropOptimizer או tf.train.AdamOptimizer.

מילון מונחים

אצווה או מיני-אצווה: האימון תמיד מתבצע על קבוצות של נתוני אימון ותוויות. הפעולה הזו עוזרת לאלגוריתם להתמזג. "האצווה" הוא בדרך כלל המימד הראשון של מזיני הנתונים. לדוגמה, Tensor של צורה [100, 192, 192, 3] מכיל 100 תמונות של 192x192 פיקסלים עם שלושה ערכים לכל פיקסל (RGB).

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

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

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

labels: שם אחר ל-"classes" או נכונות תשובות בעייתיות בסיווג בפיקוח

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

logits: הפלט של שכבת נוירונים לפני הפעלת פונקציית ההפעלה נקראים 'logits'. המונח מגיע מהפונקציה הלוגיסטית. נקרא גם "פונקציית sigmoid" שהיתה בעבר פונקציית ההפעלה הפופולרית ביותר. "פלט נוירונים לפני פונקציה לוגיסטית" קוצר ל-"logit".

loss (הפסד): פונקציית השגיאה שמשווה בין פלטי רשת נוירונים לתשובות הנכונות

neuron: מחשב את הסכום המשוקלל של הקלט, מוסיף הטיה ומזין את התוצאה באמצעות פונקציית הפעלה.

קידוד חם אחד: מחלקה 3 מתוך 5 מקודדת בתור וקטור של 5 רכיבים, כל אפסים חוץ מהאפס השלישי שהוא 1.

relu: יחידה לינארית מתוקנת. פונקציית הפעלה פופולרית לנוירונים.

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

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

tensor: "tensor" דומה למטריצה, אבל עם מספר שרירותי של מאפיינים. טנזור חד-ממדי הוא וקטור. מפריד דו-ממדי הוא מטריצה. לאחר מכן יכולים להיות רכיבי Tensor עם 3, 4, 5 או יותר מאפיינים.

5. [מידע חדש] רשתות נוירונים מלאכותיות

בקצרה

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

איור: סינון תמונה עם שני פילטרים עוקבים שמורכבים מ-48 x 4 x 48 משקולות לכל אחד מהם.

רשתות נוירונים מלאכותיות מחילות סדרה של מסננים שניתן ללמוד על תמונת הקלט. שכבה קונבולוציה מוגדרת לפי גודל המסנן (או הליבה), מספר המסננים והצעד. לקלט ולפלט של שכבה קונבולוציונית יש שלושה ממדים (רוחב, גובה, מספר ערוצים), החל בתמונת הקלט (רוחב, גובה וערוצי RGB). כשקובעים שכבות קונבולוציה, אפשר לשנות את הרוחב והגובה של הפלט באמצעות צעדים > 1, או באמצעות פעולת איסוף מקסימלי. אפשר לשנות את העומק של הפלט (nb של ערוצים) באמצעות יותר או פחות מסננים.

כך נראית רשת עצבית מתקפלת פשוטה ב-Keras:

model = tf.keras.Sequential([
  # input: images of size 192x192x3 pixels (the three stands for RGB channels)
  tf.keras.layers.Conv2D(kernel_size=3, filters=24, padding='same', activation='relu', input_shape=[192, 192, 3]),
  tf.keras.layers.Conv2D(kernel_size=3, filters=24, padding='same', activation='relu'),
  tf.keras.layers.MaxPooling2D(pool_size=2),
  tf.keras.layers.Conv2D(kernel_size=3, filters=12, padding='same', activation='relu'),
  tf.keras.layers.MaxPooling2D(pool_size=2),
  tf.keras.layers.Conv2D(kernel_size=3, filters=6, padding='same', activation='relu'),
  tf.keras.layers.Flatten(),
  # classifying into 5 categories
  tf.keras.layers.Dense(5, activation='softmax')
])

model.compile(
  optimizer='adam',
  loss= 'categorical_crossentropy',
  metrics=['accuracy'])

רשתות קונבולוציה 101

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

עם זאת, 48 משקולות לא מספיקות. כדי להוסיף עוד דרגות חופש, אנחנו חוזרים על אותה פעולה עם קבוצת משקולות חדשה. הפעולה הזו תפיק קבוצה חדשה של פלט מסננים. שנקרא 'ערוץ' של פלטים באנלוגיה עם הערוצים R,G,B בתמונת הקלט.

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

איור: רשת עצבית מתקפלת משנה 'קוביות' של נתונים ל"קוביות" אחרות של נתונים.

קיפולים (קונבולציות) ברצף, צבירה מקסימלית

אם מבצעים את הקונבולוציות בקצב של 2 או 3, אפשר גם לכווץ את קוביית הנתונים שמתקבלת בממדים האופקיים שלה. אפשר לעשות זאת ב-2 דרכים נפוצות:

• קונבולציה זזה: מסנן הזזה כמו למעלה, אבל עם צעדים >1
• קיבוץ מקסימלי: חלון הזזה שמבצע את הפעולה MAX (בדרך כלל בתיקונים בגודל 2x2, שחוזר על עצמו כל 2 פיקסלים)

איור: החלקת חלון המחשוב ב-3 פיקסלים תוביל לפחות ערכי פלט. קונבולוציות חדות או צבירה מקסימלית (מקסימום בחלון של 2x2 עם החלקה בצעד של 2) הן דרך לכווץ את קוביית הנתונים במידות האופקיות.

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

מסווג מסתובב

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

איור: מסווג תמונות באמצעות שכבות קונבולוציה ושכבות softmax. היא משתמשת במסננים ביחס של 3x3 ו-1x1. השכבות של maxpool מתאימות למקסימום של 2x2 נקודות נתונים. ראש הסיווג מוטמע בשכבה צפופה עם הפעלה softmax.

ב-Keras

אפשר לכתוב ב-Keras את הערימה המתקפלת שמתוארת למעלה כך:

model = tf.keras.Sequential([
  # input: images of size 192x192x3 pixels (the three stands for RGB channels)    
  tf.keras.layers.Conv2D(kernel_size=3, filters=32, padding='same', activation='relu', input_shape=[192, 192, 3]),
  tf.keras.layers.Conv2D(kernel_size=1, filters=32, padding='same', activation='relu'),
  tf.keras.layers.MaxPooling2D(pool_size=2),
  tf.keras.layers.Conv2D(kernel_size=3, filters=32, padding='same', activation='relu'),
  tf.keras.layers.Conv2D(kernel_size=1, filters=32, padding='same', activation='relu'),
  tf.keras.layers.MaxPooling2D(pool_size=2),
  tf.keras.layers.Conv2D(kernel_size=3, filters=32, padding='same', activation='relu'),
  tf.keras.layers.Conv2D(kernel_size=1, filters=32, padding='same', activation='relu'),
  tf.keras.layers.MaxPooling2D(pool_size=2),
  tf.keras.layers.Conv2D(kernel_size=3, filters=32, padding='same', activation='relu'),
  tf.keras.layers.Conv2D(kernel_size=1, filters=32, padding='same', activation='relu'),
  tf.keras.layers.MaxPooling2D(pool_size=2),
  tf.keras.layers.Conv2D(kernel_size=3, filters=16, padding='same', activation='relu'),
  tf.keras.layers.Conv2D(kernel_size=1, filters=8, padding='same', activation='relu'),
  tf.keras.layers.Flatten(),
  # classifying into 5 categories
  tf.keras.layers.Dense(5, activation='softmax')
])

model.compile(
  optimizer='adam',
  loss= 'categorical_crossentropy',
  metrics=['accuracy'])

לפרמטר המרווח הפנימי בשכבות קונבולוציה יכולים להיות שני ערכים:

• "same": משטח עם אפסים כדי ליצור פלטים באותו רוחב/גובה כמו הקלט
• "regular" (תקין): ללא מרווח פנימי, יש להשתמש רק בפיקסלים אמיתיים

6. המרה מותאמת אישית

שיחה קולית

בואו לבנות ולאמן מחדש רשת נוירונים קונבולוציה. השימוש ב-TPU יאפשר לנו לבצע איטרציה במהירות רבה. פותחים את ה-notebook הבא, מריצים את התאים (Shift-ENTER) ופועלים לפי ההוראות בכל מקום שבו מופיע הכיתוב 'נדרשת עבודה' התיוג.

Keras_Flowers_TPU (playground).ipynb

המטרה היא לגבור על רמת הדיוק של 75% מהמודל של למידת ההעברה. למודל הזה יש יתרון: הוא עבר אימון מראש על מערך נתונים של מיליוני תמונות, ויש לנו כאן רק תמונות ב-3670. האם תוכלו לפחות להתאים אותה?

מידע נוסף

כמה שכבות, מה הגודל?

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

Layer (type)                 Output Shape              Param #   
=================================================================
conv2d (Conv2D)              (None, 192, 192, 16)      448       
_________________________________________________________________
conv2d_1 (Conv2D)            (None, 192, 192, 30)      4350      
_________________________________________________________________
max_pooling2d (MaxPooling2D) (None, 96, 96, 30)        0         
_________________________________________________________________
conv2d_2 (Conv2D)            (None, 96, 96, 60)        16260     
_________________________________________________________________
 ... 
_________________________________________________________________
global_average_pooling2d (Gl (None, 130)               0         
_________________________________________________________________
dense (Dense)                (None, 90)                11790     
_________________________________________________________________
dense_1 (Dense)              (None, 5)                 455       
=================================================================
Total params: 300,033
Trainable params: 300,033
Non-trainable params: 0
_________________________________________________________________

כמה טיפים:

• שכבות מרובות הן מה שהופך את רשתות נוירונים יעילות. לפתרון הבעיה הפשוטה הזו של זיהוי פרחים, מומלץ להוסיף 5 עד 10 שכבות.
• להשתמש במסננים קטנים. בדרך כלל, מסננים בגודל 3x3 מתאימים בכל מקום.
• אפשר להשתמש גם בפילטרים ביחס 1x1, והם זולים. הם לא ממש "מסננים" כל דבר מלבד חישוב שילובים ליניאריים של ערוצים. כדאי להחליף אותם בפילטרים אמיתיים. (מידע נוסף על "קונבולציות של 1x1" מופיע בקטע הבא).
• במקרה של בעיית סיווג כזו, מומלץ להקטין את הדגימה בתדירות גבוהה באמצעות שכבות מאגר מקסימלי (או קונבולוציות עם צעדים >1). לא משנה לך איפה הפרח נמצא, אלא רק שהוא ורד או שן הארי, כך שאיבוד המידע על ה-x ו-y אינו חשוב, והסינון של אזורים קטנים יותר הוא זול יותר.
• מספר המסננים בדרך כלל דומה למספר המחלקות בסוף הרשת (למה? ראה למטה הטריק "מאגר ממוצע גלובלי"). אם מסווגים למאות מחלקות, מגדילים את מספר המסננים בהדרגה בשכבות עוקבות. למערך נתוני הפרחים שמורכב מ-5 מחלקות, סינון עם 5 מסננים בלבד לא יספיק. אפשר להשתמש באותו מספר מסננים ברוב השכבות, לדוגמה 32 ולהקטין אותו לקראת הסוף.
• השכבות הדחוסות הסופיות יקרות. יכולים להיות להם יותר משקלים מאשר כל השכבות הקונבולוציה ביחד. לדוגמה, גם עם פלט סביר מאוד מקוביית הנתונים האחרונה של 24x24x10 נקודות נתונים, שכבה של 100 צפופה נוירונים בעלות של 24x24x10x100=576,000 משקולות !!! מומלץ לחשוב פעמיים או לנסות מאגר נתונים ממוצע גלובלי (ראו בהמשך).

מאגר ממוצע גלובלי

במקום להשתמש בשכבה צפופה יקרה בקצה של רשת עצבית מתקפלת, אפשר לפצל את ה'קובייה' של הנתונים הנכנסים בכמה חלקים ככל האפשר, צריך לחשב את הממוצע של הערכים שלהם ולהזין אותם באמצעות פונקציית הפעלה Softmax. בשיטה הזו של בניית ראש הסיווג, עולה 0 משקלים. ב-Keras, התחביר הוא tf.keras.layers.GlobalAveragePooling2D().

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

פתרון

הנה ה-notebook של הפתרון. אפשר להשתמש בו אם נתקעת.

Keras_Flowers_TPU (solution).ipynb

אילו נושאים דיברנו?

• 🤔 הפעלה עם שכבות קונבולוציה
• 🤓 התנסות באיסוף מקסימום, צעדים, קיבוץ ממוצע עולמי, ...
• 😀 איטרציה במודל בעולם האמיתי במהירות, ב-TPU

כדאי להקדיש כמה רגעים כדי לעבור על רשימת המשימות הבאה בראש שקט.

7. מעולה!

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

• צינורות נתונים במהירות TPU: tf.data.Dataset ו-TFRecords
• מודל Keras הראשון שלכם, עם למידת העברה
• [THIS LAB] רשתות קונבולוציה נוירונים, עם Keras ו-TPU
• המרות מודרניות, דחיסה, Xception, עם Keras ומעבדי TPU

מעבדי TPU בפועל

מעבדי TPU ומעבדי GPU זמינים ב-Cloud AI Platform:

• במכונות וירטואליות של למידה עמוקה (Deep Learning)
• ב-notebooks של AI Platform
• במשימות של AI Platform Training

לבסוף, אנחנו אוהבים לקבל משוב. נשמח לשמוע אם משהו השתבש בשיעור ה-Lab הזה או אם לדעתכם צריך לשפר אותו. אפשר לשלוח משוב דרך 'בעיות ב-GitHub' [feedback link].

המחבר: מרטין גורנר Twitter: @martin_gorner

www.tensorflow.org