Loss Function کہاں سے آتا ہے: Likelihood، روایت نہیں

یہ readings اور تین lines ہیں، تین طریقوں سے scored: squared error، جس کی طرف سب پہلے جاتے ہیں؛ absolute error، جسے شاید statistician چنے؛ اور worst error، جسے machinist چنے گا، کیونکہ inspector کو آپ کے average سے غرض نہیں — وہ tolerance سے باہر واحد part کو reject کرتا ہے۔

NumPy یہاں pure-Python perceptron کے ایک chapter بعد ایک وجہ سے آتا ہے: اس chapter کے آخر تک ہم چار لاکھ candidate lines کو، ہر ایک کو بیس readings کے against، evaluate کرتے ہیں، اور Python loop اس کے لیے غلط tool ہے۔ یہ وہ notation بھی ہے جس میں نیچے cited ہر source لکھی گئی ہے۔

import numpy as np

# Hours since the blade was changed, and the width of the part measured then.
SHIFT = np.array([
    (0.5, 20.17), (1.0, 20.28), (1.5, 20.53), (2.0, 20.61), (2.5, 20.69),
    (3.0, 20.94), (3.5, 21.21), (4.0, 21.31), (4.5, 21.27), (5.0, 21.35),
    (5.5, 21.58), (6.0, 21.80), (6.5, 21.67), (7.0, 22.07), (7.5, 22.10),
    (8.0, 22.31), (8.5, 22.48), (9.0, 22.66), (9.5, 22.90), (10.0, 23.13),
])
h, y = SHIFT[:, 0], SHIFT[:, 1]

LINES = {"A": (20.10, 0.26), "B": (20.20, 0.28), "C": (20.30, 0.26)}

for name, (a, b) in LINES.items():
    r = y - (a + b * h)                                      
    print(f"{name}   mean square {np.mean(r**2):.5f}"
          f"   mean absolute {np.mean(np.abs(r)):.5f}"
          f"   worst {np.max(np.abs(r)):.3f}")               

highlighted lines میں quantity residual ہے: line نے کیا کہا minus caliper نے کیا کہا، ہر reading کے لیے ایک number۔ اس chapter کا ہر scoring rule، اور اس کے بعد آنے والے اٹھائیس chapters کا ہر loss function، residuals کی list کو ایک single number میں squash کرنے کا کوئی طریقہ ہے۔ فرق صرف یہ ہے کہ وہ squash کیسے کرتے ہیں۔

A   mean square 0.02699   mean absolute 0.12600   worst 0.430
B   mean square 0.02524   mean absolute 0.13700   worst 0.350
C   mean square 0.03179   mean absolute 0.15000   worst 0.320

columns پڑھیں، rows نہیں۔ squared error کہتا ہے B، absolute error کہتا ہے A، worst error کہتا ہے C: ایک ہی بیس points پر تین rules، تین winners۔

میں نے یہ تین lines اس طرح چنی تھیں کہ وہ disagree کریں، اور مجھے یہ صاف کہنا چاہیے۔ point یہ ہے کہ یہ کتنا آسان تھا — sensible-looking intercepts اور slopes پر چند منٹ کی search ایسے سینکڑوں triples نکال دیتی ہے۔ ranking آپ کے chosen rule کی خاصیت ہے، lines کے بارے میں fact نہیں، لہٰذا rule implementation detail نہیں: وہ problem کی definition ہے۔ جس سے وہ سوال اٹھتا ہے جس کا جواب دینے کے لیے یہ chapter ہے: آپ اسے کن بنیادوں پر choose کرتے ہیں؟

پہلے ایک چھوٹی بات، کیونکہ lines تین نہیں بلکہ infinitely many ہیں۔ فی الحال squared error لیں، چونکہ سب یہی لیتے ہیں، اور اس trick سے problem کو ایک single number تک shrink کریں جس نے Chapter 1 میں perceptron کو گیارہ ہزار epochs بچائے تھے: دونوں columns سے mean subtract کریں۔ جب points کا cloud origin پر centred ہو جائے تو squared error کے تحت best line عین origin سے گزرتی ہے — so intercept settle ہو گیا اور choose کرنے کو صرف slope رہ گیا۔

u, v = h - h.mean(), y - y.mean()        # 5.25 hours, 21.553 mm

def mse(theta):
    return np.mean((v - theta * u) ** 2)

grid = np.arange(0.0, 0.6001, 0.001)
curve = np.array([mse(t) for t in grid])
print(grid.size, "candidates ->", f"theta={grid[curve.argmin()]:.3f}", f"mse={curve.min():.6f}")

601 candidates -> theta=0.293 mse=0.010115

چھ سو ایک candidate slopes، ایک winner: 0.293 ملی میٹر per hour، truth 0.300 کے مقابلے میں۔ بیس noisy readings اور ایک for-loop ایک ملی میٹر فی گھنٹہ کے سوویں حصے تک پہنچ گئے — دو اور ایک تہائی percent۔

دلچسپ چیز winner نہیں بلکہ search کی shape ہے۔ پوری curve print کریں، rotate کر کے تاکہ loss left to right چلے:

ts = np.arange(0.0, 0.6001, 0.04)
ls = np.array([mse(t) for t in ts])
for t, l in zip(ts, ls):
    col = round(l / ls.max() * 50)
    print(f"theta={t:.2f} |{' ' * col}*{' ' * (50 - col)}| mse={l:7.4f}")

theta=0.00 |                                              *    | mse= 0.7244
theta=0.04 |                                  *                | mse= 0.5428
theta=0.08 |                        *                          | mse= 0.3878
theta=0.12 |                *                                  | mse= 0.2593
theta=0.16 |          *                                        | mse= 0.1575
theta=0.20 |     *                                             | mse= 0.0822
theta=0.24 |  *                                                | mse= 0.0336
theta=0.28 | *                                                 | mse= 0.0116
theta=0.32 | *                                                 | mse= 0.0161
theta=0.36 |   *                                               | mse= 0.0473
theta=0.40 |       *                                           | mse= 0.1050
theta=0.44 |            *                                      | mse= 0.1894
theta=0.48 |                   *                               | mse= 0.3004
theta=0.52 |                            *                      | mse= 0.4379
theta=0.56 |                                      *            | mse= 0.6021
theta=0.60 |                                                  *| mse= 0.7928

یہ ایک valley ہے، side سے دیکھی ہوئی۔ اس کا ایک bottom ہے، walls دونوں طرف smoothly اوپر جاتے ہیں، اور — یہ وہ حصہ ہے جو Chapter 1 کی staircase نہیں دے سکتی تھی — اس پر ہر single point پر "downhill" کی well-defined direction موجود ہے۔ اس shape کو یاد رکھیں۔ Chapter 3 پورا اس بات پر ہے کہ تمام چھ سو ایک points visit کیے بغیر اس کے نیچے کیسے walk کیا جائے، اور جب valley کے ایک سے زیادہ bottom ہوں تو کیا بدلتا ہے۔

ہمare پاس valley اس لیے ہے کہ ہم نے square کیا۔ absolute error bottom پر kink دیتا؛ worst error flat stretches دیتا جہاں line کو move کرنے سے کچھ بھی نہیں بدلتا۔ Squaring بے شک convenient ہے — اور convenience ہی تقریباً وہ وجہ ہے جو زیادہ تر courses چار انداز میں سجا کر دیتے ہیں: یہ errors کو positive بنا دیتا ہے (absolute value بھی بناتی ہے)؛ یہ بڑے errors کو زیادہ punish کرتا ہے (کیوں کرنا چاہیے؟)؛ یہ differentiable ہے (fourth power بھی ہے)؛ یہ وہی ہے جو سب use کرتے ہیں (ہے، اور یہ argument نہیں)۔

ایمان دار position یہ ہے۔ squared error نے line B select کی اور absolute error نے line A۔ ان میں سے ایک اس factory کے لیے right ہے اور دوسری wrong، اور اب تک کہی گئی کوئی بات نہیں بتا سکتی کہ کون سی۔ rule choose کرنے کے لیے آپ کو کچھ جاننا ہو گا کہ readings line سے different کیسے ہوئیں، اور یہ mathematics کے بارے میں نہیں بلکہ world کے بارے میں سوال ہے۔ اس کا جواب دینے کے لیے machinery کا ایک چھوٹا ٹکڑا چاہیے۔

یہ وہ claim ہے جو "کون سی line بہتر ہے" کو ایک answer والے سوال میں بدلتا ہے۔

Assume کریں part کی width line plus random error ہے، اور assume کریں کہ error Gaussian — bell curve — سے draw ہوئی ہے، mean zero اور standard deviation $\sigma$ کے ساتھ:

Gaussian کی density ہے

اب وہ کریں جو perceptron نہیں کر سکتا تھا۔ ایک given candidate slope $\theta$ کے لیے ہر reading کا residual ہے، اور اوپر کی formula اس residual کو ایک number میں بدلتی ہے: اگر یہ slope truth ہے تو exactly اس size کی error کتنی plausible ہے؟ line پر پڑی reading کو بڑا number ملتا ہے، آدھا millimetre دور reading کو چھوٹا۔

readings independent ہیں — caliper پچھلے part کو remember نہیں کرتا — so product rule کہتا ہے کہ whole notebook کی plausibility individual densities کا product ہے۔ یہی product $\theta$ کی likelihood ہے۔¹ direction note کریں، کیونکہ Bayes' rule اسی direction کے بارے میں ہے: data fixed اور known ہے، اور parameter vary کرتا ہے۔ یہ "slope کی probability" نہیں۔ یہ وہ probability ہے جو model آپ کو actually ملے data کو assign کرتا ہے، slope کے function کے طور پر read کی ہوئی۔

SIGMA = 0.12

def gaussian(r, sigma):
    return np.exp(-r ** 2 / (2 * sigma ** 2)) / (sigma * np.sqrt(2 * np.pi))

def likelihood(theta):
    return np.prod(gaussian(v - theta * u, SIGMA))          

for t in (0.25, 0.293, 0.35):
    print(f"theta={t}   likelihood = {likelihood(t):.6g}")

theta=0.25   likelihood = 521.952
theta=0.293   likelihood = 2.42028e+07
theta=0.35   likelihood = 0.190312

0.293 کا slope اس notebook کو 0.25 کے مقابلے میں چھیالیس ہزار times زیادہ plausible بناتا ہے، اور 0.35 کے مقابلے میں ایک سو ستائیس million times زیادہ plausible۔ Maximum likelihood وہ principle ہے کہ آپ وہ parameter pick کرتے ہیں جو آپ نے actually observe کیا اسے as unsurprising as possible بنائے۔ یہ theorem نہیں بلکہ proposal ہے کہ "best" کا مطلب کیا ہونا چاہیے — content والا proposal، کیونکہ یہ آپ کو noise کے بارے میں اپنا assumption state کرنے پر مجبور کرتا ہے، اس سے پہلے کہ آپ کچھ score کر سکیں۔

ایک shift کے بجائے پورے مہینے کی shifts پر وہی تین lines of code چلائیں، اور method گر پڑتا ہے۔

rng = np.random.default_rng(7)
u_big = rng.uniform(-5.25, 5.25, 2000)                     # 2000 readings, not 20
v_big = 0.30 * u_big + 0.12 * rng.standard_normal(2000)

print("2000 readings, sigma = 0.12 mm :", np.prod(gaussian(v_big - 0.30 * u_big, 0.12)))
noisy = 0.30 * u_big + 2.0 * rng.standard_normal(2000)
print("2000 readings, sigma = 2.00 mm :", np.prod(gaussian(noisy - 0.30 * u_big, 2.0)))
print("largest float64 :", np.finfo(np.float64).max)

RuntimeWarning: overflow encountered in reduce
2000 readings, sigma = 0.12 mm : inf
2000 readings, sigma = 2.00 mm : 0.0
largest float64 : 1.7976931348623157e+308

دو ہزار multiplications اور answer inf ہے۔ ایک constant بدلیں — sloppier caliper، تاکہ densities 1 سے large کے بجائے smaller نکلیں — اور وہی code 0.0 return کرتا ہے۔ دونوں answers غلط ہیں، opposite directions میں، neither کوئی exception raise کرتا ہے جسے آپ catch کر سکیں، اور دوسرا تو warning بھی print نہیں کرتا۔

mathematics میں کچھ غلط نہیں۔ ان settings پر likelihood ایک perfectly well-defined finite number ہے: اس کا natural logarithm 1400.91 ہے، so number خود تقریباً $10^{608}$ ہے۔ problem یہ ہے کہ آپ کے computer کے پاس وہ number نہیں، اور یہ سمجھنا worth ہے کہ اس کے پاس exactly کون سے numbers ہیں، کیونکہ یہ آخری بار نہیں جب یہ outcome decide کرے گا۔

exploding product کا fix معمول والا ہے: logarithms لیں۔ logarithm products کو sums میں بدلتا ہے، یہ strictly increasing ہے so maximum کی location نہیں بدل سکتا، اور دو ہزار moderate numbers کا sum ایسی چیز ہے جسے float64 بغیر شکایت handle کر لیتا ہے۔ convention سے ہم negative log-likelihood لیتے ہیں، تاکہ better کا مطلب smaller ہو۔ اب Gaussian density substitute کریں اور دیکھیں کیا ہوتا ہے۔

یہ وہ result ہے جس کے لیے یہ chapter موجود ہے، اور اسے بغیر hedging کے state کرنا چاہیے: squared error کوئی convention نہیں۔ یہ Gaussian کی negative log-likelihood ہے، constants removed کے ساتھ۔ squared error minimise کرنا عین وہی act ہے جیسے assert کرنا کہ آپ کی errors Gaussian ہیں اور پوچھنا کہ کون سا parameter آپ کے data کو least surprising بناتا ہے۔ آپ یہ assertion شروع سے کر رہے تھے؛ بس آپ کو بتایا نہیں جا رہا تھا۔

equivalence checkable ہے، so check کریں: وہی چھ سو ایک slopes full negative log-likelihood، constants and all، کے ساتھ scan کریں، اور plain squared error کے ساتھ بھی۔

N = v.size

def nll(theta):
    r = v - theta * u
    return N * np.log(SIGMA * np.sqrt(2 * np.pi)) + np.sum(r ** 2) / (2 * SIGMA ** 2)

nlls = np.array([nll(t) for t in grid])
mses = np.array([mse(t) for t in grid])
print(f"argmin of the negative log-likelihood : theta={grid[nlls.argmin()]:.3f}  nll={nlls.min():.6f}")
print(f"argmin of the mean squared error      : theta={grid[mses.argmin()]:.3f}  mse={mses.min():.6f}")
print("same index:", nlls.argmin() == mses.argmin())

argmin of the negative log-likelihood : theta=0.293  nll=-17.001977
argmin of the mean squared error      : theta=0.293  mse=0.010115
same index: True

vertical axis پر different numbers، اور ان میں سے ایک negative ہے، جو sum of squares کبھی نہیں ہوتا: negative log-likelihood zero سے نیچے جا سکتی ہے، کیونکہ density 1 سے exceed کر سکتی ہے۔ same valley کا same bottom، last grid point تک۔

ہم نے $\sigma$ کو fiat سے 0.12 پر fix کیا، اور plant میں کسی کو اپنے caliper کی error کا spread معلوم نہیں۔ اسے second unknown سمجھیں اور maximum likelihood کو اسے بھی decide کرنے دیں۔ یہاں constant term جسے ہم ابھی discard کر رہے تھے واپس آتا ہے، کیونکہ یہی واحد چیز ہے جو model اور perfect precision کے claim کے بیچ کھڑی ہے۔

r = v - 0.293 * u
sigmas = np.arange(0.01, 1.0001, 0.0001)
nll_sigma = N * np.log(sigmas * np.sqrt(2 * np.pi)) + np.sum(r ** 2) / (2 * sigmas ** 2)

print("best sigma on the grid       :", round(float(sigmas[nll_sigma.argmin()]), 4))
print("sqrt(mean squared residual)  :", round(float(np.sqrt(np.mean(r ** 2))), 4))

best sigma on the grid       : 0.1006
sqrt(mean squared residual)  : 0.1006

دونوں four decimals تک agree کرتے ہیں، اور accidentally نہیں: اس expression کو differentiate کر کے zero پر set کرنے سے exactly $\hat{\sigma}^2 = \frac{1}{N}\sum r_i^2$ ملتا ہے۔ so mean squared error محض variance جیسا نہیں۔ اس model کے تحت یہ noise کی variance کا maximum-likelihood estimate ہے — جس number کو آپ شروع سے minimise کر رہے تھے وہ اصل میں یہ estimate تھا کہ آپ کا sensor کتنا noisy ہے۔

ایک wrinkle، کہنا cheap اور بعد میں rediscover کرنا expensive: یہ estimate low biased ہے، کیونکہ residuals ایک ایسے fit کے against measure ہوئے جو خود انہیں small بنانے کے لیے chosen تھا۔ اسے simulate کریں — بیس readings کی دو لاکھ notebooks، ایسی distribution سے drawn جس کی true variance exactly 1 ہے، fit کا ایک parameter خود readings سے estimated۔ sum of squares کو $N$ سے divide کرنے سے average 0.9501 آتا ہے؛ $N-1$ سے divide کرنے سے 1.0001؛ اور $(N-1)/N$ exact 0.95 ہے۔ ہر parameter جو آپ fit کرتے ہیں ایک degree of freedom cost کرتا ہے، اور یہ بہت بڑے problem کی smallest visible instance ہے: model ہمیشہ اس data پر بہتر دکھتا ہے جس پر اسے fit کیا گیا۔ Chapter 4 اسے data hold back کرنے کی discipline میں بدلتا ہے، اور Chapter 6 effect کو اس کا نام دیتا ہے۔

اگر squared error assert کرتا ہے کہ noise Gaussian ہے، اگلا سوال یہ ہے کہ جب assertion false ہو تو کیا ہوتا ہے۔ تھوڑا false نہیں — اس طرح false جیسے real measurements false ہوتی ہیں۔

shop floor پر زیادہ تر caliper readings ایک tenth of a millimetre تک اچھی ہوتی ہیں، اور shift میں ایک دو بار swarf کا chip jaw کے نیچے آ جاتا ہے اور reading کئی millimetres off ہو جاتی ہے۔ ایسی errors heavy-tailed ہیں: زیادہ تر small، کبھی کبھار enormous، اور enormous اتنی بار جتنی bell curve allow نہیں کرتی۔ Cauchy distribution اس behaviour کا standard clean model ہے، اور اس کی density Gaussian کی طرح simple ہے:

فرق tail ہے: Gaussian $e^{-\varepsilon^2}$ کی طرح fall off کرتا ہے، brutally fast، اور Cauchy $1/\varepsilon^2$ کی طرح، بمشکل ہی۔ consequence کہنا آسان نہیں مگر دیکھنا آسان ہے:

rng = np.random.default_rng(3)
g = 0.12 * rng.standard_normal(10 ** 6)          # Gaussian noise
c = 0.12 * rng.standard_cauchy(10 ** 6)          # Cauchy noise, same scale
for k in (10 ** 2, 10 ** 3, 10 ** 4, 10 ** 5, 10 ** 6):
    print(f"{k:>9,} samples   gaussian var {g[:k].var():.4f}   cauchy var {c[:k].var():10.2f}")

      100 samples   gaussian var 0.0164   cauchy var       0.26
    1,000 samples   gaussian var 0.0146   cauchy var      59.88
   10,000 samples   gaussian var 0.0145   cauchy var     358.17
  100,000 samples   gaussian var 0.0144   cauchy var    3097.98
1,000,000 samples   gaussian var 0.0144   cauchy var   32886.10

Gaussian کا sample variance 0.0144 پر settle ہوتا ہے، جو $0.12^2$ ہے، اور وہیں رہتا ہے۔ Cauchy کا چڑھتا ہے، اور sample کرتے رہنے تک چڑھتا رہتا ہے، کیونکہ converge کرنے کو کچھ ہے ہی نہیں: Cauchy distribution کی variance نہیں، اور mean بھی نہیں۔ squared error، جس کا whole business squares کے average کو minimise کرنا ہے، ایسی quantity مانگ رہا ہے جو exist نہیں کرتی۔

تو یہ ایک shift ہے جہاں caliper fool ہوا۔ وہی بیس hours، وہی blade، وہی 0.30 ملی میٹر per hour کا drift — صرف noise اب Cauchy ہے۔ اسے دو بار fit کریں: ایک بار squared residuals minimise کر کے، ایک بار اس noise کی negative log-likelihood minimise کر کے جس نے actually data generate کیا۔ centring trick یہاں help نہیں — یہ intercept کو صرف squared error کے لیے pin کرتی ہے — so دونوں fits intercepts اور slopes کے grid پر brute force سے جاتے ہیں، کیونکہ ہمارے پاس اب بھی valley کا bottom ڈھونڈنے کا کوئی طریقہ نہیں سوائے اسے visit کرنے کے۔

SWARF = np.array([
    (0.5, 20.08), (1.0, 21.95), (1.5, 20.86), (2.0, 27.51), (2.5, 20.64),
    (3.0, 20.75), (3.5, 21.01), (4.0, 21.03), (4.5, 21.37), (5.0, 20.60),
    (5.5, 22.03), (6.0, 21.95), (6.5, 21.98), (7.0, 22.01), (7.5, 21.73),
    (8.0, 22.97), (8.5, 22.60), (9.0, 22.66), (9.5, 22.44), (10.0, 22.78),
])
hs, ys = SWARF[:, 0], SWARF[:, 1]

A = np.arange(18.0, 22.001, 0.005)      # 801 intercepts
B = np.arange(-0.20, 0.8001, 0.002)     # 501 slopes
R = ys - (A[:, None, None] + B[None, :, None] * hs)      # every line against every point

SCALE = 0.12
square = np.sum(R ** 2, axis=2)                          # least squares          
cauchy = np.sum(np.log(1 + (R / SCALE) ** 2), axis=2)    # Cauchy likelihood      

for name, surface in (("least squares", square), ("Cauchy likelihood", cauchy)):
    i, j = np.unravel_index(surface.argmin(), surface.shape)
    print(f"{name:>18}:  width = {A[i]:.3f} + {B[j]:.4f} * hours"
          f"   -> 23.5 mm at hour {(23.5 - A[i]) / B[j]:.2f}")
print(f"{'the truth':>18}:  width = 20.000 + 0.3000 * hours"
      f"   -> 23.5 mm at hour {(23.5 - 20.0) / 0.30:.2f}")
print(f"{A.size * B.size:,} candidate lines evaluated")

دو highlighted lines ہی fits کے درمیان entire difference ہیں۔ Cauchy density کا log لیں، constants پہلے کی طرح exactly drop کریں، اور $\sum \log\left(1 + (r/s)^2\right)$ باقی بچتا ہے۔ same recipe، noise کے بارے میں different claim۔

     least squares:  width = 21.380 + 0.1080 * hours   -> 23.5 mm at hour 19.63
 Cauchy likelihood:  width = 19.935 + 0.3020 * hours   -> 23.5 mm at hour 11.80
         the truth:  width = 20.000 + 0.3000 * hours   -> 23.5 mm at hour 11.67
401,301 candidate lines evaluated

Least squares 0.108 ملی میٹر فی گھنٹہ کا drift report کرتا ہے، real rate کے تقریباً ایک تہائی، اور conclude کرتا ہے کہ blade hour 19.6 تک good ہے۔ true answer hour 11.7 ہے۔ اس fit پر عمل کرتے ہوئے plant press کو آٹھ extra hours چلاتا ہے اور field کے سب سے standard loss function کے authority پر tolerance سے باہر parts بناتا رہتا ہے۔ Cauchy fit، وہی بیس readings، وہی grid، اور code میں ایک line کے فرق سے، hour 11.8 پر land کرتا ہے۔

دو objections answers deserve کرتے ہیں، کیونکہ دونوں وہ پہلی بات ہیں جو اچھا engineer کہتا ہے۔

outlier obvious ہے — بس اسے delete کر دیں۔ آپ کر سکتے ہیں، اور اس سے help ہوتی ہے، مگر یہ enough نہیں۔ single worst reading delete کرنے سے least-squares slope 0.108 سے 0.239 ہو جاتا ہے، جو پھر بھی blade change کو hour 13.1 پر رکھتا ہے، ڈیڑھ گھنٹہ late؛ worst کو delete کر کے، refit کر کے، اور جو اب worst ہے اسے delete کرنے سے آپ 0.286 تک پہنچتے ہیں — اور note کریں کہ یہ پہلے ہی ایک procedure ہے، observation نہیں: original fit کے دو largest residuals delete کریں تو آپ 0.223 پر land کرتے ہیں۔ مگر اب آپ نے judgement calls کر لی ہیں جنہیں آپ write down یا defend نہیں کر سکتے، اور rule automate کرنا اسے rescue نہیں کرتا: drop-the-largest-residual-then-refit، ایک ہزار simulated shifts پر run کیا گیا، likelihood fit کے 0.0100 کے مقابلے میں 0.0177 کا median slope error رکھتا ہے، اور shifts کے 14.7% میں 0.05 سے زیادہ off ہے، 1.3% کے مقابلے میں۔ deletion wrong assumption کے اوپر patch ہے۔ likelihood کو patch نہیں چاہیے، کیونکہ اس نے کبھی assume نہیں کیا کہ outlier impossible ہے۔

آپ نے lucky dataset pick کیا۔ یہ objection بالکل right ہے، اسی لیے last experiment ایک ہزار independent shifts simulate کرتا ہے اور ہر ایک پر دونوں ways refit کرتا ہے۔

A = np.arange(18.0, 22.001, 0.02)        # a coarser grid: a thousand fits to do
B = np.arange(-0.20, 0.8001, 0.005)
lines = A[:, None, None] + B[None, :, None] * hs
rng = np.random.default_rng(2026)
err_sq, err_ca = [], []

for _ in range(1000):                                        # 1000 independent shifts
    ys = 20.00 + 0.30 * hs + SCALE * rng.standard_cauchy(hs.size)
    R = ys - lines
    _, j = np.unravel_index(np.sum(R ** 2, axis=2).argmin(), (A.size, B.size))
    _, q = np.unravel_index(np.sum(np.log1p((R / SCALE) ** 2), axis=2).argmin(), (A.size, B.size))
    err_sq.append(abs(B[j] - 0.30))
    err_ca.append(abs(B[q] - 0.30))

err_sq, err_ca = np.array(err_sq), np.array(err_ca)
for name, e in (("least squares", err_sq), ("Cauchy likelihood", err_ca)):
    print(f"{name:>18}: median slope error {np.median(e):.4f} mm/h"
          f"   off by more than 0.05 in {100 * np.mean(e > 0.05):4.1f}% of shifts"
          f"   worst {e.max():.3f}")
print(f"the likelihood fit is the closer of the two in {100 * np.mean(err_ca < err_sq):.1f}% of shifts")

     least squares: median slope error 0.0350 mm/h   off by more than 0.05 in 40.4% of shifts   worst 0.500
 Cauchy likelihood: median slope error 0.0100 mm/h   off by more than 0.05 in  1.3% of shifts   worst 0.090
the likelihood fit is the closer of the two in 75.6% of shifts

Median، mean نہیں، اسی وجہ سے جس وجہ سے اس section میں ہر چیز ہے: least-squares errors Cauchy سے driven ہیں، so ان کا average report کرنے کے لیے stable چیز نہیں۔ Least squares پانچ میں سے دو shifts میں badly wrong ہے؛ likelihood fit ستتر میں سے ایک shift میں badly wrong ہے، اور ایک ہزار shifts میں اس کی worst failure least squares کی worst کا پانچواں حصہ بھی نہیں۔

اس میں سے کچھ بھی squared error کو bad نہیں بناتا۔ یہ اسے specific بناتا ہے، اور arithmetic exactly بتاتی ہے کیوں۔ 0.1 mm کا residual اور 7 mm کا residual لیں۔ Squared، bad reading total میں good reading کے مقابلے میں 4,900 times زیادہ contribute کرتی ہے، so line bodily اس کی طرف dragged ہو جاتی ہے؛ Cauchy log-likelihood کے تحت وہی دو residuals 0.527 اور 8.133 contribute کرتے ہیں، ratio 15.4۔ bad reading اب بھی count کرتی ہے، بس decide کرنے نہیں پاتی۔ یہی robust statistics کی beginning ہے، جہاں Huber کا 1964 loss small residuals کے لیے quadratically اور large ones کے لیے linearly behave کر کے فرق split کرتا ہے،⁷ اور جہاں Tukey پہلے ہی دکھا چکا تھا کہ sample variance کو mean absolute deviation سے worse tool بنانے کے لیے کتنی کم contamination کافی ہے۔⁸

ایک historical note بھی، اتنا اچھا کہ چھوڑا نہیں جا سکتا۔ Least squares پہلے Legendre نے 1805 میں publish کیا، ایک convenient algebraic device کے طور پر جس کی justification بس یہ تھی کہ یہ کام کرتا تھا۔⁹ چار سال بعد Gauss نے argument کو الٹا چلایا: اس نے given لیا کہ repeated measurements combine کرنے کا right way arithmetic mean ہے، پوچھا کہ کون سی error distribution mean کو most probable value بناتی ہے، اور دکھایا کہ essentially صرف ایک کرتی ہے — وہ جو اب اس کے نام سے ہے۔¹⁰ اس chapter کی derivation اسی کی ہے، دو centuries سے زیادہ پرانی ہے، اور پھر بھی وہی part ہے جو زیادہ تر courses چھوڑ دیتے ہیں۔

مگر valley کو دوبارہ دیکھیں۔ $\theta = 0.20$ پر 0.0822 loss کے ساتھ کھڑے ہوں تو "downhill" کی direction mystery نہیں — آپ page پر دیکھ سکتے ہیں، curve right کی طرف down slope کرتی ہے۔ اگر آپ loss function سے پوچھ سکیں کہ وہ اس point پر جہاں آپ کھڑے ہیں کس طرف slope کرتی ہے، کہیں اور evaluate کیے بغیر، تو آپ اسی طرف step لے سکتے ہیں، دوبارہ پوچھ سکتے ہیں، اور repeat کر سکتے ہیں جب تک زمین flat نہ ہو جائے۔

اس سوال کا ایک نام ہے۔ کسی point پر function کا slope اس کا derivative ہے، اور many parameters کے function کے لیے ہر direction میں slopes کا collection gradient ہے۔ Chapter 1 اسے use نہیں کر سکتا تھا، کیونکہ perceptron کی error ایسی staircase تھی جس سے slope پوچھا ہی نہیں جا سکتا تھا۔ اس chapter نے کچھ بہتر بنایا ہے: ایک loss جو ہر جگہ smooth ہے اور جو preference کے بجائے stated assumption سے آیا ہے۔

لہٰذا Chapter 3 کا سوال اب یہ نہیں کہ slope exists ہے یا نہیں۔ سوال یہ ہے کہ اسے compute کیسے کیا جائے، اس کے against move کرنا uphill کے بجائے downhill کیوں جاتا ہے — ایک sign جسے تقریباً ہر course آپ سے faith پر لینے کو کہتا ہے — اور دوبارہ پوچھنے سے پہلے کتنا step لیا جائے، جو نکلتا ہے وہی ایک number ہے جو decide کرتا ہے کہ training run converge کرے گا، answer کے around ہمیشہ oscillate کرے گا، یا infinity کی طرف بھاگ جائے گا۔

اس chapter کے ساتھ یہ بھی پڑھنے کے قابل ہیں: Prince, Understanding Deep Learning §5.1–5.2 and Appendix C، جو یہاں used order میں book کا ہر loss maximum likelihood سے build کرتا ہے؛ Goodfellow, Bengio and Courville, Deep Learning §3.1–3.11 and §5.5، whose maximum-likelihood section وہ KL divergence بھی derive کرتا ہے جو Chapter 4 کو چاہیے؛ Murphy, Probabilistic Machine Learning: An Introduction chapter 2 and §4.2، اس پر کہ maximum likelihood کیا guarantee کرتا ہے اور کیا نہیں؛ Deisenroth, Faisal and Ong, Mathematics for Machine Learning §6.1–6.4 for the sum rule, product rule and Bayes' rule done properly؛ Tom Mitchell کا short CMU note Estimating Probabilities: MLE and MAP (2016)؛ اور Dive into Deep Learning کا §22.7، جو runnable code میں same result تک پہنچتا ہے۔