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

המרות מודרניות, סתימות, Xception, עם Keras ומעבדי TPU

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

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

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

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

פייפליינים במהירות TPU: ‏ tf.data.Dataset ו-TFRecords
המודל הראשון של Keras עם למידה של העברות
רשתות עצביות מתקפלות, עם Keras ויחידות TPU
[THIS LAB] Modern convnets, squeezenet, Xception, with Keras and TPUs

מה תלמדו

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

משוב

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

2. מדריך למתחילים ב-Google Colaboratory

ב-Lab הזה נעשה שימוש ב-Google Collaboratory, ולא נדרשת הגדרה מצדכם. ‫Colaboratory היא פלטפורמת מחברות אונליין למטרות חינוכיות. הוא מציע הדרכה בחינם בנושאי CPU, ‏ GPU ו-TPU.

אתם יכולים לפתוח את מחברת הדוגמה הזו ולהריץ כמה תאים כדי להכיר את Colaboratory.

Welcome to Colab.ipynb

בחירת TPU backend

בתפריט Colab, בוחרים באפשרות Runtime > Change runtime type (זמן הריצה > שינוי הסוג של זמן הריצה) ואז בוחרים באפשרות TPU. בשיעור ה-Lab הזה תשתמשו ב-TPU (יחידת עיבוד טנסור) עוצמתית עם תמיכה באימון מואץ בחומרה. החיבור לסביבת זמן הריצה יתבצע באופן אוטומטי בהרצה הראשונה, או שאפשר להשתמש בלחצן 'חיבור' בפינה השמאלית העליונה.

הפעלת Notebook

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

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

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

תאים מוסתרים

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

אימות

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

3. ‫[INFO] מהם Tensor Processing Units ‏ (TPUs)?

בקצרה

הקוד לאימון מודל ב-TPU ב-Keras (עם חזרה ל-GPU או ל-CPU אם 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 מודרניים מאורגנים סביב 'ליבות' שניתנות לתכנות. זו ארכיטקטורה גמישה מאוד שמאפשרת להם לטפל במגוון משימות כמו עיבוד תלת-ממד, למידה עמוקה, סימולציות פיזיות ועוד. לעומת זאת, יחידות TPU משלבות מעבד וקטורי קלאסי עם יחידת כפל מטריצות ייעודית, והן מצטיינות בכל משימה שבה כפל מטריצות גדול הוא הדומיננטי, כמו רשתות נוירונים.

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

החומרה

‫MXU ו-VPU

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

נקודה צפה בדיוק מעורב ו-bfloat16

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

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

לכן Google הציגה את הפורמט bfloat16 ב-TPU. ‏bfloat16 הוא float32 קטום עם אותם ביטים של מעריך ואותו טווח כמו 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 יכול להטמיע 16 אלף מהן ב-MXU בגודל 128x128 ולעבד את הכפלת המטריצות הזו בבת אחת.

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

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

Cloud TPU

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

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

TPU pods

במרכזי הנתונים של Google, יחידות ה-TPU מחוברות לחיבור הדדי (interconnect) של מחשוב עתיר ביצועים (HPC), שיכול לגרום להן להיראות כמו מאיץ גדול מאוד. ‫Google קוראת להם pods, והם יכולים לכלול עד 512 ליבות TPU v2 או 2,048 ליבות TPU v3.

איור: TPU v3 Pod. לוחות ומתלים של TPU שמחוברים באמצעות HPC interconnect.

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

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

התוכנה

אימון עם גודל אצווה גדול

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

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

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

הפרטים הטכניים: XLA

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

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

שימוש ביחידות TPU ב-Keras

החל מ-Tensorflow 2.1, יש תמיכה ב-TPU דרך Keras API. התמיכה ב-Keras פועלת ביחידות TPU ובמערכות TPU. דוגמה שפועלת ב-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=...)

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

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

משימות נפוצות להעברת נתונים ל-TPU

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

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

בקצרה

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

מסווג של רשת נוירונים מורכב מכמה שכבות של נוירונים. לסיווג תמונות, אלה יכולות להיות שכבות צפופות או, בתדירות גבוהה יותר, שכבות קונבולוציוניות. הם מופעלים בדרך כלל באמצעות פונקציית ההפעלה relu. השכבה האחרונה משתמשת במספר נוירונים ששווה למספר הכיתות, והיא מופעלת באמצעות softmax. לסיווג, cross-entropy היא פונקציית ההפסד הנפוצה ביותר, שמשווה בין תוויות (כלומר תשובות נכונות) עם קידוד 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 על וקטור, מחשבים את האקספוננט של כל רכיב ואז מבצעים נורמליזציה של הווקטור, בדרך כלל באמצעות נורמת L1 (סכום הערכים המוחלטים), כך שסכום הערכים יהיה 1 ואפשר יהיה לפרש אותם כהסתברויות.

Cross-entropy loss

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

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

Gradient descent

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

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

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

gradient descent2.png

חלוקה לקבוצות קטנות ומומנטום

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

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

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

איור: נקודת אוכף. השיפוע הוא 0, אבל זה לא מינימום בכל הכיוונים. (‫Attribution של התמונה Wikimedia: By Nicoguaro - Own work, CC BY 3.0)

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

מילון מונחים

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

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

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

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

תוויות: שם נוסף ל'סיווגים' או לתשובות נכונות בבעיית סיווג עם פיקוח

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

‫logits: הפלט של שכבת נוירונים לפני החלת פונקציית ההפעלה נקרא logits. המונח הזה מגיע מהפונקציה הלוגיסטית, שנקראת גם פונקציית סיגמואיד, שהייתה פונקציית ההפעלה הפופולרית ביותר. השם 'Neuron outputs before logistic function' (פלט של נוירון לפני פונקציה לוגיסטית) קוצר ל-'logits'.

‫loss: פונקציית השגיאה שמשווה בין התפוקות של רשת נוירונים לבין התשובות הנכונות

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

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

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

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

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

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

5. ‫[INFO] רשתות נוירונים מלאכותיות

בקצרה

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

איור: סינון תמונה באמצעות שני מסננים עוקבים, כל אחד עם 48 משקלים שניתנים ללמידה (4x4x3=48).

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

כך נראית רשת נוירונים מתקפלת פשוטה ב-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'])

רשתות עצביות מתקפלות (CNN) – מבוא

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

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

Screen Shot 2016-07-29 at 16.02.37.png

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

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

קיפולים (קונבולציות) עם צעדים, יצירת מאגרים מקסימליים

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

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

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

מסווג קונבולוציוני

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

איור: מסווג תמונות שמשתמש בשכבות קונבולוציה ובשכבות 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. Squeezenet

דרך פשוטה לשלב בין הרעיונות האלה מוצגת במאמר Squeezenet. המחברים מציעים עיצוב פשוט מאוד של מודול קונבולוציה, שמשתמש רק בשכבות קונבולוציה של 1x1 ו-3x3.

איור: ארכיטקטורת squeezenet שמבוססת על 'מודולי אש'. הן מחליפות שכבת 1x1 ש'דוחסת' את הנתונים הנכנסים בממד האנכי, ואחריה שתי שכבות קונבולוציה מקבילות של 1x1 ו-3x3 ש'מרחיבות' שוב את עומק הנתונים.

מעשי

ממשיכים בנוטבוק הקודם ויוצרים רשת נוירונים קונבולוציונית בהשראת SqueezeNet. תצטרכו לשנות את קוד המודל ל'סגנון פונקציונלי' של Keras.

Keras_Flowers_TPU (playground).ipynb

מידע נוסף

כדאי להגדיר פונקציית עזר למודול squeezenet:

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 שכבות של איגום מקסימלי ברשת, וגם עם מודול אחד, 2 או 3 של חומת אש עוקבת בין השכבות של האיגום המקסימלי.

במודולים של Fire, הפרמטר squeeze בדרך כלל צריך להיות קטן מהפרמטר 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% דיוק רחוק מאוד. הגיע הזמן לעוד כמה טריקים זולים.

Batch Normalization

הנרמול באצווה יעזור לכם לפתור את בעיות ההתכנסות שבהן נתקלתם. בסדנה הבאה נספק הסברים מפורטים על הטכניקה הזו. בינתיים, אפשר להשתמש בה כעוזרת 'קסם' של קופסה שחורה על ידי הוספת השורה הזו אחרי כל שכבת קונבולוציה ברשת, כולל השכבות בתוך הפונקציה 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 באמצעות tf.data.Dataset API. מגדירים פונקציית טרנספורמציה חדשה לנתונים:

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

אחר כך משתמשים בו בטרנספורמציה הסופית של הנתונים (התא 'training and validation datasets', הפונקציה '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

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

עכשיו אפשר להגיע לדיוק של 80% ב-35 תקופות.

המוצר

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

Keras_Flowers_TPU_squeezenet.ipynb

מה נכלל

‫🤔 מודלים של Keras בסגנון פונקציונלי
🤓 ארכיטקטורת Squeezenet
🤓 הגדלת מערך הנתונים באמצעות tf.data.datset

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

8. Xception fine-tuned

Separable convolutions

לאחרונה, שיטה אחרת להטמעת שכבות קונבולוציה צוברת פופולריות: קונבולוציות שניתנות להפרדה לפי עומק. אני יודע, זה שם ארוך, אבל הרעיון די פשוט. הם מיושמים ב-Tensorflow וב-Keras כ- tf.keras.layers.SeparableConv2D.

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

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

הפעלת קונבולוציה נפרדת נמצאת בשימוש ברוב הארכיטקטורות העדכניות של רשתות קונבולוציה: MobileNetV2, ‏ Xception, ‏ EfficientNet. אגב, MobileNetV2 הוא המודל שבו השתמשתם בעבר ל-Transfer Learning.

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

שכבת קונבולוציה: 4 x 4 x 3 x 5 = 240

שכבת קונבולוציה ניתנת להפרדה: 4 x 4 x 3 + 3 x 5 = 48 + 15 = 63

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

מעשי

מפעילים מחדש את מחברת ה-playground של Transfer Learning, אבל הפעם בוחרים ב-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])

המוצר

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

07_Keras_Flowers_TPU_xception_fine_tuned_best.ipynb

מה נכלל

🤔 Depth-separable convolution
🤓 לוחות זמנים של קצב למידה
😈 כוונון עדין של מודל שעבר אימון מראש.

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

9. מעולה!

בניתם את הרשת הנוירונית המתקפלת המודרנית הראשונה שלכם ואימנתם אותה לרמת דיוק של 90% ומעלה, תוך חזרה על אימונים עוקבים תוך דקות ספורות הודות ל-TPU. בזה מסתיים קוד ה-lab מספר 4 בנושא Keras ב-TPU:

פייפליינים במהירות TPU: ‏ tf.data.Dataset ו-TFRecords
המודל הראשון של Keras עם למידה של העברות
רשתות עצביות מתקפלות, עם Keras ויחידות TPU
[THIS LAB] Modern convnets, squeezenet, Xception, with Keras and TPUs

מעבדי TPU בפועל

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

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

Martin Görner ID small.jpg
המחבר: מרטין גרנר
טוויטר: @martin_gorner

tensorflow logo.jpg
www.tensorflow.org