Classification، cross-entropy، اور خود کو دھوکا نہ دینے کا طریقہ

وہی factory جو باب 1 میں تھی، مگر سوال مشکل ہے۔ accept یا reject کے بجائے سوال ہے کیا یہ پرزہ defective ہے — اور defects نایاب ہیں، جس سے اس باب کا measuring نصف مشکل اور modelling نصف دھوکے سے آسان ہو جاتا ہے۔

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

تین splits، دو نہیں۔ وجہ اپنی الگ section کی مستحق ہے اور نیچے ملے گی؛ ابھی کے لیے پہلے پر train کریں، دوسرے پر tune کریں، اور تیسرے کو نہ دیکھیں۔

Features standardised ہیں — mean منہا، standard deviation سے divide — صرف training statistics استعمال کرتے ہوئے، اسی وجہ سے جو باب 1 نے perceptron کے convergence bound کے ساتھ دکھائی تھی: uncentred data geometry کو hostile بنا دیتا ہے۔ یہ mean کن rows سے compute کرنے کی اجازت ہے، اسی باب میں آگے چل کر ایک زندہ سوال بنے گا۔

Perceptron نے sign لوٹایا تھا۔ Sign reject اور reject، مگر بمشکل میں فرق نہیں کر سکتا، اور یہی فرق factory کو یہ فیصلہ کرنے کے لیے چاہیے کہ کون سے parts human سے پہلے دوبارہ inspect کروائے جائیں۔

لہٰذا باب 2 کی recipe کو لفظی طور پر follow کریں۔ لکھیں کہ آپ label کے پیدا ہونے کے بارے میں کیا claim کرتے ہیں، likelihood لیں، log لیں، اسے negate کریں، اور آپ کے پاس loss ہے۔ yes/no outcome کے لیے claim ایک Bernoulli distribution ہے: probability $p$ ہے کہ part defective ہے، اور

جو بس یہ لکھنے کا compact طریقہ ہے کہ ”$p$ اگر $y = 1$، اور $1-p$ اگر $y = 0$“۔ اس کا log لیں اور اسے negate کریں، تو ایک example کے لیے loss ہے

یہ binary cross-entropy ہے۔ اسے اس لیے نہیں چنا گیا کہ یہ convenient ہے؛ یہ اس واحد distribution کی negative log-likelihood ہے جو coin flip کے پاس ہو سکتی ہے۔ کوئی اور چیز دستیاب ہی نہیں تھی۔

اب بھی یہ رہ گیا ہے کہ $p$ کہاں سے آتا ہے۔ model ایک weighted sum $s = \mathbf{w}\cdot\mathbf{x} + b$ compute کرتا ہے، جو real number ہے اور پوری line پر range کرتا ہے، جبکہ probability کو $(0,1)$ میں رہنا ہوتا ہے۔ ان دونوں کے بیچ حرکت کرانے والا function 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

دائیں ہاتھ والے column کو price list سمجھ کر پڑھیں۔ 90 % confidence کے ساتھ درست ہونے کی قیمت 0.105 ہے۔ commit نہ کرنے کی قیمت 0.693 ہے — یعنی $\log 2$، کندھے اچکانے کی قیمت۔ confidence کے ساتھ غلط ہونے کی قیمت 4.6 ہے، چوالیس گنا زیادہ، اور جیسے جیسے model اپنی غلطی پر زیادہ یقین کرتا ہے، قیمت لا محدود بڑھتی ہے۔ Cross-entropy صرف errors نہیں گنتی: یہ تکبر کا بل بناتی ہے۔

باب 3 نے کہا: کسی بھی چیز کو train کرنے کے لیے، loss کی ہر parameter کے respect میں derivative حاصل کریں۔ اسے ایک example کے لیے کریں۔ $s = \mathbf{w}\cdot\mathbf{x} + b$ اور $p = \sigma(s)$ کے ساتھ:

لہٰذا update ہے prediction minus truth، times input۔ اور کچھ نہیں۔ یہ پورا trainer ہے، جو باب 3 کا descent ہے صرف ایک line بدل کر:

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

sigmoid میں np.where cosmetic نہیں ہے۔ $1/(1+e^{-s})$ کو directly compute کرنا large negative $s$ کے لیے overflow کر جاتا ہے؛ branch وہ algebraically identical form چنتی ہے جو exponent کو negative رکھے۔ یہ باب 2 کا floating-point box اپنا پہلا قرض وصول کر رہا ہے، اور دو sections بعد بڑا قرض وصول کرے گا۔

Cross-entropy کو squared error پر prefer کرنے کی standard explanation اوپر والا likelihood argument ہے: squared error Gaussian noise assume کرنے سے ملتا ہے، labels Gaussian نہیں، لہٰذا نہ کریں۔ یہ درست ہے اور کسی کو قائل نہیں کرتا، کیونکہ آپ sigmoid کے اوپر $L = (p - y)^2$ لکھ سکتے ہیں اور یہ train ہو جائے گا۔

جو دلیل اثر کرتی ہے وہ gradient کے بارے میں ہے۔ sigmoid کے اوپر squared error رکھیں تو chain rule دیتا ہے

وہ extra $p(1-p)$ وہی ہے جو پہلے cancel ہوا تھا۔ اب نہیں ہوتا، اور جب بھی model confident ہوتا ہے یہ zero کی طرف جاتا ہے — اس وقت بھی جب model confidence کے ساتھ غلط ہو۔ دونوں کو چند scores پر evaluate کریں، ایک ایسے example کے لیے جس کا true label 1 ہے:

$s = -8$ پر model اتنا غلط ہے جتنا ممکن ہے، اور squared error ایسا gradient دیتا ہے جو cross-entropy کے gradient سے 1,491 گنا چھوٹا ہے۔ غلطی جتنی worse ہو، model اس سے اتنا کم سیکھتا ہے۔ Cross-entropy کا gradient، اس کے برعکس، $-1$ پر saturate ہوتا ہے: maximally wrong ایک maximally large signal دیتا ہے، اور اس سے بڑا نہیں۔

Race چلائیں۔ دو ہزار balanced points، identical starting weights جو confidently wrong ہونے کے لیے چنے گئے ہیں ($\mathbf{w} = [-6, -6]$)، identical learning rate، فرق صرف loss کا ہے۔ دونوں runs کو cross-entropy سے score کیا گیا ہے تاکہ columns comparable ہوں۔

Cross-entropy epoch 50 تک finish ہو چکی ہے۔ Squared error epoch 100 پر بھی 24 % accuracy پر ہے — اور epoch 10 کے 23 % سے move نہیں ہوا تھا — guessing سے بھی بدتر، کیونکہ اس نے confidently wrong start کیا اور جو gradient اسے rescue کرتا اسے 0.0007 سے multiply کر دیا گیا۔ یہ تقریباً epoch 500 پر escape کرتا ہے اور اسی جگہ پہنچتا ہے۔ لہٰذا ایماندار summary یہ ہے کہ sigmoid کے اوپر squared error incorrect نہیں؛ یہ بالکل وہاں slow ہے جہاں speed سب سے زیادہ معنی رکھتی ہے۔ دو-parameter model پر آپ 450 epochs کھو دیتے ہیں۔ سو layers والے network پر، جہاں کہیں نہ کہیں کوئی unit ہمیشہ confidently wrong ہوتا ہے، آپ training run کھو دیتے ہیں۔

تین quantities، باب 8 میں perplexity کے لیے اور باب 11 میں اس penalty کے لیے جو fine-tuned policy کو اس کے reference کے قریب رکھتی ہے، ٹھیک طرح چاہیے ہوں گی۔ یہ اپنی reputation سے آسان ہیں۔²

Entropy bits کی average تعداد ہے جو آپ کو کسی distribution سے draw کو communicate کرنے کے لیے خرچ کرنا پڑتی ہے، اگر آپ اس کے لیے best possible code استعمال کریں:

Cross-entropy وہ خرچ ہے جب آپ $q$ کے لیے بنایا گیا code اس data پر استعمال کریں جو حقیقت میں $p$ سے آتا ہے:

KL divergence excess ہے — bits میں waste — جو $q$ پر یقین کرنے سے پیدا ہوتا ہے جب truth $p$ ہو:

Belt پر تینوں check کریں:

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

وہاں دو چیزیں نظر آتی ہیں۔ پہلی، ایک model جو صرف training base rate، 1.69 %، report کرتا ہے، 0.1330 bits کی cross-entropy حاصل کرتا ہے، تقریباً بالکل test labels کی entropy — جیسا کہ لازمی ہے، کیونکہ اس کے پاس درست distribution ہے اور کوئی دوسری information نہیں۔ Entropy وہ floor ہے جو فرد کے بارے میں ignorance آپ کو خرید کر دیتی ہے۔ دوسری، ایک model جو کندھے اچکا کر 0.5 کہتا ہے، ٹھیک 1 bit ادا کرتا ہے، اور دونوں کے بیچ gap، 0.8671 bits، بالکل KL divergence ہے۔ $H + D_{\mathrm{KL}} = H(p,q)$ memorize کرنے کی identity نہیں؛ یہ ایک bill ہے جسے آپ add ہوتے دیکھ سکتے ہیں۔

اور training سے connection: جب label ایک single known class ہو، ”true“ distribution one-hot ہوتی ہے، اس کی entropy zero ہوتی ہے، اور cross-entropy برابر KL divergence ہوتی ہے۔ Cross-entropy کو minimise کرنا اور model کی distribution کو truth کی طرف کھینچنا ایک ہی عمل ہے۔

Defective ایک چیز نہیں۔ moulding میں part short shot (material کافی نہیں)، flash (بہت زیادہ، mould سے باہر نچڑا ہوا)، یا burn بن کر نکل سکتا ہے۔ چار outcomes، لہٰذا چار logits، اور انہیں چار probabilities بننا ہے جن کا sum one ہو۔ یہ softmax ہے:

اس کی ایک property ہے جو accident جیسی لگتی ہے مگر دراصل پوری implementation ہے:

کسی بھی constant $c$ کے لیے، کیونکہ $e^{z_i + c} = e^{c} e^{z_i}$ اور $e^c$ اوپر اور نیچے cancel ہو جاتے ہیں۔ logits کے بیچ صرف differences معنی رکھتے ہیں۔ absolute level information نہیں ہے۔

خوش قسمتی ہے، کیونکہ absolute level ہی computer کو توڑتا ہے:

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}$ ایک 64-bit float کو overflow کرتا ہے، sum infinity بن جاتا ہے، اور infinity divided by infinity nan ہے — نہ error، نہ crash، بس ایک silent hole جہاں تین probabilities ہوا کرتی تھیں۔ maximum logit کو subtract کرنا mathematically کچھ نہیں بدلتا اور numerically سب کچھ بدل دیتا ہے، کیونکہ largest exponent بالکل $e^0 = 1$ بن جاتا ہے۔ یہ باب 2 کا logsumexp trick ہے work clothes پہن کر، اور ہر serious implementation یہی کرتی ہے:

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 پھر وہی prediction minus truth ہے، اب $Y$ one-hot کے ساتھ۔ binary case شروع سے ہی special case تھا۔

3,000 parts پر trained اور 1,000 پر tested، ہر ایک کے تین measurements (width، weight، melt temperature) کے ساتھ، یہ 94.00 % accuracy تک پہنچتا ہے۔ یہ ہے وہ چیز جو یہ number چھپا رہا ہے:

Model نصف سے کم short shots پکڑتا ہے۔ Accuracy یہ نہیں دیکھ سکتی، کیونکہ 86 % parts fine ہیں اور انہیں درست پکڑنا average کو اٹھانے کے لیے کافی ہے۔ Macro F1 — per-class F1 scores کا mean، جو rare class کو common class جتنا weight دیتا ہے — 0.7983 ہے، micro F1 کے 0.9400 کے مقابل، جو definition کے لحاظ سے accuracy کے identical ہے۔ جب بھی کوئی ایک F1 number report کرے، پوچھیں کون سا۔

Modelling یہاں ختم ہوئی۔ باقی chapter numbers کے بارے میں ہے۔

Trained binary model لیں اور ہر logit کو constant سے multiply کر کے دو variants بنائیں: hesitant version کے لیے 0.35، overconfident کے لیے 4۔ positive number سے multiply کرنے سے کوئی sign بدل نہیں سکتا، اس لیے تینوں models تمام 4,000 test parts کے لیے بالکل وہی label predict کرتے ہیں۔ Accuracy انہیں الگ نہیں بتا سکتی۔ Cross-entropy کو کوئی مشکل نہیں:

Hesitant model ہر part پر چھوٹا tax دیتا ہے، ان ہزاروں پر بھی جنہیں یہ درست پکڑتا ہے۔ Overconfident model درست ہونے پر تقریباً free ہے اور غلط ہونے پر catastrophic — اس test set کا ایک part اکیلا اسے 27.63 nats خرچ کراتا ہے۔ دونوں مخالف routes سے تقریباً ایک ہی total پر آتے ہیں، اور trained model، جس کی probabilities data کے مطابق calibrated ہیں، دونوں سے تین گنا نیچے بیٹھتا ہے۔

یہ loss اور metric کے فرق کو بیان کرنے کا سب سے تیز طریقہ ہے۔ Loss وہ ہے جسے آپ optimise کرتے ہیں: اسے differentiable ہونا چاہیے، اور یہ model کی ہر بات دیکھتا ہے، یہ بھی کہ وہ کتنا sure تھا۔ Metric وہ ہے جس پر آپ کو judge کیا جاتا ہے: یہ step function، business rule، missed defects کی count ہو سکتا ہے۔ یہ ایک ہی object نہیں ہیں اور ہمیشہ agree نہیں کرتے — اسی لیے آپ شروع کرنے سے پہلے دونوں define کرتے ہیں، اور loss کو metric کی جگہ کبھی کھڑا نہیں ہونے دیتے صرف اس لیے کہ وہ screen پر موجود ہے۔

کسی بھی model سے پہلے requirement: سب سے lazy possible answer کیا score کرتا ہے؟ اس belt پر، ہمیشہ fine کہو:

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

98.15 %۔ اب trained logistic model، default 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 percentage point سے beat کیا، اور جو report accuracy پر رک جائے گی وہ اسے win کہے گی۔ Confusion matrix بتاتا ہے کہ اصل میں کیا ہوا:

اس نے 74 میں سے 8 defective parts پکڑے اور 66 کو گزرنے دیا۔ تین numbers اس table کو پڑھنے کے تین طریقوں کے نام ہیں:

• Precision $= \mathrm{TP}/(\mathrm{TP}+\mathrm{FP}) = 8/10 = 0.800$۔ جن parts کو اس نے flag کیا، ان میں کتنے واقعی defective تھے۔ یہ wasted inspections کی cost ہے۔
• Recall $= \mathrm{TP}/(\mathrm{TP}+\mathrm{FN}) = 8/74 = 0.108$۔ defective parts میں سے اس نے کتنے پکڑے۔ یہ customer کو bad part ship کرنے کی cost ہے۔
• F1 $= 2PR/(P+R) = 0.190$، ان دونوں کا harmonic mean، جو چھوٹے والے کے قریب رہتا ہے اور اس لیے ان میں سے صرف ایک سے flattering قبول نہیں کرتا۔

کون سا matter کرتا ہے، یہ factory پر depend کرتا ہے، mathematics پر نہیں: inspection چند seconds لیتی ہے اور shipped defect ایک recall notice بن سکتا ہے، اس لیے یہاں recall غالب ہے اور 0.108 failure ہے۔

لیکن model مسئلہ نہیں۔ Threshold مسئلہ ہے، اور threshold model کا حصہ نہیں — یہ probability کے بعد apply کیا گیا business decision ہے۔ اسے sweep کریں:

Accuracy column کو نیچے پڑھیں۔ یہ پورے راستے گرتی ہے — 98.30 % سے 65.93 % تک — جبکہ model 8 defects پکڑنے سے 74 میں سے 71 پکڑنے تک جاتا ہے۔ یہ model جو بھی useful کام کر سکتا ہے، وہ اس کی accuracy کو worse بناتا ہے۔ headline number optimise کرنے والی team وہ version ship کرے گی جو کچھ نہیں ڈھونڈتا۔

تین splits کیوں، دو کیوں نہیں؟ کیونکہ جس لمحے آپ examples کے کسی set کو کچھ بھی choose کرنے کے لیے استعمال کرتے ہیں — threshold، learning rate، چھ models میں سے کون ship کرنا ہے — وہ set fitting کے لیے استعمال ہو چکا ہے، اور اس کا score unbiased نہیں رہتا۔³ اس belt پر measured: validation set پر threshold sweep کرنے سے 0.196 چنا جاتا ہے، اور پھر model untouched test set پر F1 = 0.4122 score کرتا ہے۔ اگر sweep براہِ راست test set پر چلائی جاتی، تو وہاں best achievable 0.4186 تھا — ایک ایسا number جسے report کرنے کا کسی کو حق نہیں۔

Gap یہاں چھوٹا ہے، 0.006، کیونکہ یہ ایک hyperparameter تھا جو 4,000 validation examples کے مقابل ایک بار sweep ہوا۔ یہ ہر extra decision اور validation set کے ہر shrink کے ساتھ بڑھتا ہے۔ یہ بھی نوٹ کریں کہ single run میں direction guaranteed نہیں: chosen threshold نے validation پر 0.3902 اور test پر 0.4122 score کیا، لہٰذا validation نے اس بار اسے understate کیا۔ Bias کئی decisions پر systematic ہے، ایک میں visible نہیں۔⁴

اب exercise۔ Belt log ایک تیسرے column، station_seconds، کے ساتھ آتا ہے: ہر part نے inspection station پر کتنا وقت گزارا۔ اسے add کرنا preprocessing میں one-line change ہے۔ یہ جو کرتا ہے وہ یہ ہے:

Recall 10.8 % سے 77.0 % پر چلا جاتا ہے۔ F1 چار گنا سے بھی زیادہ ہو جاتا ہے۔ اور دھیان دیں accuracy نے کیا کیا: 98.30 % → 99.20 %، point کے نو دسویں کا gain، ایسا number جو summary slide میں ”تقریباً 99 % دونوں طرح“ کہہ کر round ہو جاتا ہے۔ Accuracy پہلے failure دیکھنے میں fail ہوئی اور اب fraud دیکھنے میں fail ہوتی ہے۔

آگے پڑھنے سے پہلے: model cheat کر رہا ہے۔ معلوم کریں کیسے۔

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

Highlighted line leak ہے: defective part کا dwell time مختلف distribution سے draw ہوتا ہے، کیونکہ human نے اسے belt سے اٹھایا۔ Applied machine learning میں یہ سب سے common serious bug ہے، اور اس کا نام ہے: target leakage — training features میں ایسی information جو prediction کے moment پر available نہیں ہوتی۔⁵ یہ کوئی exception نہیں پھینکتا۔ یہ بہتر number produce کرتا ہے۔ Project میں ہر incentive اسے keep کرنے کی طرف اشارہ کرتا ہے۔

Defence ایک سوال ہے، جو ہر column سے پوچھا جاتا ہے: جس instant مجھے یہ prediction چاہیے، کیا یہ value ابھی exist کرتی ہے؟ Live belt پر، station_seconds تب تک unknown ہے جب تک part inspect نہ ہو جائے — جو وہ چیز ہے جسے model replace کرنے والا تھا۔

فرض کریں آپ model کو 20 examples پر score کرتے ہیں اور یہ 17 درست کرتا ہے۔ آپ 85 % report کرتے ہیں۔

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 کی honest reading ہے کہیں 64 % اور 95 % کے بیچ۔ واقعی 65 % model یہ result 4.4 % وقت produce کرتا ہے — تئیس runs میں ایک — اور اگر آپ نے handful of prompts آزما کر best report کیا، تو آپ نے وہ run خود manufacture کیا۔ بیس میں سے سترہ ایک 85 % model کو 65 % model سے distinguish نہیں کر سکتے۔

Rate پر interval لگانے کے دو طریقے، اور دونوں آپ کے toolkit میں ہونے چاہئیں:

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)

Plain success rate کے لیے Wilson⁶ استعمال کریں؛ یہ کسی بھی $n$ پر well behaved رہتا ہے اور randomness نہیں مانگتا۔ اوپر note کریں کہ $n = 20$ پر bootstrap کا upper end 1.0000 ہے — 20 points resample کرنا آسانی سے 20 correct ones draw کر سکتا ہے، اس لیے یہ اپنی granularity سے narrower interval represent نہیں کر سکتا۔ Bootstrap⁷ وہاں استعمال کریں جہاں کوئی formula نہیں، یعنی زیادہ تر interesting cases: F1، macro-averages، BLEU، pass@1، rubric-based judge کا score۔ اس belt پر، tuned model کے 0.4122 F1 کا bootstrap interval [0.3009, 0.5156] ہے — یہی number report میں آنا چاہیے، کیونکہ point estimate اکیلا ایسی comparison کی دعوت دیتا ہے جسے یہ support نہیں کر سکتا۔

ایک اور measurement، کیونکہ یہ بدل دیتی ہے کہ آپ دو models کیسے compare کریں۔ دو models انہی 500 examples پر scored:

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)

ان کے intervals overlap کرتے ہیں، اور folk rule — overlapping error bars کا مطلب significant difference نہیں — comparison کو inconclusive کہے گا۔ ایسا نہیں ہے۔ دونوں models انہی examples پر چلے، اس لیے صحیح quantity per-example difference ہے، جس کا interval [0.0260, 0.0680] ہے، آرام سے zero سے اوپر۔ وہ 500 items میں سے صرف 31 پر disagree کرتے ہیں، اور A ان disagreements میں سے 27 جیتتا ہے؛ shared examples، easy اور hard دونوں، noise add کرنے کے بجائے cancel ہو جاتے ہیں۔ Models کو paired compare کریں، اور آپ data کے ایک fraction سے وہی conclusion لے آتے ہیں۔

اب آپ کے پاس ایک model ہے جو calibrated probabilities output کرتا ہے، ایک loss جو convenience کے بجائے data کے بارے میں claim سے derived ہے، ایک gradient جو لفظی طور پر prediction minus truth ہے، اور — زیادہ اہم — یہ معلوم کرنے کی machinery کہ اس میں سے کچھ کام بھی کرتا ہے یا نہیں۔ اوپر والا ten-line Wilson interval verbatim reuse ہوتا ہے: یہ باب 15 میں prompt variants، باب 19 میں retrieval tables، اور باب 29 میں golden set کو carry کرتا ہے۔ Bootstrap وہ ہے جس کی طرف آپ اس وقت جاتے ہیں جب کوئی formula نہیں ہوتا۔

مگر model اب بھی ایک layer ہے۔ یہ ایک line draw کرتا ہے، اور باب 1 نے XOR کی چار rows سے prove کیا تھا کہ line کافی نہیں۔ Fix stack کرنا ہے: پہلی layer جو space کو bend کرتی ہے، دوسری جو bent space میں line draw کرتی ہے۔

یہی وہ جگہ ہے جہاں اس باب کا tidy gradient ختم ہوتا ہے۔ اوپر سب کچھ اس لیے کام کر گیا کہ $\partial L/\partial s = p - y$ input اور loss کے بیچ ایک layer والے model کے لیے ایک بار ہاتھ سے لکھا جا سکتا تھا۔ بیچ میں دوسری layer رکھیں تو سوال کی شکل بدل جاتی ہے: loss کی derivative اس weight کے respect میں کیا ہے جو output کو بالکل touch نہیں کرتا — ایک ایسا weight جس کا influence صرف دوسری layer کے through آتا ہے، ممکن ہے ایک ساتھ کئی paths سے؟

وہ derivative exist کرتی ہے۔ اسے hand سے compute کرنا toy سے بڑی کسی بھی چیز کے لیے hopeless ہے، اور اسے ایک وقت میں ایک parameter کے لیے compute کرنا ایک مختلف scale پر hopeless ہے۔ ضرورت ایک procedure کی ہے جو forward pass کے ابھی چل کر آنے والے اسی graph پر ایک single backward pass سے network کی ہر derivative نکال دے۔

یہ باب 5 ہے، اور یہی engine ہے جس پر باقی course چلتا ہے۔

اس باب کے ساتھ پڑھنے کے قابل مزید: Bishop, Pattern Recognition and Machine Learning §1.2, §1.5, §1.6 and §4.3، جو probability، decision theory، information theory اور linear classification کو اسی order میں cover کرتا ہے جسے یہ chapter follow کرتا ہے؛ 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) — کیوں اوپر quoted AUC وہ واحد threshold-free number نہیں ہونا چاہیے جسے آپ دیکھیں جب 1.7 % parts defective ہوں۔