סיווג, אנטרופיה צולבת, ואיך לא לעבוד על עצמך

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

import numpy as np

rng = np.random.default_rng(4)
N = 20_000
width  = rng.normal(22.0, 0.9, N)      # millimetres
weight = rng.normal(57.0, 3.0, N)      # grams

z_true = -5.90 + 1.90 * (width - 22.0) + 0.42 * (weight - 57.0)
y = (rng.random(N) < 1 / (1 + np.exp(-z_true))).astype(float)

perm = rng.permutation(N)
train, val, test = perm[:12_000], perm[12_000:16_000], perm[16_000:]

N = 20000  defects = 337  base rate = 0.0169
defects per split = 203 60 74

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

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

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

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

שזו רק דרך קומפקטית לכתוב "$p$ אם $y = 1$, ו-$1-p$ אם $y = 0$". לוקחים את ה-log של זה והופכים סימן, וההפסד עבור דוגמה אחת הוא

זו אנטרופיה צולבת בינארית. היא לא נבחרה כי היא נוחה; היא ה-negative log-likelihood של ההתפלגות היחידה שיכולה להיות להטלת מטבע. לא הייתה אפשרות אחרת.

מה שעדיין חסר הוא מאיפה $p$ מגיע. המודל מחשב סכום משוקלל $s = \mathbf{w}\cdot\mathbf{x} + b$, שהוא מספר ממשי ונע על פני כל הישר, והסתברות חייבת לחיות ב-$(0,1)$. הפונקציה שמעבירה ביניהם היא הסיגמואיד הלוגיסטי:

logit -4.0  ->  p = 0.0180        loss when y=1 and p=0.9  : 0.1054
logit -1.0  ->  p = 0.2689        loss when y=1 and p=0.5  : 0.6931
logit  0.0  ->  p = 0.5000        loss when y=1 and p=0.01 : 4.6052
logit  4.0  ->  p = 0.9820

קראו את העמודה הימנית כמחירון. להיות צודק בביטחון של 90 % עולה 0.105. לסרב להתחייב עולה 0.693 — שזה $\log 2$, מחיר משיכת הכתפיים. לטעות בביטחון עולה 4.6, פי ארבעים וארבע יותר, והמחיר עולה ללא גבול ככל שהמודל נעשה בטוח יותר בטעות. אנטרופיה צולבת לא רק סופרת שגיאות: היא גובה תשלום על יהירות.

פרק 3 אמר: כדי לאמן משהו, משיגים את הנגזרת של ההפסד ביחס לכל פרמטר. עושים זאת עבור דוגמה אחת. עם $s = \mathbf{w}\cdot\mathbf{x} + b$ ו-$p = \sigma(s)$:

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

def sigmoid(z):
    return np.where(z >= 0, 1.0 / (1.0 + np.exp(-z)),
                    np.exp(np.minimum(z, 0)) / (1.0 + np.exp(np.minimum(z, 0))))


def fit_logistic(X, y, lr=0.5, epochs=4000):
    w, b = np.zeros(X.shape[1]), 0.0
    for _ in range(epochs):
        p = sigmoid(X @ w + b)
        g = p - y                        
        w -= lr * (X.T @ g) / len(y)     
        b -= lr * g.sum() / len(y)       
    return w, b

ה-np.where ב-sigmoid אינו קוסמטי. חישוב $1/(1+e^{-s})$ ישירות גורם ל-overflow עבור $s$ שלילי גדול; ההסתעפות בוחרת את הצורה האלגברית הזהה ששומרת את המעריך שלילי. זו קופסת הנקודה הצפה מפרק 2 שגובה את החוב הראשון שלה, והיא תגבה חוב גדול יותר בעוד שני סעיפים.

ההסבר הסטנדרטי להעדפת אנטרופיה צולבת על פני שגיאה ריבועית הוא טיעון הנראות למעלה: שגיאה ריבועית מתקבלת מהנחה של רעש גאוסי, תוויות אינן גאוסיות, ולכן אל תעשו זאת. זה נכון וזה לא משכנע אף אחד, כי אפשר לכתוב $L = (p - y)^2$ מעל סיגמואיד וזה יתאמן.

הטיעון שפוגע הוא על ה-gradient. שמים שגיאה ריבועית על סיגמואיד וכלל השרשרת נותן

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

ב-$s = -8$ המודל טועה ככל שאפשר לטעות, ושגיאה ריבועית מגיבה ב-gradient קטן פי 1,491 מזה של אנטרופיה צולבת. ככל שהטעות גרועה יותר, המודל לומד ממנה פחות. ה-gradient של אנטרופיה צולבת, בינתיים, רווי ב-$-1$: טעות מקסימלית מייצרת אות גדול באופן מקסימלי, ולא גדול יותר.

מריצים את המרוץ. אלפיים נקודות מאוזנות, משקלי התחלה זהים שנבחרו להיות שגויים בביטחון ($\mathbf{w} = [-6, -6]$), קצב למידה זהה, רק ההפסד שונה. שתי הריצות נמדדות עם אנטרופיה צולבת כדי שהעמודות יהיו בנות השוואה.

אנטרופיה צולבת מסיימת עד epoch 50. שגיאה ריבועית עדיין ב-24 % דיוק ב-epoch 100 — ולא זזה מ-23 % ב-epoch 10 — גרוע מניחוש, כי היא התחילה בטעות בביטחון וה-gradient שהיה מציל אותה הוכפל ב-0.0007. היא נמלטת בערך ב-epoch 500 ונוחתת באותו מקום. לכן הסיכום ההוגן הוא ששגיאה ריבועית מעל סיגמואיד אינה שגויה; היא איטית בדיוק במקום שבו מהירות חשובה ביותר. במודל עם שני פרמטרים מאבדים 450 epochs. ברשת עם מאה שכבות, שבה איזושהי יחידה איפשהו תמיד טועה בביטחון, מאבדים את ריצת האימון.

שלוש כמויות, שנצטרך כמו שצריך ב-פרק 8 עבור perplexity וב-פרק 11 עבור העונש ששומר policy שעבר fine-tuning קרוב לרפרנס שלו. הן קלות יותר מהמוניטין שלהן.²

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

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

דיברגנציית KL היא העודף — הבזבוז, בביטים, שנגרם מאמונה ב-$q$ כשהאמת היא $p$:

בודקים את שלושתן על המסוע:

test defect rate                                = 0.0185
entropy of that coin                            = 0.1329 bits
cross-entropy of the constant predictor on test = 0.1330 bits
KL(test coin || fair coin)                      = 0.8671 bits
H + KL                                          = 1.0000 bits
cross-entropy of the p=0.5 predictor on test    = 1.0000 bits

שני דברים נראים שם. ראשית, מודל שפשוט מדווח על שיעור הבסיס באימון, 1.69 %, משיג אנטרופיה צולבת של 0.1330 ביטים, כמעט בדיוק האנטרופיה של תוויות הבדיקה — כפי שהוא חייב, מאחר שיש לו את ההתפלגות הנכונה ואין לו מידע אחר. אנטרופיה היא הרצפה שבורות לגבי הפרט קונה לכם. שנית, מודל שמושך כתפיים ואומר 0.5 משלם בדיוק ביט אחד, והפער בין השניים, 0.8671 ביטים, הוא בדיוק דיברגנציית KL. $H + D_{\mathrm{KL}} = H(p,q)$ אינה זהות לשינון; היא חשבון שאפשר לראות מצטבר.

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

פגום הוא לא דבר אחד. ביציקה, חלק יכול לצאת כ-short shot (לא מספיק חומר), flash (יותר מדי, שנדחק החוצה מהתבנית), או burn. ארבע תוצאות, לכן ארבעה logits, והם חייבים להפוך לארבע הסתברויות שסכומן אחת. זה softmax:

יש לו תכונה שנראית כמו תאונה ולמעשה היא כל המימוש:

עבור כל קבוע $c$, כי $e^{z_i + c} = e^{c} e^{z_i}$ וה-$e^c$ מתבטל למעלה ולמטה. רק הבדלים בין logits אומרים משהו. הרמה המוחלטת אינה מידע.

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

logits            = [800. 801. 799.]
naive softmax     = [nan nan nan]
shifted by -max   = [0.2447 0.6652 0.09  ]
same softmax after adding 1000 to every logit: True

$e^{800}$ גורם ל-overflow ב-float של 64 ביט, הסכום נעשה אינסוף, ואינסוף חלקי אינסוף הוא nan — לא שגיאה, לא קריסה, רק חור שקט במקום שבו היו שלוש הסתברויות. חיסור ה-logit המקסימלי לא משנה כלום מתמטית ומשנה הכול נומרית, כי המעריך הגדול ביותר נעשה בדיוק $e^0 = 1$. זה טריק ה-logsumexp מפרק 2 בבגדי עבודה, וכל מימוש רציני עושה זאת:

def softmax(Z):
    Z = Z - Z.max(axis=1, keepdims=True)   
    E = np.exp(Z)
    return E / E.sum(axis=1, keepdims=True)


def fit_softmax(X, Y, lr=1.0, epochs=6000):
    W, b = np.zeros((X.shape[1], Y.shape[1])), np.zeros(Y.shape[1])
    for _ in range(epochs):
        G = (softmax(X @ W + b) - Y) / len(X)   
        W -= lr * (X.T @ G)
        b -= lr * G.sum(0)
    return W, b

ה-gradient הוא שוב חיזוי פחות אמת, עכשיו עם $Y$ one-hot. המקרה הבינארי היה מקרה פרטי כל הזמן.

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

המודל מוצא פחות ממחצית ה-short shots. דיוק לא יכול לראות את זה, כי 86 % מהחלקים תקינים וזיהוי נכון שלהם מספיק כדי לסחוב את הממוצע. Macro F1 — הממוצע של ציוני F1 לכל מחלקה, שמעניק למחלקה נדירה אותו משקל כמו למחלקה נפוצה — הוא 0.7983, לעומת micro F1 של 0.9400 שבהגדרה זהה לדיוק. בכל פעם שמישהו מדווח על מספר F1 אחד, שאלו איזה.

זה סוף המידול. שאר הפרק עוסק במספרים.

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

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

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

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

always-say-fine baseline: accuracy = 0.9815
confusion (tn, fp, fn, tp) = (3926, 0, 74, 0)

98.15 %. עכשיו המודל הלוגיסטי המאומן, בסף ברירת המחדל 0.5:

logistic @0.5: accuracy=0.9830 precision=0.8000 recall=0.1081 F1=0.1905
confusion (tn, fp, fn, tp) = (3924, 2, 66, 8)

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

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

• Precision $= \mathrm{TP}/(\mathrm{TP}+\mathrm{FP}) = 8/10 = 0.800$. מתוך החלקים שסומנו, כמה באמת היו פגומים. זו העלות של בדיקות מבוזבזות.
• Recall $= \mathrm{TP}/(\mathrm{TP}+\mathrm{FN}) = 8/74 = 0.108$. מתוך החלקים הפגומים, כמה נתפסו. זו העלות של שליחת חלק פגום ללקוח.
• F1 $= 2PR/(P+R) = 0.190$, הממוצע ההרמוני שלהם, שנשאר קרוב לקטן מביניהם ולכן מסרב להיות מוחמא מאחד מהם בלבד.

מה חשוב תלוי במפעל, לא במתמטיקה: בדיקה עולה כמה שניות ופגם שנשלח עולה הודעת recall, לכן כאן recall שולט ו-0.108 הוא כישלון.

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

קראו את עמודת הדיוק מלמעלה למטה. היא יורדת לאורך כל הדרך — מ-98.30 % ל-65.93 % — בזמן שהמודל עובר מלתפוס 8 פגמים ללתפוס 71 מתוך 74. כל דבר שימושי שהמודל הזה יכול לעשות מחמיר את הדיוק שלו. צוות שממטב את מספר הכותרת היה משיק את הגרסה שלא מוצאת כלום.

למה שלוש חלוקות ולא שתיים? כי ברגע שמשתמשים בקבוצת דוגמאות כדי לבחור משהו — סף, קצב למידה, איזה משישה מודלים להשיק — הקבוצה הזו שימשה להתאמה, והציון שלה מפסיק להיות בלתי מוטה.³ במדידה על המסוע הזה: סריקת הסף על סט האימות בוחרת 0.196, ואז המודל מקבל F1 = 0.4122 על סט הבדיקה שלא נגעו בו. אילו הסריקה הייתה מתבצעת ישירות על סט הבדיקה, הטוב ביותר שהיה אפשר להשיג שם היה 0.4186 — מספר שאף אחד לא זכאי לדווח עליו.

הפער קטן כאן, 0.006, כי זה hyperparameter אחד שנסרק פעם אחת מול 4,000 דוגמאות אימות. הוא גדל עם כל החלטה נוספת ועם כל הקטנה של סט האימות. שימו לב גם שהכיוון אינו מובטח בריצה יחידה: הסף שנבחר קיבל 0.3902 באימות ו-0.4122 בבדיקה, כך שהאימות המעיט בערכו הפעם. ההטיה שיטתית על פני החלטות רבות, לא גלויה באחת.⁴

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

Recall עולה מ-10.8 % ל-77.0 %. F1 גדל ביותר מפי ארבעה. ושימו לב מה הדיוק עשה: 98.30 % → 99.20 %, רווח של תשע עשיריות נקודה, שזה מסוג המספרים שמתעגלים ל-"בערך 99 % כך או כך" בשקף סיכום. הדיוק לא ראה את הכישלון קודם ועכשיו לא רואה את התרמית.

לפני שממשיכים לקרוא: המודל מרמה. מצאו איך.

station = 1.8 + rng.exponential(0.35, N)                     # a part just passing through
audited = rng.random(N) < 0.006                              # random spot checks
station[audited] += rng.uniform(6.0, 26.0, audited.sum())
station[y == 1] = 9.0 + rng.exponential(7.0, (y == 1).sum())  

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

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

נניח שאתם מדרגים מודל על 20 דוגמאות והוא צודק ב-17. אתם מדווחים 85 %.

17 correct out of 20 -> accuracy 0.8500
  Wilson    95% CI : [0.6396, 0.9476]
  bootstrap 95% CI : [0.7000, 1.0000]
  P(a 65% model scores 17 or more out of 20) = 0.0444
  P(an 85% model scores 17 or more out of 20) = 0.6477

הקריאה הכנה של 17/20 היא איפשהו בין 64 % ל-95 %. מודל שבאמת עומד על 65 % מייצר את התוצאה הזו ב-4.4 % מהמקרים — ריצה אחת מתוך עשרים ושלוש — ואם ניסיתם קומץ prompts ודיווחתם על הטוב ביותר, ייצרתם את הריצה הזו בעצמכם. שבע-עשרה מתוך עשרים לא יכולות להבדיל בין מודל של 85 % למודל של 65 %.

שתי דרכים לשים רווח סמך על שיעור, ושתיהן שייכות לארגז הכלים שלכם:

def wilson(k, n, z=1.959963985):
    """95% interval for k successes in n trials. Correct at small n; no simulation."""
    ph, d = k / n, 1 + z * z / n
    centre = (ph + z * z / (2 * n)) / d
    half = z * (ph * (1 - ph) / n + z * z / (4 * n * n)) ** 0.5 / d
    return centre - half, centre + half


def bootstrap_ci(correct, n_resamples=10_000, alpha=0.05, seed=0):
    """95% interval for the mean of any per-example score array. Works on F1 too."""
    rng = np.random.default_rng(seed)
    correct = np.asarray(correct, dtype=float)
    draws = correct[rng.integers(0, len(correct), size=(n_resamples, len(correct)))]
    lo, hi = np.quantile(draws.mean(axis=1), [alpha / 2, 1 - alpha / 2])
    return float(correct.mean()), float(lo), float(hi)

השתמשו ב-Wilson⁶ לשיעור הצלחה פשוט; הוא נשאר מתנהג היטב בכל $n$ ואינו דורש אקראיות. שימו לב למעלה שב-$n = 20$ הקצה העליון של ה-bootstrap הוא 1.0000 — דגימה מחדש של 20 נקודות יכולה בקלות למשוך 20 נכונות, לכן היא לא יכולה לייצג רווח סמך צר יותר מהגרנולריות שלה עצמה. השתמשו ב-bootstrap⁷ במקום שבו אין נוסחה, וזה רוב המקרים המעניינים: F1, ממוצעי macro, BLEU, pass@1, ציון של שופט מבוסס rubric. במסוע הזה, ה-F1 של המודל המכוונן, 0.4122, נושא רווח bootstrap של [0.3009, 0.5156] — וזה המספר שצריך להופיע בדוח, כי האומדן הנקודתי לבדו מזמין השוואה שהוא לא יכול לתמוך בה.

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

model A: 0.8580  95% CI [0.8260, 0.8880]
model B: 0.8120  95% CI [0.7780, 0.8460]
the two intervals overlap: True
paired difference A-B: 0.0460  95% CI [0.0260, 0.0680]
they disagree on 31 of 500 examples (A right 27, B right 4)

הרווחים שלהם חופפים, וכלל האצבע — פסי שגיאה חופפים פירושם שאין הבדל מובהק — היה קורא להשוואה לא חד-משמעית. היא לא. שני המודלים רצו על אותן דוגמאות, לכן הכמות הנכונה היא ההפרש לכל דוגמה, שהרווח שלו הוא [0.0260, 0.0680], בנוחות מעל אפס. הם חולקים רק על 31 מתוך 500 פריטים, ו-A מנצח ב-27 מאותן מחלוקות; הדוגמאות המשותפות, קלות וקשות כאחד, מתבטלות במקום להוסיף רעש. השוו מודלים בזוגות, ותגיעו לאותה מסקנה משבריר מהנתונים.

עכשיו יש לכם מודל שמוציא הסתברויות מכוילות, הפסד שנגזר מטענה על הנתונים במקום להיבחר מטעמי נוחות, gradient שהוא ממש חיזוי פחות אמת, ו — חשוב יותר — את המנגנון לברר אם משהו מזה עובד. רווח Wilson בן עשר השורות למעלה משמש שוב כלשונו: הוא נושא את וריאציות ה-prompt ב-פרק 15, את טבלאות השליפה ב-פרק 19, ואת ה-golden set ב-פרק 29. ה-bootstrap הוא מה שפונים אליו כשאין נוסחה.

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

שם נגמר ה-gradient המסודר של הפרק הזה. כל מה שלמעלה עבד כי $\partial L/\partial s = p - y$ היה ניתן לכתיבה ידנית, פעם אחת, עבור מודל עם שכבה אחת בין הקלט להפסד. שמים שכבה שנייה באמצע והשאלה משנה צורה: מה הנגזרת של ההפסד ביחס למשקל שלא נוגע בכלל בפלט — כזה שההשפעה שלו מגיעה רק דרך שכבה אחרת, אולי לאורך כמה נתיבים בבת אחת?

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

זה פרק 5, וזה המנוע שעליו רץ שאר הקורס.

כדאי לקרוא לצד הפרק הזה גם את Bishop, Pattern Recognition and Machine Learning §1.2, §1.5, §1.6 ו-§4.3, שמכסה הסתברות, תורת החלטות, תורת האינפורמציה וסיווג ליניארי בסדר שהפרק הזה הולך לפיו; Murphy, Probabilistic Machine Learning: An Introduction, פרקים 6 ו-10; Prince, Understanding Deep Learning §5.4–5.7; ואת Saito and Rehmsmeier, The Precision-Recall Plot Is More Informative than the ROC Plot When Evaluating Binary Classifiers on Imbalanced Datasets (PLOS ONE, 2015) — למה ה-AUC שצוטט למעלה לא צריך להיות המספר היחיד בלי סף שאתם מסתכלים עליו כש-1.7 % מהחלקים פגומים.