طبقه‌بندی، Cross-Entropy، و چطور خودتان را فریب ندهید

همان کارخانه‌ی فصل 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

سه split، نه دو تا. دلیلش ارزش بخش جداگانه دارد و پایین‌تر یکی می‌گیرد؛ فعلاً روی اولی train کنید، روی دومی tune کنید، و به سومی نگاه نکنید.

ویژگی‌ها standardised شده‌اند — میانگین کم شده، بر انحراف معیار تقسیم شده — و این کار فقط با آمارهای training انجام شده است، به همان دلیلی که فصل 1 با کران همگرایی perceptron نشان داد: داده‌ی نامرکز هندسه را خصمانه می‌کند. اینکه مجازید میانگین را از کدام ردیف‌ها حساب کنید، بعدتر در همین فصل به یک پرسش زنده تبدیل می‌شود.

perceptron یک علامت برمی‌گرداند. علامت نمی‌تواند رد را از رد، اما با اختلاف کم جدا کند، و همین تفاوت دقیقاً چیزی است که یک کارخانه برای تصمیم‌گرفتن درباره‌ی اینکه انسان اول کدام قطعات را دوباره بازرسی کند نیاز دارد.

پس دستور فصل 2 را عیناً دنبال کنید. بنویسید ادعایتان درباره‌ی اینکه label چگونه تولید می‌شود چیست، likelihood را بگیرید، log را بگیرید، منفی‌اش کنید، و یک loss دارید. برای خروجی بله/خیر، ادعا یک توزیع Bernoulli است: احتمالی $p$ وجود دارد که قطعه معیوب باشد، و

که فقط روش فشرده‌ای برای نوشتن این است: «$p$ اگر $y = 1$، و $1-p$ اگر $y = 0$». log آن را بگیرید و منفی‌اش کنید، و loss برای یک نمونه می‌شود

این binary cross-entropy است. چون راحت است انتخاب نشده؛ negative log-likelihood تنها توزیعی است که یک پرتاب سکه می‌تواند داشته باشد. چیز دیگری در دسترس نبود.

چیزی که هنوز کم است این است که $p$ از کجا می‌آید. مدل یک جمع وزن‌دار $s = \mathbf{w}\cdot\mathbf{x} + b$ حساب می‌کند، که یک عدد حقیقی است و روی کل خط حقیقی حرکت می‌کند، اما احتمال باید در $(0,1)$ زندگی کند. تابعی که میان این دو جابه‌جا می‌شود logistic sigmoid است:

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 هزینه دارد، چهل‌وچهار برابر بیشتر، و هرچه مدل درباره‌ی یک اشتباه مطمئن‌تر شود، قیمت بدون حد بالا می‌رود. Cross-entropy فقط خطاها را نمی‌شمارد: بابت غرور پول می‌گیرد.

فصل 3 گفت: برای train کردن هر چیزی، مشتق loss نسبت به هر پارامتر را بگیرید. این کار را برای یک نمونه انجام دهید. با $s = \mathbf{w}\cdot\mathbf{x} + b$ و $p = \sigma(s)$:

پس update یعنی پیش‌بینی منهای حقیقت، ضرب‌در ورودی. همین و بس. این کل trainer است، همان descent فصل 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})$ برای $s$های منفیِ بزرگ overflow می‌کند؛ branch شکلی را انتخاب می‌کند که از نظر جبری یکسان است اما exponent را منفی نگه می‌دارد. این اولین بدهی‌ای است که جعبه‌ی floating-point فصل 2 وصول می‌کند، و دو بخش دیگر بدهی بزرگ‌تری خواهد گرفت.

توضیح استاندارد برای ترجیح cross-entropy به squared error همان استدلال likelihood بالاست: squared error چیزی است که از فرض Gaussian noise به دست می‌آید، labelها Gaussian نیستند، پس این کار را نکنید. درست است و هیچ‌کس را قانع نمی‌کند، چون می‌توانید $L = (p - y)^2$ را روی sigmoid بنویسید و train خواهد شد.

استدلالی که می‌نشیند درباره‌ی گرادیان است. squared error را روی sigmoid بگذارید و chain rule می‌دهد

آن $p(1-p)$ اضافه همان چیزی است که قبلاً حذف شد. حالا حذف نمی‌شود، و هر وقت مدل مطمئن باشد به صفر میل می‌کند — حتی وقتی مدل با اطمینان اشتباه است. هر دو را در چند امتیاز ارزیابی کنید، برای نمونه‌ای که label واقعی‌اش 1 است:

در $s = -8$ مدل تا جای ممکن اشتباه است، و squared error با گرادیانی پاسخ می‌دهد که 1,491 بار کوچک‌تر از گرادیان cross-entropy است. هرچه اشتباه بدتر باشد، مدل کمتر از آن یاد می‌گیرد. گرادیان cross-entropy، در عوض، در $-1$ اشباع می‌شود: حداکثر اشتباه یک سیگنال حداکثری تولید می‌کند، و نه بزرگ‌تر.

مسابقه را اجرا کنید. دو هزار نقطه‌ی balanced، وزن‌های آغازین یکسان که طوری انتخاب شده‌اند که با اطمینان اشتباه باشند ($\mathbf{w} = [-6, -6]$)، learning rate یکسان، فقط loss فرق می‌کند. هر دو اجرا با cross-entropy امتیازدهی می‌شوند تا ستون‌ها قابل مقایسه باشند.

Cross-entropy تا epoch 50 تمام کرده است. Squared error در epoch 100 هنوز روی 24 % accuracy است — و از 23 % در epoch 10 تکان نخورده بود — بدتر از حدس‌زدن، چون با اطمینان اشتباه شروع کرده و گرادیانی که باید نجاتش می‌داد در 0.0007 ضرب شده است. حوالی epoch 500 فرار می‌کند و به همان نقطه می‌رسد. پس خلاصه‌ی صادقانه این است که squared error روی sigmoid نادرست نیست؛ دقیقاً جایی کند است که سرعت بیشترین اهمیت را دارد. در یک مدل دوپارامتری 450 epoch از دست می‌دهید. در شبکه‌ای با صد لایه، جایی که همیشه یک unit در جایی با اطمینان اشتباه است، کل training run را از دست می‌دهید.

سه کمیت، که در فصل 8 برای perplexity و در فصل 11 برای جریمه‌ای که یک policy با fine-tuning را نزدیک reference نگه می‌دارد به‌درستی لازم‌اند. از شهرتشان آسان‌ترند.²

Entropy میانگین تعداد بیت‌هایی است که باید برای انتقال یک draw از یک توزیع خرج کنید، اگر بهترین code ممکن را برای آن استفاده کنید:

Cross-entropy چیزی است که وقتی code ساخته‌شده برای $q$ را روی داده‌ای استفاده می‌کنید که در واقع از $p$ می‌آید، خرج می‌کنید:

KL divergence اضافه‌هزینه است — هدررفت، بر حسب بیت، ناشی از باورداشتن به $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

دو چیز آنجا پیداست. اول، مدلی که صرفاً نرخ پایه‌ی training، یعنی 1.69 %، را گزارش می‌کند، به cross-entropy برابر 0.1330 بیت می‌رسد، تقریباً دقیقاً entropy labelهای test — همان‌طور که باید، چون توزیع درست را دارد و هیچ اطلاعات دیگری ندارد. Entropy کفی است که ناآگاهی از فرد برای شما می‌خرد. دوم، مدلی که شانه بالا می‌اندازد و می‌گوید 0.5 دقیقاً 1 بیت می‌پردازد، و فاصله‌ی میان این دو، 0.8671 بیت، دقیقاً KL divergence است. $H + D_{\mathrm{KL}} = H(p,q)$ هویتی برای حفظ‌کردن نیست؛ صورتحسابی است که می‌توانید جمع‌شدنش را ببینید.

و اتصالش به training: وقتی label یک کلاس معلوم واحد است، توزیع «واقعی» one-hot است، entropy آن صفر است، و cross-entropy برابر KL divergence می‌شود. کمینه‌کردن cross-entropy و کشیدن توزیع مدل به سمت حقیقت یک کار واحدند.

عیب‌داربودن یک چیز واحد نیست. در قالب‌گیری، یک قطعه می‌تواند به صورت 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}$ یک float 64-bit را overflow می‌کند، جمع بی‌نهایت می‌شود، و بی‌نهایت تقسیم بر بی‌نهایت می‌شود nan — نه خطا، نه crash، فقط حفره‌ای خاموش جایی که قبلاً سه احتمال بود. کم‌کردن بزرگ‌ترین logit از نظر ریاضی هیچ چیز را عوض نمی‌کند و از نظر عددی همه‌چیز را، چون بزرگ‌ترین exponent دقیقاً $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

گرادیان باز هم پیش‌بینی منهای حقیقت است، این بار با $Y$ one-hot. حالت binary از اول فقط یک حالت خاص بود.

پس از train شدن روی 3,000 قطعه و test شدن روی 1,000 قطعه، با سه اندازه‌گیری برای هر کدام (عرض، وزن، دمای مذاب)، به 94.00 % accuracy می‌رسد. این چیزی است که آن عدد پنهان می‌کند:

مدل کمتر از نیمی از short shotها را پیدا می‌کند. Accuracy این را نمی‌بیند، چون 86 % قطعات سالم‌اند و درست‌گرفتن آن‌ها برای بالا نگه‌داشتن میانگین کافی است. Macro F1 — میانگین F1های هر کلاس، که به کلاس نادر همان وزنی را می‌دهد که به کلاس رایج — برابر 0.7983 است، در برابر micro F1 برابر 0.9400 که بنا به تعریف با accuracy یکی است. هر وقت کسی یک عدد F1 گزارش کرد، بپرسید کدام.

این پایان مدل‌سازی است. بقیه‌ی فصل درباره‌ی عددهاست.

مدل binary آموزش‌دیده را بردارید و با ضرب‌کردن هر logit در یک ثابت دو variant بسازید: 0.35 برای نسخه‌ای مردد، 4 برای نسخه‌ای بیش‌ازحد مطمئن. ضرب در عدد مثبت هیچ علامتی را عوض نمی‌کند، پس هر سه مدل برای همه‌ی 4,000 قطعه‌ی test دقیقاً همان label را پیش‌بینی می‌کنند. Accuracy نمی‌تواند آن‌ها را از هم تشخیص دهد. Cross-entropy هیچ مشکلی ندارد:

مدل مردد روی هر قطعه یک مالیات کوچک می‌پردازد، حتی روی هزاران موردی که درست می‌گیرد. مدل بیش‌ازحد مطمئن وقتی درست است تقریباً رایگان است و وقتی اشتباه است فاجعه‌بار — یک قطعه در آن test set به‌تنهایی 27.63 nats هزینه دارد. این دو از مسیرهای مخالف تقریباً به مجموع یکسانی می‌رسند، و مدل train‌شده، که احتمال‌هایش با داده calibrated شده‌اند، سه برابر پایین‌تر از هر دو می‌نشیند.

این تیزترین روش برای بیان تفاوت میان loss و metric است. loss چیزی است که optimize می‌کنید: باید differentiable باشد، و هر چیزی را که مدل گفته می‌بیند، از جمله اینکه چقدر مطمئن بوده. metric چیزی است که با آن قضاوت می‌شوید: می‌تواند step function باشد، business rule باشد، شمارش defectهای ازدست‌رفته باشد. آن‌ها یک شیء نیستند و همیشه هم‌نظر نیستند — برای همین هر دو را پیش از شروع تعریف می‌کنید، و هرگز اجازه نمی‌دهید loss فقط چون روی صفحه است جای metric را بگیرد.

پیش از هر مدل، الزام این است: تنبل‌ترین پاسخ ممکن چه امتیازی می‌گیرد؟ روی این نوار، همیشه بگو سالم است:

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

98.15 %. حالا مدل logistic train‌شده، با threshold پیش‌فرض 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 %. baseline را 0.15 واحد درصد شکست داد، و هر گزارشی که روی accuracy توقف کند این را برد می‌نامد. confusion matrix می‌گوید واقعاً چه اتفاقی افتاده است:

از 74 قطعه‌ی معیوب، 8 تا را پیدا کرد و 66 تا را عبور داد. سه عدد سه روش خواندن آن جدول را نام‌گذاری می‌کنند:

• 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$، میانگین هارمونیک آن دو، که نزدیک کوچک‌ترشان می‌ماند و بنابراین اجازه نمی‌دهد یکی به‌تنهایی چاپلوسی کند.

اینکه کدام مهم است به کارخانه بستگی دارد، نه به ریاضی: بازرسی چند ثانیه هزینه دارد و defect ارسال‌شده یک اعلامیه‌ی recall، پس اینجا recall غالب است و 0.108 شکست است.

اما مشکل مدل نیست. threshold است، و threshold بخشی از مدل نیست — یک تصمیم کسب‌وکاری است که بعداً روی احتمال اعمال می‌شود. آن را sweep کنید:

ستون accuracy را رو به پایین بخوانید. تمام مسیر سقوط می‌کند — از 98.30 % به 65.93 % — در حالی که مدل از گرفتن 8 defect به گرفتن 71 تا از 74 می‌رسد. هر کار مفیدی که این مدل می‌تواند انجام دهد accuracy آن را بدتر می‌کند. تیمی که عدد تیتر را optimize کند نسخه‌ای را ship می‌کند که هیچ چیز پیدا نمی‌کند.

چرا سه split و نه دو تا؟ چون لحظه‌ای که از مجموعه‌ای از نمونه‌ها برای انتخاب هر چیزی استفاده کنید — یک threshold، یک learning rate، اینکه کدام‌یک از شش مدل را ship کنید — آن مجموعه برای fitting استفاده شده است، و score آن دیگر unbiased نیست.³ اندازه‌گیری روی این نوار: sweep کردن threshold روی validation set مقدار 0.196 را انتخاب می‌کند، و سپس مدل روی test set دست‌نخورده F1 = 0.4122 می‌گیرد. اگر sweep مستقیماً روی test set اجرا شده بود، بهترین مقدار دست‌یافتنی آنجا 0.4186 بود — عددی که هیچ‌کس حق گزارش‌دادنش را ندارد.

فاصله اینجا کوچک است، 0.006، چون یک hyperparameter یک‌بار روی 4,000 نمونه‌ی validation sweep شده است. با هر تصمیم اضافه و هر کوچک‌شدن validation set بزرگ‌تر می‌شود. همچنین توجه کنید که جهت در یک اجرای منفرد تضمین‌شده نیست: threshold انتخاب‌شده روی validation مقدار 0.3902 و روی test مقدار 0.4122 گرفت، پس validation این بار آن را کمتر نشان داد. bias در میان تصمیم‌های بسیار systematic است، نه در یکی قابل مشاهده.⁴

حالا تمرین. log نوار با ستون سومی می‌آید، station_seconds: مدت زمانی که هر قطعه در ایستگاه بازرسی گذرانده است. افزودنش به preprocessing یک تغییر یک‌خطی است. این کاری است که می‌کند:

Recall از 10.8 % به 77.0 % می‌رود. F1 بیش از چهار برابر می‌شود. و ببینید accuracy چه کرد: 98.30 % → 99.20 %، سودی برابر نه‌دهم یک point، همان عددی که در یک اسلاید خلاصه به «در هر صورت حدود 99 %» گرد می‌شود. Accuracy قبلاً شکست را ندید و حالا تقلب را نمی‌بیند.

پیش از ادامه: مدل دارد تقلب می‌کند. پیدا کنید چطور.

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())  

خط برجسته همان leak است: dwell time یک قطعه‌ی معیوب از توزیع متفاوتی draw می‌شود، چون انسان آن را از روی نوار برداشته است. این رایج‌ترین باگ جدی در machine learning کاربردی است، و نام دارد: target leakage — اطلاعاتی در ویژگی‌های training که در لحظه‌ای که prediction باید انجام شود در دسترس نخواهد بود.⁵ هیچ exceptionی پرتاب نمی‌کند. عدد بهتری تولید می‌کند. همه‌ی incentiveهای یک پروژه به سمت نگه‌داشتنش اشاره می‌کنند.

دفاع یک پرسش است، از هر ستون: در لحظه‌ای که به این prediction نیاز دارم، آیا این مقدار هنوز وجود دارد؟ روی نوار زنده، 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 % مواقع این نتیجه را تولید می‌کند — یک اجرا از هر بیست‌وسه — و اگر چند prompt را امتحان کرده باشید و بهترین را گزارش داده باشید، خودتان همان اجرا را ساخته‌اید. هفده از بیست نمی‌تواند مدل 85 % را از مدل 65 % تشخیص دهد.

دو راه برای گذاشتن interval روی یک rate، و هر دو باید در جعبه‌ابزارتان باشند:

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)

برای success rate ساده از Wilson⁶ استفاده کنید؛ در هر $n$ خوش‌رفتار می‌ماند و randomness لازم ندارد. بالا توجه کنید که در $n = 20$ انتهای بالایی bootstrap برابر 1.0000 است — resampling از 20 نقطه به‌راحتی می‌تواند 20 مورد درست draw کند، پس نمی‌تواند intervalی باریک‌تر از granularity خودش نمایش دهد. از bootstrap⁷ جایی استفاده کنید که formula وجود ندارد، یعنی بیشتر موارد جالب: F1، macro-averageها، BLEU، pass@1، امتیاز یک judge مبتنی بر rubric. روی این نوار، F1 مدل tune‌شده برابر 0.4122 یک bootstrap interval برابر [0.3009, 0.5156] دارد — و این همان عددی است که باید در گزارش بیاید، چون point estimate به‌تنهایی مقایسه‌ای را دعوت می‌کند که نمی‌تواند پشتیبانی کند.

یک اندازه‌گیری دیگر، چون روش مقایسه‌ی دو مدل را عوض می‌کند. دو مدل روی همان 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)

Intervalهایشان overlap دارند، و قاعده‌ی عامیانه — overlapping error bars یعنی تفاوت معناداری نیست — مقایسه را inconclusive می‌نامید. این‌طور نیست. دو مدل روی همان نمونه‌ها اجرا شده‌اند، پس کمیت درست تفاوت per-example است، که interval آن [0.0260, 0.0680] است و با خیال راحت بالاتر از صفر قرار دارد. آن‌ها فقط روی 31 تا از 500 item اختلاف دارند، و A در 27 تا از آن اختلاف‌ها برنده است؛ نمونه‌های مشترک، آسان و سخت با هم، به‌جای افزودن noise، حذف می‌شوند. مدل‌ها را paired مقایسه کنید، و با کسری از داده به همان نتیجه می‌رسید.

اکنون مدلی دارید که probabilityهای calibrated خروجی می‌دهد، lossی که از ادعایی درباره‌ی داده مشتق شده نه از راحتی انتخاب شده، گرادیانی که عیناً پیش‌بینی منهای حقیقت است، و — مهم‌تر — ماشینی برای فهمیدن اینکه اصلاً چیزی از این‌ها کار می‌کند یا نه. interval ده‌خطی Wilson بالا عیناً دوباره استفاده می‌شود: variantهای prompt در فصل 15، جدول‌های retrieval در فصل 19، و golden set در فصل 29 را حمل می‌کند. وقتی formula وجود ندارد سراغ bootstrap می‌روید.

اما مدل هنوز یک layer است. یک خط می‌کشد، و فصل 1 با چهار ردیف XOR ثابت کرد که خط کافی نیست. راه‌حل stack کردن است: layer اول فضا را خم می‌کند، layer دوم خط را در فضای خم‌شده می‌کشد.

اینجاست که گرادیان تمیز این فصل تمام می‌شود. همه‌ی آنچه بالا آمد کار کرد چون $\partial L/\partial s = p - y$ را می‌شد یک بار، با دست، برای مدلی با یک layer بین input و loss نوشت. یک layer دوم وسط بگذارید و شکل پرسش عوض می‌شود: مشتق loss نسبت به وزنی که اصلاً به output دست نمی‌زند چیست — وزنی که اثرش فقط از طریق layer دیگری می‌رسد، شاید هم‌زمان از چند مسیر؟

آن مشتق وجود دارد. حساب‌کردنش با دست برای هر چیزی بزرگ‌تر از toy ناامیدکننده است، و حساب‌کردنش یکی‌یکی برای هر پارامتر در مقیاسی دیگر ناامیدکننده. چیزی که لازم است procedureای است که هر مشتق در network را از یک backward pass واحد روی همان graphی به دست آورد که forward pass همین الآن طی کرد.

این فصل 5 است، و engineی است که بقیه‌ی این دوره روی آن اجرا می‌شود.

خواندن این‌ها کنار این فصل هم ارزش دارد: Bishop, Pattern Recognition and Machine Learning §1.2, §1.5, §1.6 and §4.3، که probability، decision theory، information theory و linear classification را به همان ترتیبی پوشش می‌دهد که این فصل دنبال می‌کند؛ Murphy, Probabilistic Machine Learning: An Introduction, chapters 6 and 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 نقل‌شده در بالا نباید تنها عدد threshold-free باشد که وقتی 1.7 % قطعات معیوب‌اند به آن نگاه می‌کنید.