לגרום לה להתאמן, ולגרום לה להכליל

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

def profile(model, x):
    h = x
    for layer in model:
        h = layer(h)
        if isinstance(layer, (nn.Tanh, nn.ReLU)):
            print(f"activation std: {h.std().item():.4f}")
    model(x).sum().backward()
    for p in model.parameters():
        if p.dim() == 2:
            print(f"gradient std: {p.grad.std().item():.2e}")

שלושה אתחולים, אותה ארכיטקטורה, שש שכבות של $\tanh$:

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

השורה השנייה היא הכשל ההפוך, ושווה להבין אותה כי היא לא אינטואיטיבית. האקטיבציות נראות בריאות — סביב 0.96 — אבל זה $\tanh$ רווי, מוצמד קרוב לגבול שלו, בדיוק המשטר שפרק 5 מדד כמאבד פקטור של כמעט עשרת אלפים בגרדיאנט. ועדיין הגרדיאנטים עצומים: 1940 בשכבה הראשונה. שני הדברים נכונים באותו זמן. כל צעד אחורה מכפיל ב-$W^\top$, ועם 128 קלטים בשונות יחידה לפקטור הזה יש הגבר של בערך $\sqrt{128} \approx 11$, שמכריע את ההתכווצות מה-$\tanh$ הרווי. הגרדיאנטים גדלים גאומטרית בדרך חזרה. זהו גרדיאנט מתפוצץ, והוא מייצר ערכי loss של nan בתוך כמה צעדים בכל ריצת אימון אמיתית.

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

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

שכבות נרמול אוכפות את קנה המידה ברציפות. בהינתן וקטור של אקטיבציות, מחסירים ממוצע, מחלקים בסטיית תקן, ואז מפעילים קנה מידה נלמד $\gamma$ והזחה $\beta$ כדי שהשכבה תוכל לבטל את הנרמול אם יתברר שזה מה שהיא רוצה:

השאלה האמיתית היחידה היא על מה עושים ממוצע. Batch normalization³ לוקח $\mu$ ו-$\sigma$ לאורך ממד ה-batch, סטטיסטיקה אחת לכל feature. Layer normalization⁴ לוקח אותם לאורך ה-features, סטטיסטיקה אחת לכל דוגמה.

הבחירה הזו נראית קטנה וקובעת כמעט כל מה שבא אחר כך:

לכן LayerNorm הוא זה שתפגשו שוב בפרק 9 בלי שינוי: בלוק ה-transformer משתמש בו, והוא משתמש בו בגלל הסיבות בעמודה הימנית, לא כי הוא עובד טוב יותר באופן מופשט.

ארבעה תיקונים אפשריים לרשת המתה: אתחול Xavier, LayerNorm, חיבורים שיוריים, ו-Adam במקום SGD. הפיתוי הוא להחיל את ארבעתם ולהמשיך הלאה. עשו את זה ולעולם לא תדעו מי מהם היה חשוב, ובפעם הבאה שזה יקרה לא תהיה לכם שיטה — רק טקס.

אז מחילים אותם אחד בכל פעם. אותו seed, אותו data, אותה ארכיטקטורה, 800 צעדים:

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

תנו לכל ריצה פי שישה תקציב — 5000 צעדים במקום 800 — והיא משתנה לחלוטין:

עכשיו התמונה חדה, וזו אבחנה ולא טקס.

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

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

ו״כלום״ עדיין בדיוק 0.6931 אחרי חמשת אלפים צעדים. לא 0.6929. זה לא איטי; זה מת, וההבחנה הזו נראית עכשיו באופן שלא נראתה קודם, כי יש לכם שורה שאומרת שתיקון עובד להשוואה.

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

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

v = beta * v + p.grad          
p -= lr * v                    

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

m = b1 * m + (1 - b1) * g          # mean of the gradient          
v = b2 * v + (1 - b2) * g * g      # mean of the squared gradient  
m_hat = m / (1 - b1 ** t)          # bias correction: both averages start at zero
v_hat = v / (1 - b2 ** t)
p -= lr * m_hat / (v_hat.sqrt() + eps)   

עשר שורות. הריצו את שניהם מול torch.optim על אותה בעיה במשך 50 צעדים:

SGD+momentum   by hand [2.7781870365142822, -1.0304985046386719]
               torch   [2.7781870365142822, -1.0304983854293823]   max |diff| = 1.19e-07
Adam           by hand [0.4893140196800232, -0.46317872405052185]
               torch   [0.48931416869163513, -0.46317875385284424]   max |diff| = 1.49e-07

זהה עד דיוק float32. torch.optim.Adam הוא חמש השורות האלה, בתוספת עשרות שנים של טיפול במקרי קצה ו-kernel ב-C++. זו העסקה שאתם עושים מכאן ואילך: לא קסם תמורת הבנה, אלא מהירות תמורת שורות שכבר כתבתם.

ההסבר הרגיל ל-Adam הוא ״learning rates אדפטיביים לכל פרמטר״, שזה תיאור ולא סיבה. הסיבה היא גאומטריה, ואפשר למדוד אותה.

קחו loss שהעקמומיות שלו שונה בין כיוונים: תלולה באחד, רדודה באחר. ל-SGD יש learning rate גלובלי אחד, ולכן הוא חייב לבחור ערך קטן מספיק כדי להיות יציב בכיוון התלול ביותר — והערך הזה אז קטן מדי בהרבה לכיוון הרדוד, שבו ההתקדמות זוחלת. זה מה שיוצר את התמונה הקלאסית של gradient descent המזגזג במורד עמק צר.

שני יחסי עקמומיות, שלושה אופטימייזרים, 300 צעדים, וכל אופטימייזר מקבל את ה-learning rate הטוב ביותר מסריקה כדי שאף אחד לא יתחיל בנחיתות:

ביחס של עשר, הכול עובד ואין על מה לדבר. באלף, SGD פשוט לא מצליח להגיע לתשובה באף learning rate שנוסה — התוצאה הטובה ביותר שלו היא עדיין error של 1.93 — והוא ממש מתבדר במחצית מה-rates. Adam נוחת בדיוק על היעד ולא מתבדר באף אחד מהם.

העמודה האחרונה הזו היא הסיבה המעשית ש-Adam הוא ברירת המחדל. זה לא ש-Adam מוצא פתרונות טובים יותר; בבעיות ממוזגות היטב SGD מכוונן לעיתים קרובות משתווה אליו או מנצח אותו. זה ש-Adam הרבה פחות רגיש ל-learning rate שבחרתם, ולרשתות אמיתיות יש יחסי עקמומיות גרועים בהרבה מאלף על פני מיליוני הפרמטרים שלהן.

שני חלקים נוספים שייכים לכאן ושניהם שורה אחת. Gradient clipping משנה את קנה המידה של וקטור הגרדיאנט בכל פעם שהנורמה שלו עוברת סף, מה שהופך את שורת ״loss פתאום קופץ לערך עצום״ בטבלת האבחון ללא-אירוע. ו-learning rate schedules: warmup קצר מכמעט אפס לאורך מאות הצעדים הראשונים, כי אומדני השונות של Adam הם זבל עד שהם ראו כמה גרדיאנטים וצעד בגודל מלא על זבל יכול להרוס את האתחול; ואז cosine decay לכיוון אפס, כי לסיים ריצה עם אותו גודל צעד שהתחלתם איתו פירושו לרעוד סביב המינימום במקום להתייצב בו.

כל מה שהיה עד עכשיו עסק בלהוריד את ה-loss. עכשיו החצי הקשה יותר, כי ירידת ה-loss אינה המטרה — היא proxy למטרה, וה-proxy נכשל בצורה ספציפית ומפורסמת.

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

דרגה 11 דרך 12 נקודות עוברת דרך כל אחת ואחת בדיוק — train error אפס עד שש ספרות אחרי הנקודה — והיא גרועה פי שמונה מדרגה 5 על data שלא ראתה. בקשו מדרגה 3 ומדרגה 11 לחזות ב-$x = 3.25$, ממש מחוץ לטווח האימון:

degree  3: predicts   -1.053   (truth -0.012)
degree 11: predicts  +61.224   (truth -0.012)

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

זהו overfitting, וההפך שלו — דרגה 1, שלא יכולה לייצג את העקומה בכלל וגרועה בכל מקום — הוא underfitting. החשבון הקלאסי מחלק את השגיאה הצפויה של מודל לשלושה חלקים: bias, השגיאה מכך שהמודל קשיח מדי לייצג את האמת; variance, השגיאה מכך שהמודל גמיש עד כדי כך שהוא רודף אחרי הרעש בדגימה הספציפית הזו; ורעש בלתי ניתן לצמצום, ששום דבר לא מתקן. מודלים פשוטים הם biased, מודלים גמישים הם בעלי variance גבוה, והמרשם הקלאסי הוא למצוא את הנקודה המתוקה באמצע — דרגה 5 בטבלה שלמעלה.

הכלים הסטנדרטיים כולם תוקפים את איבר ה-variance:

• רגולריזציית L2 (weight decay) מוסיפה $\lambda \lVert w \rVert^2$ ל-loss, מושכת משקלים לכיוון אפס והופכת את הפונקציה לחלקה יותר. בטבלה שלמעלה, המקדם הגדול ביותר של דרגה 11 הוא שעושה את הנזק; ענישה על גודל מנטרלת אותו.
• L1 מוסיפה במקום זאת $\lambda \sum |w_i|$. ההבדל אינו קוסמטי: הגרדיאנט של L2 פרופורציונלי למשקל ולכן קטן כשהמשקל קטן, מתקרב לאפס בלי להגיע, בעוד שהגרדיאנט של L1 הוא קבוע $\pm\lambda$ שממשיך לדחוף עד הסוף. לכן L1 מייצרת משקלים שהם בדיוק אפס — היא בוחרת features. L2 מייצרת משקלים קטנים. השתמשו ב-L2 כשאתם רוצים חלקות, ב-L1 כשאתם רוצים דלילות.
• Dropout⁷ מאפס תת-קבוצה אקראית של אקטיבציות בכל צעד אימון, כך שאף יחידה לא יכולה להסתמך על כך שיחידה מסוימת אחרת תהיה נוכחת.
• Early stopping עוקב אחרי ה-validation loss ועוצר כשהוא מתחיל לעלות.
• Data augmentation מייצר עוד דוגמאות אימון מאלה שיש לכם, מה שתוקף את הבעיה במקור: overfitting הוא מחסור ב-data לא פחות משהוא עודף פרמטרים.
• Cross-validation מחלק את ה-data ב-$k$ דרכים ומאמן $k$ פעמים, מה שקונה אומדן אמין של test error כשיש לכם מעט מדי data מכדי להפריש סט מוחזק בצד.

עכשיו העובדה ששוברת את התמונה.

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

ארבעים נקודות אימון, קלטים בעשרים ממדים, features אקראיים של ReLU, ומספר ה-features $P$ נסרק מ-2 עד 5000 — עם פתרון minimum-norm שנבחר בכל פעם שיש רבים שמתאימים:

קראו אותה בשלושה חלקים. עד $P/n = 0.5$ הסיפור הקלאסי מחזיק בדיוק: השגיאה יורדת, ואז מתחילה לעלות. ב-$P = n = 40$ — סף האינטרפולציה, שבו למודל יש בדיוק מספיק פרמטרים כדי לעבור דרך כל נקודת אימון — ה-test error מגיע לשיא, ב-5.81, גרוע פי חמישה מהמודל הקטן. השיא הזה הוא האזהרה הקלאסית, והוא אמיתי.

ואז הוא יורד שוב. והוא ממשיך לרדת, אחרי $P = 5n$, אחרי $P = 37n$, כל הדרך עד $P = 125n$, שם ה-test error של 0.5664 טוב יותר מהמודל הטוב ביותר עם פחות מדי פרמטרים שהושג אי פעם. מודל עם 5000 פרמטרים שמותאם ל-40 נקודות הוא המודל הטוב ביותר בטבלה.

זהו double descent,⁸⁹ והמנגנון נראה בעמודה האחרונה. ברגע ש-$P > n$ יש אינסוף הגדרות פרמטרים שמתאימות בדיוק ל-data האימון, ואיזו מהן תקבלו תלוי באופן הבחירה שלכם. פתרון ה-minimum-norm בוחר את הקטן ביותר, ו-$\lVert w \rVert$ מראה מה זה אומר: הוא מגיע לשיא ב-14.83 בדיוק בסף — שם יש בדיוק פתרון אינטרפולציה אחד ואתם תקועים איתו, קיצוני ככל שיהיה — ואז יורד מונוטונית ככל ש-$P$ גדל, כי יותר פרמטרים פירושם יותר פתרונות אינטרפולציה לבחור מתוכם, מה שאומר שהקטן ביותר הזמין נהיה קטן יותר. ב-$P = 5000$ הנורמה היא 0.18, קטנה פי שמונים מאשר בסף.

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

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

הכלים בפרק הזה מספיקים כדי לאמן רשת שעובדת על data שאפשר לשים בטבלה: שורות של מספרים, עמודת labels.

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

פרק 7 בונה tokenizer.

עבור החיבורים השיוריים ששימשו למעלה, He ואחרים, Deep Residual Learning for Image Recognition (arXiv:1512.03385). Building makemore Part 3: Activations & Gradients, BatchNorm של Andrej Karpathy עובר דרך אבחון היסטוגרמת האקטיבציות במודל אמיתי והוא הטיפול המעשי הטוב ביותר בחצי הראשון של הפרק הזה. הרצאות 8 ו-11–13 של Yaser Abu-Mostafa ב-Learning From Data נותנות את תאוריית ה-generalisation הקלאסית כמו שצריך, כולל החלקים שהפרק הזה דחס לפסקה.