1. סקירה כללית
בשיעור ה-Lab הזה תלמדו על ארכיטקטורה קונבולציה מודרנית ונשתמש בידע שלכם כדי ליישם קונבולה פשוטה ויעילה שנקראת 'squeezenet'.
שיעור ה-Lab הזה כולל את ההסברים התיאוריים הנדרשים על רשתות נוירונים קונבולוציה, ונקודת התחלה טובה למפתחים שלומדים על למידה עמוקה (Deep Learning).
שיעור ה-Lab הזה הוא חלק 4 של "Keras on TPU" סדרות. אפשר לעשות את זה בסדר הבא או בנפרד.
- צינורות נתונים במהירות TPU: tf.data.Dataset ו-TFRecords
- מודל Keras הראשון שלכם, עם למידת העברה
- רשתות נוירונים קונבולוציה, עם Keras ומעבדי TPU
- [THIS LAB] מקרנים מודרניות, חצאית, Xception, עם Keras ומעבדי TPU
מה תלמדו
- לשלוט בסגנון הפונקציונלי של Keras
- בניית מודל באמצעות ארכיטקטורת סקוויזנט
- להשתמש במעבדי TPU כדי לאמן מהר ואיטרציה על הארכיטקטורה
- להטמיע הרחבת נתונים באמצעות tf.data.dataset.
- כדי לבצע כוונון עדין של מודל גדול (Xception) שעבר אימון מראש ב-TPU
משוב
אם תיתקלו בבעיה במעבדת הקוד הזו, נשמח לשמוע על כך. אפשר לשלוח משוב דרך 'בעיות ב-GitHub' [feedback link].
2. התחלה מהירה של Google Colaboratory
בשיעור ה-Lab הזה נעשה שימוש ב'שיתוף פעולה עם Google' ולא נדרשת הגדרה כלשהי מצדך. Colaboratory היא פלטפורמת notebook אונליין למטרות חינוכיות. התוכנית כוללת הכשרה בחינם ביחידות CPU (מעבדים), GPU ו-TPU.
אפשר לפתוח את ה-notebook לדוגמה ולעבור דרך שני תאים כדי להכיר את Colaboratory.
בחירת קצה עורפי של TPU
בתפריט Colab, בוחרים באפשרות סביבת זמן הריצה > משנים את הסוג של סביבת זמן הריצה ואז בוחרים באפשרות TPU. בשיעור ה-Lab הזה תלמדו להשתמש ב-TPU (יחידת עיבוד Tensor) חזקה, לגיבוי לצורך אימון עם האצת חומרה. החיבור לסביבת זמן הריצה יתבצע באופן אוטומטי בהפעלה הראשונה, או שאפשר להשתמש באפשרות Connect (התחברות) בפינה הימנית העליונה.
ביצוע Notebook
כדי להפעיל תאים בכל פעם, לוחצים על תא באמצעות מקש Shift-ENTER. אפשר גם להריץ את כל ה-notebook באמצעות סביבת זמן הריצה > הפעלה של הכול
תוכן העניינים
בכל המחברות יש תוכן עניינים. אפשר לפתוח אותו באמצעות החץ השחור שמימין.
תאים מוסתרים
בחלק מהתאים תוצג רק הכותרת שלהם. זוהי תכונת notebook ספציפית ל-Colab. אפשר ללחוץ עליהן לחיצה כפולה כדי לראות את הקוד שבפנים, אבל בדרך כלל זה לא מעניין במיוחד. בדרך כלל תומכים בפונקציות או בפונקציות חזותיות. עדיין צריך להריץ את התאים האלה כדי להגדיר את הפונקציות שבתוכה.
אימות
ל-Colab יש אפשרות לגשת לקטגוריות הפרטיות שלך ב-Google Cloud Storage בתנאי שביצעת אימות באמצעות חשבון מורשה. קטע הקוד שלמעלה יפעיל תהליך אימות.
3. [מידע] מהן יחידות עיבוד של Tensor (TPU)?
בקצרה
הקוד לאימון מודל על 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, ופירוש הדבר שבדרך כלל לא נדרשים שינויים בקוד כדי לשפר את הביצועים ברמת דיוק מופחתת.
מערך סיסטולי
ה-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 של רשת טורואידים דו-ממדית של 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
בקצרה
אם כל המונחים המודגשים בפסקה הבאה כבר מוכרים לכם, תוכלו לעבור לתרגיל הבא. אם אתם רק מתחילים בתחום הלמידה העמוקה, אתם מוזמנים להמשיך לקרוא.
עבור מודלים שנוצרו כרצף של שכבות, 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 על וקטור
הפסד חוצה-אנטרופיה
עכשיו, כשרשת הנוירונים שלנו מייצרת חיזויים מתמונות קלט, אנחנו צריכים למדוד עד כמה הן טובות, כלומר המרחק בין מה שהרשת אומרת לנו לבין התשובות הנכונות, שנקראות גם 'תוויות'. חשוב לזכור שיש לנו תוויות נכונות לכל התמונות במערך הנתונים.
כל מרחק מתאים, אבל כשמדובר בבעיות סיווג, המונח "מרחק בין אנטרופיה" נקרא היא היעילה ביותר. נקרא לשגיאה הזו 'הפסד' פונקציה:
ירידה הדרגתית
"אימון" רשת הנוירונים כוללת למעשה שימוש בתמונות ובתוויות לאימון כדי להתאים משקולות והטיות ולצמצם את פונקציית האובדן החוצה-אנטרופיה. כך זה עובד.
ה-cross-entropy הוא פונקציה של משקולות, הטיות, פיקסלים של תמונת האימון והסיווג הידוע שלה.
אם נחשב את הנגזרות החלקיות של ה-Cross-entropy ביחס לכל המשקולות ולכל ההטיות, נקבל 'הדרגתיות', המחושב עבור תמונה, תווית וערך נוכחי של משקולות והטיות. זכרו שיש לנו מיליוני משקולות והטיות, ולכן חישוב ההדרגתיות נשמע כמו עבודה רבה. למרבה המזל, Tensorflow עושה את זה בשבילנו. התכונה המתמטית של שיפוע הוא שהוא מצביע "למעלה". מכיוון שאנחנו רוצים להגיע למקום שבו ה-cross-entropy הוא נמוך, אנחנו הולכים בכיוון ההפוך. אנחנו מעדכנים את המשקל וההטיות לפי חלק מההדרגתיות. לאחר מכן אנחנו מבצעים את אותו הדבר שוב ושוב באמצעות הקבוצות הבאות של תמונות ותוויות לאימון, בלולאת אימון. אנו מקווים שזה מתכנס למקום שבו ה-cross-entropy הוא מינימלי, אם כי שום דבר לא מבטיח שהמינימום הזה ייחודי.
מיני-אצווה ומומנטום
ניתן לחשב את ההדרגתיות על תמונה אחת לדוגמה בלבד ולעדכן את המשקלים וההטיות באופן מיידי, אבל אם עושים זאת על קבוצה של, לדוגמה, 128 תמונות יוצר הדרגתי שמייצג טוב יותר את המגבלות שהוטלו על ידי תמונות לדוגמה שונות ולכן סביר להניח שהן יתמזגו מהר יותר אל הפתרון. גודל המיני-אצווה הוא פרמטר שניתן לשנות.
השיטה הזו, שלפעמים נקראת 'ירידה הדרגתית אקראית' יש יתרון נוסף פרגמטי יותר: עבודה עם אצוות פירושה גם עבודה עם מטריצות גדולות יותר, ובדרך כלל קל יותר לבצע אופטימיזציה שלהן במעבדי GPU ובמעבדי TPU.
עם זאת, ההתכנסות עדיין יכולה להיות קצת כאוטית והיא יכולה אפילו לעצור אם הווקטור ההדרגתי הוא אפסים. האם זה אומר שמצאנו ערך מינימום? לא תמיד. רכיב הדרגתי יכול להיות אפס במינימום או במקסימום. בווקטור הדרגתי שכולל מיליוני רכיבים, אם כולם אפסים, ההסתברות שכל אפסים תואמת למינימום ואף אחד מהם לנקודה מקסימלית לא די קטן. במגוון מימדים, נקודות אוכף הן נפוצות ולא רוצים לעצור בהן.
איור: נקודת אוכף. ההדרגתיות היא 0 אך הוא לא ערך מינימלי בכל הכיוונים. (קרדיט תמונה Wikimedia: By Nicoguaro – Own work, CC BY 3.0)
הפתרון הוא להוסיף קצת תנע לאלגוריתם האופטימיזציה כדי שהוא יוכל לשוט מעבר לנקודות האופל בלי לעצור.
מילון מונחים
אצווה או מיני-אצווה: האימון תמיד מתבצע על קבוצות של נתוני אימון ותוויות. הפעולה הזו עוזרת לאלגוריתם להתמזג. "האצווה" הוא בדרך כלל המימד הראשון של מזיני הנתונים. לדוגמה, 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 משקולות לכל אחד מהם.
כך נראית רשת עצבית מתקפלת פשוטה ב-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) הן דרך לכווץ את קוביית הנתונים במידות האופקיות.
מסווג מסתובב
לבסוף, אנחנו מצרפים ראש סיווג על ידי יישור קוביית הנתונים האחרונה והזנתה דרך שכבה צפופה שמופעלת באופן רך. מסווג קונבולוציה טיפוסי יכול להיראות כך:
איור: מסווג תמונות באמצעות שכבות קונבולוציה ושכבות 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'])
6. [מידע חדש] ארכיטקטורות קונבולוציה מודרניות
בקצרה
איור: 'מודול' קונבולוציה. מה הכי טוב בשלב זה? האם שכבת המאגר המקסימלי ולאחר מכן שכבה קונבולוטית של 1x1 או שילוב אחר של שכבות? מנסים את כולם, משרשרים את התוצאות ונותנים לרשת להחליט. בצד שמאל: " inception" של הארכיטקטורה המורכבת באמצעות מודולים כאלה.
ב-Keras, כדי ליצור מודלים שבהם זרימת הנתונים יכולה להסתעף פנימה והחוצה, צריך להשתמש במודל הפונקציונלי בסגנון של מודל טרנספורמר. לדוגמה:
l = tf.keras.layers # syntax shortcut
y = l.Conv2D(filters=32, kernel_size=3, padding='same',
activation='relu', input_shape=[192, 192, 3])(x) # x=input image
# module start: branch out
y1 = l.Conv2D(filters=32, kernel_size=1, padding='same', activation='relu')(y)
y3 = l.Conv2D(filters=32, kernel_size=3, padding='same', activation='relu')(y)
y = l.concatenate([y1, y3]) # output now has 64 channels
# module end: concatenation
# many more layers ...
# Create the model by specifying the input and output tensors.
# Keras layers track their connections automatically so that's all that's needed.
z = l.Dense(5, activation='softmax')(y)
model = tf.keras.Model(x, z)
טריקים זולים אחרים
פילטרים קטנים ביחס גובה-רוחב של 3x3
באיור הזה מוצגת התוצאה של שני פילטרים ביחס גובה-רוחב של 3x3. נסו לזהות את נקודות הנתונים שתרמו לתוצאה: שני המסננים הרציפים האלה מסוג 3x3 מחשבים שילוב כלשהו של אזור בגודל 5x5. זה לא בדיוק אותו השילוב שמסנן בגודל 5x5 יחושב, אבל כדאי לנסות כי שני מסננים עוקבים מסוג 3x3 זולים יותר ממסנן יחיד בגודל 5x5.
קונבולוציות 1x1?
במונחים מתמטיים, "1x1" קונבולציה היא כפל בקבוע, לא רעיון שימושי מאוד. עם זאת, ברשתות נוירונים מורכבות חשוב לזכור שהמסנן מיושם בקוביית נתונים, ולא רק על תמונה דו-ממדית. לכן, "1x1" מסנן מחשב סכום משוקלל של עמודת נתונים בגודל 1x1 (ראו איור) ותוך כדי הזזת הנתונים בין הנתונים, יתקבל שילוב ליניארי של ערוצי הקלט. זה למעשה שימושי. אם חושבים על הערוצים כתוצאות של פעולות סינון נפרדות, לדוגמה מסנן 'אוזניים מחודדות', מסנן אחר ל'שפמים' והשלישית ל"עיניים חסומות" ואז '1x1' השכבה המורכבת תחושב כמה שילובים ליניאריים אפשריים של התכונות האלה, וזה יכול להיות שימושי אם מחפשים "חתול". בנוסף, שכבות של 1x1 משתמשות בפחות משקל.
7. סקווֶנט
אחת הדרכים הפשוטות לשילוב בין הרעיונות האלה הוצגו ב"מחט" נייר. המחברים מציעים תכנון פשוט מאוד של מודול קונבולוציה, באמצעות שכבות קונבולוציה בגודל 1x1 ו-3x3 בלבד.
איור: ארכיטקטורת מעיכה שמבוססת על 'מודולים של אש'. הן מחליפים ביניהן שכבה של 1x1 ש"כווצת" את הנתונים הנכנסים במימד האנכי ולאחר מכן שתי שכבות מקבילות של 1x1 ו-3x3 ש"מתרחבות". את עומק הנתונים שוב.
שיחה קולית
ממשיכים ב-notebook הקודם ויוצרים רשת עצבית מתקפלת בהשראת סקוץ'. תצטרכו לשנות את קוד המודל ל"סגנון פונקציונלי" של Keras.
Keras_Flowers_TPU (playground).ipynb
מידע נוסף
בתרגיל הזה כדאי להגדיר פונקציה מסייעת למודול מעיכה:
def fire(x, squeeze, expand):
y = l.Conv2D(filters=squeeze, kernel_size=1, padding='same', activation='relu')(x)
y1 = l.Conv2D(filters=expand//2, kernel_size=1, padding='same', activation='relu')(y)
y3 = l.Conv2D(filters=expand//2, kernel_size=3, padding='same', activation='relu')(y)
return tf.keras.layers.concatenate([y1, y3])
# this is to make it behave similarly to other Keras layers
def fire_module(squeeze, expand):
return lambda x: fire(x, squeeze, expand)
# usage:
x = l.Input(shape=[192, 192, 3])
y = fire_module(squeeze=24, expand=48)(x) # typically, squeeze is less than expand
y = fire_module(squeeze=32, expand=64)(y)
...
model = tf.keras.Model(x, y)
המטרה הפעם היא להגיע לרמת דיוק של 80%.
דברים שכדאי לנסות
מתחילים עם שכבה מתקפלת אחת ולאחר מכן ממשיכים עם "fire_modules", לסירוגין עם MaxPooling2D(pool_size=2) שכבות. אפשר להתנסות במספר מקסימלי של 2 עד 4 שכבות מאגר ברשת, וגם עם 1, 2 או 3 מודולי אש רצופים בין שכבות המאגר המקסימליות.
במודולים של Fire, "smoeze" בדרך כלל צריך להיות קטן יותר מהפרמטר "expand" הפרמטר. הפרמטרים האלה הם למעשה מספרים של מסננים. בדרך כלל הם נע בין 8 ל-196. אתם יכולים להתנסות בארכיטקטורות שבהן מספר המסננים גדל בהדרגה דרך הרשת או בארכיטקטורות פשוטות שבהן לכל המודולים של אש יש אותו מספר מסננים.
לדוגמה:
x = tf.keras.layers.Input(shape=[*IMAGE_SIZE, 3]) # input is 192x192 pixels RGB
y = tf.keras.layers.Conv2D(kernel_size=3, filters=32, padding='same', activation='relu')(x)
y = fire_module(24, 48)(y)
y = tf.keras.layers.MaxPooling2D(pool_size=2)(y)
y = fire_module(24, 48)(y)
y = tf.keras.layers.MaxPooling2D(pool_size=2)(y)
y = fire_module(24, 48)(y)
y = tf.keras.layers.GlobalAveragePooling2D()(y)
y = tf.keras.layers.Dense(5, activation='softmax')(y)
model = tf.keras.Model(x, y)
בשלב הזה, ייתכן שתשימו לב שהניסויים לא כל כך טובים, ושיעד הדיוק של 80% נראה מרוחק. הגיע הזמן לעוד כמה טריקים זולים.
נירמול באצווה
נורמה באצווה תעזור לכם לפתור את בעיות ההתכנסות שאתם נתקלים בהן. תקבלו הסברים מפורטים על השיטה הזו בסדנה הבאה. בינתיים, השתמשו בה כ"קסם" כלי המסייע על ידי הוספת השורה הזו אחרי כל שכבה קונבולוציה ברשת, כולל השכבות שבתוך פונקציית Fire_Module:
y = tf.keras.layers.BatchNormalization(momentum=0.9)(y)
# please adapt the input and output "y"s to whatever is appropriate in your context
צריך להקטין את פרמטר המומנטום מערך ברירת המחדל שלו, שהוא 0.99 ל-0.9, כי מערך הנתונים שלנו קטן. אל להתייחס לפרטים האלה כרגע.
הגדלת נתונים
תקבל עוד כמה נקודות אחוזים על ידי הרחבת הנתונים באמצעות טרנספורמציות קלות כמו שינויי רוויה לשמאליים:
קל מאוד לעשות את זה ב-Tensorflow באמצעות ה-API של tf.data.Dataset. מגדירים פונקציית טרנספורמציה חדשה לנתונים:
def data_augment(image, label):
image = tf.image.random_flip_left_right(image)
image = tf.image.random_saturation(image, lower=0, upper=2)
return image, label
לאחר מכן משתמשים בו בטרנספורמציה הסופית של הנתונים ("מערכי נתונים של אימון ואימות" של התא, פונקציה "get_batched_dataset"):
dataset = dataset.repeat() # existing line
# insert this
if augment_data:
dataset = dataset.map(data_augment, num_parallel_calls=AUTO)
dataset = dataset.shuffle(2048) # existing line
אל תשכחו להגדיר את הרחבת הנתונים כאופציונלית ולהוסיף את הקוד הדרוש כדי לוודא שרק מערך הנתונים מורחב. אין היגיון להרחיב את מערך הנתונים לאימות.
עכשיו אפשר להגיע לרמת דיוק של 80% ב-35 תקופות של זמן מערכת.
פתרון
הנה ה-notebook של הפתרון. אפשר להשתמש בו אם נתקעת.
Keras_Flowers_TPU_squeezenet.ipynb
אילו נושאים דיברנו?
- 🤔 Keras "סגנון פונקציונלי" דגמים
- 🤓 ארכיטקטורת מעיכה
- 🤓 נתונים באמצעות tf.data.datset
כדאי להקדיש כמה רגעים כדי לעבור על רשימת המשימות הבאה בראש שקט.
8. כוונון עדין של Xception
קיפולים (קונבולציות) שניתנות להפרדה
דרך אחרת ליישום שכבות קונבולוציה צברה לאחרונה פופולריות: קונבולוציות עם הפרדה בעומק. אני יודעת, שפע של פה, אבל העיקרון די פשוט. הם מוטמעים ב-Tensorflow וב-Keras בתור tf.keras.layers.SeparableConv2D.
קונבולציה ניתנת להפרדה מפעילה גם מסנן על התמונה, אבל היא משתמשת בקבוצה נפרדת של משקלים לכל ערוץ של תמונת הקלט. אחריו מופיעה "קונבולוציה של 1x1", סדרה של מוצרי נקודות שהתוצאה שלה היא סכום משוקלל של הערוצים המסוננים. עם משקלים חדשים בכל פעם, הרכבים המשוקללים רבים של הערוצים מחושבים לפי הצורך.
איור: קונבולציות נפרדות. שלב 1: קונבולציות עם מסנן נפרד לכל ערוץ. שלב 2: שילובים לינאריים של ערוצים. חוזרים על הפעולה עם קבוצת משקולות חדשה עד שמגיעים למספר הרצוי של ערוצי הפלט. אפשר לחזור על שלב 1 גם על שלב 1, עם משקלים חדשים בכל פעם, אבל בפועל זה קורה רק לעיתים רחוקות.
קונבולציות הניתנות להפרדה משמשות בארכיטקטורות הרשתות הקונבולוציות האחרונות: MobileNetV2, Xception, EfficientNet. דרך אגב, MobileNetV2 היא השיטה שבה השתמשתם בעבר כדי להעביר את הלמידה.
הם זולים יותר משקיבלים רגילים, והם הוכיחו שהם יעילים באותה מידה בפועל. זהו מספר המשקל שמופיע בדוגמה שלמעלה:
שכבה מתקפלת: 4 x 4 x 3 x 5 = 240
שכבה מתקפלת שניתנת להפרדה: 4 x 4 x 3 + 3 x 5 = 48 + 15 = 63
זה נשאר לתרגיל עם הקורא לחשב את מספר ההכפלות שנדרש כדי ליישם כל סגנון של סולמות שכבות קונבולוציה בצורה דומה. קונבולציות הניתנות להפרדה הן קטנות יותר ויעילות הרבה יותר מבחינה חישובית.
שיחה קולית
התחלה מחדש מהקטע 'העברת הלמידה' notebook של Playground, אבל הפעם בוחרים ב-Xception כמודל שעבר אימון מראש. Xception משתמש בקיפולים נפרדים בלבד. צריך לאפשר אימון של כל המשקולות. אנחנו נבצע כוונון עדין של המשקולות לפני אימון על הנתונים שלנו במקום להשתמש ככה בשכבות שאומנו מראש.
Keras Flowers transfer learning (playground).ipynb
יעד: דיוק > 95% (לא, ברצינות, זה אפשרי!)
זה התרגיל האחרון, וצריך עוד קצת עבודה על קוד ומדעי הנתונים.
מידע נוסף על כוונון עדין
Xception זמין במודלים הרגילים שעברו אימון מראש באפליקציה tf.keras.application.* לא לשכוח להשאיר את כל המשקולות בשלב הזה לאימון.
pretrained_model = tf.keras.applications.Xception(input_shape=[*IMAGE_SIZE, 3],
include_top=False)
pretrained_model.trainable = True
כדי לקבל תוצאות טובות בזמן כוונון של המודל, צריך לשים לב לקצב הלמידה ולהשתמש בלוח זמנים של קצב הלמידה עם תקופת הרצה. כך:
התחלה בקצב למידה רגיל תשבש את המשקולות של המודל שעברו אימון מראש. בתור התחלה, המערכת שומרת בהדרגה את הנתונים עד שהמודל נצמד לנתונים שלכם כדי לשנות אותם בצורה סבירה. אחרי הרמפה, אפשר להמשיך בקצב למידה קבוע או דעיכה אקספוננציאלית.
ב-Keras, קצב הלמידה נקבע באמצעות קריאה חוזרת (callback) שבה אתם יכולים לחשב את קצב הלמידה המתאים לכל תקופה של זמן מערכת. Keras יעביר את קצב הלמידה הנכון לכלי האופטימיזציה בכל תקופה של זמן מערכת.
def lr_fn(epoch):
lr = ...
return lr
lr_callback = tf.keras.callbacks.LearningRateScheduler(lr_fn, verbose=True)
model.fit(..., callbacks=[lr_callback])
פתרון
הנה ה-notebook של הפתרון. אפשר להשתמש בו אם נתקעת.
07_Keras_Flowers_TPU_xception_fine_tuned_best.ipynb
אילו נושאים דיברנו?
- 🤔 הסרה בקישורי עומק
- 🤓 לוח זמנים לקצב הלמידה
- 😈. כוונון עדין של מודל שעבר אימון מראש.
כדאי להקדיש כמה רגעים כדי לעבור על רשימת המשימות הבאה בראש שקט.
9. מעולה!
בניתם את רשת הנוירונים המתקפלת המודרנית הראשונה שלכם ואימון אותה ברמת דיוק של 90% ומעלה, וחזרה על אימונים עוקבים בתוך דקות בלבד בעזרת מעבדי TPU. הגענו לסוף של 4 "Keras on TPU Codelabs":
- צינורות נתונים במהירות TPU: tf.data.Dataset ו-TFRecords
- מודל Keras הראשון שלכם, עם למידת העברה
- רשתות נוירונים קונבולוציה, עם Keras ומעבדי TPU
- [THIS LAB] מקרנים מודרניות, חצאית, Xception, עם Keras ומעבדי TPU
מעבדי TPU בפועל
מעבדי TPU ומעבדי GPU זמינים ב-Cloud AI Platform:
- במכונות וירטואליות של למידה עמוקה (Deep Learning)
- ב-notebooks של AI Platform
- במשימות של AI Platform Training
לבסוף, אנחנו אוהבים לקבל משוב. נשמח לשמוע אם משהו השתבש בשיעור ה-Lab הזה או אם לדעתכם צריך לשפר אותו. אפשר לשלוח משוב דרך 'בעיות ב-GitHub' [feedback link].
|
