Bir Loss Function Nereden Gelir: Gelenekten Değil, Likelihood’dan

İşte okumalar ve üç doğru; üç şekilde puanlanmış: herkesin ilk uzandığı squared error; bir istatistikçinin seçebileceği absolute error; ve makinistin seçeceği worst error, çünkü muayene senin ortalamanla ilgilenmez — tolerans dışı olan tek parçayı reddeder.

NumPy burada, saf Python perceptron’dan bir bölüm sonra, tek bir nedenle sahneye çıkıyor: bu bölümün sonunda dört yüz bin aday doğruyu her biri yirmi okumaya karşı değerlendiriyoruz ve Python döngüsü bunun için yanlış araç. Ayrıca aşağıda alıntılanan her kaynağın yazıldığı gösterim de bu.

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}")               

Vurgulanan satırlardaki nicelik residual’dır: doğrunun söylediği eksi kumpasın söylediği; her okuma için bir sayı. Bu bölümdeki her puanlama kuralı ve bundan sonraki yirmi sekiz bölümdeki her loss function, bir residual listesini tek bir sayıya ezmenin bir yoludur. Yalnızca nasıl ezecekleri bakımından farklılaşırlar.

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

Satırları değil sütunları oku. Squared error B diyor, absolute error A diyor, worst error C diyor: aynı yirmi nokta üzerinde üç kural, üç kazanan.

Bu üç doğruyu özellikle anlaşamasınlar diye seçtim; bunu açıkça söylemeliyim. Asıl mesele bunun ne kadar kolay olduğudur — makul görünen intercept ve eğimler üzerinde birkaç dakikalık arama, böyle yüzlerce üçlü çıkarır. Sıralama, seçtiğin kuralın bir özelliğidir; doğrular hakkında bir olgu değildir. Bu yüzden kural bir uygulama ayrıntısı değildir: problemin tanımı odur. Bu da bu bölümün cevaplamak için var olduğu soruyu doğurur: onu hangi gerekçeyle seçersin?

Önce daha küçük bir mesele, çünkü üç doğru değil sonsuz sayıda doğru vardır. Şimdilik squared error’u alalım, çünkü herkes onu alır, ve problemi Bölüm 1’de perceptron’u on bir bin epoch’tan kurtaran hileyle tek bir sayıya indirelim: iki sütundan da ortalamayı çıkar. Nokta bulutu orijine merkezlendiğinde, squared error altında en iyi doğru tam olarak orijinden geçer — böylece intercept belirlenir ve geriye seçilecek yalnızca eğim kalır.

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

Altı yüz bir aday eğim, bir kazanan: gerçek değer 0,300 iken saatte 0,293 milimetre. Yirmi gürültülü okuma ve bir for-loop, saatte milimetrenin yüzde biri yakınına geldi — yüzde iki virgül üç.

İlginç olan kazanan değil, aramanın şeklidir. Tüm eğriyi, loss soldan sağa aksın diye döndürülmüş halde yazdır:

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

Bu, yandan görülen bir vadidir. Tek bir tabanı vardır, duvarlar iki yanda da düzgünce yükselir ve — Bölüm 1’in merdiveninin sunamadığı kısım budur — üzerindeki her tek noktada iyi tanımlı bir "aşağı iniş" yönü vardır. Bu şekli aklında tut. Bölüm 3 bütünüyle, altı yüz bir noktanın hepsini ziyaret etmeden aşağı yürümekle ve bir vadinin birden fazla tabanı olduğunda neyin değiştiğiyle ilgilidir.

Bir vadimiz var çünkü kare aldık. Absolute error tabanda bir kırık verirdi; worst error ise doğruyu hareket ettirmenin hiçbir şeyi değiştirmediği düz uzantılar verirdi. Kare almak inkâr edilemez biçimde kullanışlıdır — ve çoğu dersin verdiği neden aşağı yukarı kullanışlılıktır, dört farklı kılığa sokulmuş halde: hataları pozitif yapar (absolute value da yapar); büyük hataları daha çok cezalandırır (neden cezalandırsın?); türevlenebilirdir (dördüncü kuvvet de öyle); herkes bunu kullanır (evet kullanır, ama bu bir argüman değildir).

Dürüst konum şu. Squared error B doğrusunu seçti, absolute error A doğrusunu seçti. Bunlardan biri bu fabrika için doğru, diğeri yanlış ve şimdiye kadar söylenen hiçbir şey hangisi olduğunu söyleyemez. Kuralı seçmek için okumaların doğrudan nasıl sapar hale geldiği hakkında bir şey bilmen gerekir; bu da matematik hakkında değil, dünya hakkında bir sorudur. Cevaplamak için küçük bir araç parçası gerekir.

"Hangi doğru daha iyi" sorusunu cevabı olan bir soruya dönüştüren iddia şudur.

Bir parçanın genişliğinin, doğru artı rastgele bir hata olduğunu varsay; bu hatanın da ortalaması sıfır ve standard deviation’ı $\sigma$ olan bir Gaussian’dan — çan eğrisinden — çekildiğini varsay:

Gaussian’ın density’si şudur:

Şimdi perceptron’un yapamadığı bir şey yap. Verilen bir aday eğim $\theta$ için her okumanın bir residual’ı vardır ve yukarıdaki formül bu residual’ı bir sayıya çevirir: eğer bu eğim gerçekse, tam bu büyüklükte bir hata ne kadar makuldür? Doğrunun üzerindeki bir okuma büyük bir sayı alır; yarım milimetre uzaktaki okuma küçük bir sayı.

Okumalar bağımsızdır — kumpas son parçayı hatırlamaz — bu yüzden product rule, bütün defterin makullüğünün tek tek density’lerin çarpımı olduğunu söyler. Bu çarpım, $\theta$’nin likelihood’ıdır.¹ Yönüne dikkat et, çünkü Bayes’ rule’un konusu bu yöndür: veri sabit ve bilinir; değişen parametredir. Bu "eğimin olasılığı" değildir. Modelin gerçekten elde ettiğin veriye atadığı olasılıktır; eğimin bir fonksiyonu olarak okunur.

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’lük bir eğim bu defteri 0,25’e göre kırk altı bin kat, 0,35’e göre yüz yirmi yedi milyon kat daha makul kılar. Maximum likelihood, gerçekten gözlediğin şeyi mümkün olduğunca az şaşırtıcı yapan parametreyi seçme ilkesidir. Bir teorem değil, "en iyi"nin ne anlama gelmesi gerektiğine dair bir öneridir — içeriği olan bir öneri, çünkü herhangi bir şeyi puanlamana izin verilmeden önce gürültü hakkındaki varsayımını belirtmeye zorlar.

Aynı üç kod satırını tek bir vardiya yerine bir aylık vardiyalar üzerinde çalıştır ve yöntem devrilir.

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

İki bin çarpma ve cevap inf. Tek bir sabiti değiştir — daha savruk bir kumpas, böylece density’ler 1’den büyük değil küçük çıksın — ve aynı kod 0.0 döndürür. İki cevap da yanlıştır, zıt yönlerde; hiçbiri yakalayabileceğin bir exception yükseltmez ve ikincisi uyarı bile yazdırmaz.

Matematikte yanlış olan hiçbir şey yok. Bu ayarlardaki likelihood gayet iyi tanımlı sonlu bir sayıdır: doğal logaritması 1400,91’dir, yani sayının kendisi yaklaşık $10^{608}$. Sorun, bilgisayarında o sayının olmamasıdır; bilgisayarında tam olarak hangi sayıların olduğunu anlamaya değer, çünkü sonucu onun belirleyeceği son sefer bu olmayacak.

Patlayan çarpımın çözümü alışılmış çözümdür: logaritma al. Logaritma çarpımları toplamlara çevirir, kesin biçimde artandır, bu yüzden maksimumun yerini değiştiremez ve iki bin makul sayının toplamı float64’ün şikâyetsiz işleyebileceği bir şeydir. Gelenek gereği negative log-likelihood alırız; böylece daha iyi, daha küçük demektir. Şimdi Gaussian density’yi yerine koy ve ne olduğuna bak.

Bölümün varlık nedeni olan sonuç budur ve çekincesiz söylenmeyi hak eder: squared error bir gelenek değildir. Sabitleri çıkarılmış bir Gaussian’ın negative log-likelihood’ıdır. Squared error’u minimize etmek, hatalarının Gaussian olduğunu ileri sürmek ve hangi parametrenin verini en az şaşırtıcı kıldığını sormakla tam olarak aynı eylemdir. Bu iddiayı başından beri yapıyordun; sadece sana söylenmiyordu.

Eşdeğerlik kontrol edilebilir, o yüzden kontrol et: aynı altı yüz bir eğimi tam negative log-likelihood ile, sabitler dâhil, ve düz squared error ile tara.

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

Dikey eksende farklı sayılar ve bunlardan biri negatif; oysa kareler toplamı asla negatif değildir: negative log-likelihood sıfırın altına inebilir, çünkü bir density 1’i aşabilir. Aynı vadinin aynı tabanı, son grid noktasına kadar aynı.

$\sigma$’yı keyfi olarak 0,12’ye sabitledik ve fabrikada kimse kumpas hatasının yayılımını bilmiyor. Onu ikinci bir bilinmeyen olarak ele al ve maximum likelihood’ın buna da karar vermesine izin ver. Az önce attığımız sabit terim burada geri gelir, çünkü model ile kusursuz hassasiyet iddiası arasında duran tek şey odur.

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

İkisi dört ondalığa kadar aynı çıkar ve bu tesadüf değildir: o ifadeyi türevleyip sıfıra eşitlemek tam olarak $\hat{\sigma}^2 = \frac{1}{N}\sum r_i^2$ verir. Yani mean squared error yalnızca bir variance’a benzer değildir. Bu model altında, gürültünün variance’ının maximum-likelihood estimate’idir — başından beri minimize ettiğin sayı, sensörünün ne kadar gürültülü olduğuna dair bir tahmindi.

Kısa söylemesi ucuz, sonra yeniden keşfetmesi pahalı bir pürüz: bu tahmin düşük taraflıdır, çünkü residual’lar zaten onları küçük yapmak için seçilmiş bir fit’e karşı ölçülmüştür. Simüle et — her biri yirmi okumadan oluşan iki yüz bin defter, gerçek variance’ı tam olarak 1 olan bir distribution’dan çekilmiş; fit’in tek parametresi de okumaların kendisinden tahmin edilmiş. Kareler toplamını $N$’ya bölmek 0,9501 ortalama verir; $N-1$’ye bölmek 1,0001 verir; $(N-1)/N$ ise tam 0,95’tir. Fit ettiğin her parametre bir degree of freedom’a mal olur ve bu çok daha büyük bir problemin en küçük görünür örneğidir: bir model, fit edildiği veride her zaman daha iyi görünür. Bölüm 4 bunu veriyi geride tutma disiplinine dönüştürür, Bölüm 6 da etkiye adını verir.

Squared error gürültünün Gaussian olduğunu ileri sürüyorsa, sıradaki soru bu iddia yanlış olduğunda ne olacağıdır. Biraz yanlış değil — gerçek ölçümlerin yanlış olduğu şekilde yanlış.

Atölye zemininde çoğu kumpas okuması milimetrenin onda biri kadar iyidir; vardiyada bir iki kez çenenin altına bir talaş parçası girer ve okuma birkaç milimetre sapar. Böyle hatalar heavy-tailed’dır: çoğu zaman küçük, ara sıra devasa ve bir çan eğrisinin izin verdiğinden çok daha sık devasa. Cauchy distribution bu davranışın standart temiz modelidir ve density’si Gaussian’ınki kadar basittir:

Fark kuyruktadır: Gaussian $e^{-\varepsilon^2}$ gibi, acımasızca hızlı düşer; Cauchy ise $1/\varepsilon^2$ gibi, neredeyse hiç düşmez. Sonucu görmek, söylemekten daha kolaydır:

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’ın sample variance’ı $0.12^2$ olan 0,0144’e oturur ve orada kalır. Cauchy’ninki yükselir ve örneklemeye devam ettiğin sürece yükselmeye devam eder, çünkü yakınsayacağı hiçbir şey yoktur: Cauchy distribution’ın variance’ı yoktur, mean’i de yoktur. Bütün işi karelerin ortalamasını minimize etmek olan squared error’dan var olmayan bir nicelik istenmektedir.

İşte kumpasın kandırıldığı bir vardiya. Aynı yirmi saat, aynı bıçak, saatte aynı 0,30 milimetrelik drift — yalnızca gürültü artık Cauchy. İki kez fit et: bir kez squared residual’ları minimize ederek, bir kez de veriyi gerçekten üreten gürültünün negative log-likelihood’ını minimize ederek. Merkezleme hilesi burada işe yaramaz — intercept’i yalnızca squared error için sabitler — bu yüzden iki fit de intercept ve eğimler üzerinde brute force bir grid ile yapılır; çünkü bir vadinin tabanını ziyaret etmekten başka henüz bulma yolumuz yok.

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

Vurgulanan iki satır, fit’ler arasındaki bütün farktır. Cauchy density’nin log’unu al, sabitleri tam önceki gibi at ve geriye $\sum \log\left(1 + (r/s)^2\right)$ kalır. Aynı tarif, gürültü hakkında farklı iddia.

     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 saatte 0,108 milimetrelik bir drift bildirir; gerçek hızın kabaca üçte biri, ve bıçağın 19,6. saate kadar iyi olduğu sonucuna varır. Gerçek cevap 11,7. saattir. Bu fit’e göre hareket eden fabrika, alanın en standart loss function’ının otoritesiyle tolerans dışı parçalar üreterek presi sekiz saat fazladan çalıştırır. Aynı yirmi okumayı, aynı grid’i ve kodda tek satırlık farkı kullanan Cauchy fit’i 11,8. saate iner.

İki itiraz cevaplanmayı hak eder, çünkü ikisi de iyi bir mühendisin söyleyeceği ilk şeydir.

Outlier apaçık — sil gitsin. Silebilirsin; yardımcı olur; yetmez. Tek en kötü okumayı silmek least-squares eğimini 0,108’den 0,239’a taşır; bu hâlâ bıçak değişimini 13,1. saate koyar, bir buçuk saat geç. En kötüyü silmek, yeniden fit etmek ve şimdi en kötü olanı silmek seni 0,286’ya getirir — ama bunun artık bir gözlem değil bir prosedür olduğuna dikkat et: bunun yerine ilk fit’in en büyük iki residual’ını silersen 0,223’e inersin. Artık yazamadığın ya da savunamadığın yargı kararları verdin ve kuralı otomatikleştirmek onu kurtarmaz: en-büyük-residual’ı-at-sonra-yeniden-fit-et yöntemi, bin simüle vardiya üzerinde çalıştırıldığında, likelihood fit’inin 0,0100 değerine karşı 0,0177 median eğim hatası verir ve vardiyaların %14,7’sinde 0,05’ten fazla saparken likelihood fit’inde bu oran %1,3’tür. Silme, yanlış bir varsayımın üstüne yamadır. Likelihood’ın yamaya ihtiyacı yoktur, çünkü outlier’ın imkânsız olduğunu hiç varsaymamıştır.

Şanslı bir dataset seçtin. Bu itiraz tamamen doğru; son deneyin bin bağımsız vardiyayı simüle edip her birinde iki yolla yeniden fit etmesinin nedeni bu.

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

Mean değil median; bu bölümdeki diğer her şeyle aynı nedenle: least-squares hataları bir Cauchy tarafından sürülür, bu yüzden ortalamaları raporlanacak kararlı bir şey değildir. Least squares beş vardiyanın ikisinde ciddi biçimde yanılır; likelihood fit’i yetmiş yedi vardiyada bir ciddi biçimde yanılır ve bin vardiya içindeki en kötü başarısızlığı, least squares’in en kötüsünün beşte birinden küçüktür.

Bunların hiçbiri squared error’u kötü yapmaz. Onu spesifik yapar ve aritmetik nedenini tam olarak söyler. 0,1 mm’lik bir residual ve 7 mm’lik bir residual al. Karesi alındığında kötü okuma, iyi okumaya göre toplama 4.900 kat daha fazla katkı yapar; bu yüzden doğru bedenen ona doğru sürüklenir. Cauchy log-likelihood altında aynı iki residual 0,527 ve 8,133 katkı yapar; oran 15,4’tür. Kötü okuma hâlâ sayılır, sadece karar vermesine izin verilmez. Bu, Huber’ın 1964 loss’unun küçük residual’lar için karesel, büyükler için doğrusal davranarak arayı böldüğü⁷ ve Tukey’nin sample variance’ı mean absolute deviation’dan daha kötü bir araç yapmak için ne kadar az contamination gerektiğini çoktan gösterdiği robust statistics’in başlangıcıdır.⁸

Dışarıda bırakmak için fazla güzel bir tarihsel not da var. Least squares ilk kez Legendre tarafından 1805’te, işe yaramasının ötesinde gerekçesi olmayan kullanışlı bir cebirsel araç olarak yayımlandı.⁹ Dört yıl sonra Gauss argümanı tersine yürüttü: tekrarlı ölçümleri birleştirmenin doğru yolunun arithmetic mean olduğunu verilmiş kabul etti, hangi error distribution’ın mean’i en olası değer yaptığını sordu ve özünde yalnızca birinin bunu yaptığını gösterdi — bugün onun adıyla anılan distribution.¹⁰ Bu bölümdeki türetme ona aittir, iki yüzyıldan eskidir ve hâlâ çoğu dersin dışarıda bıraktığı kısım budur.

Yine de vadiye geri bak. $\theta = 0.20$ noktasında, loss 0,0822 iken "aşağı iniş" yönü gizem değildir — sayfada görebilirsin, eğri sağa doğru aşağı eğilir. Loss function’a, başka hiçbir yerde değerlendirmeden, üzerinde durduğun noktada hangi yöne eğimli olduğunu sorabilseydin, o yöne bir adım atabilir, tekrar sorabilir ve zemin düzleşene kadar tekrarlayabilirdin.

Bu sorunun bir adı var. Bir fonksiyonun bir noktadaki eğimi türevidir; çok parametreli bir fonksiyon için her yöndeki eğimlerin bir aradaki koleksiyonu gradient’tir. Bölüm 1 bunu kullanamazdı, çünkü perceptron’un hatası sorulacak eğimi olmayan bir merdivendi. Bu bölüm daha iyi bir şey inşa etti: her yerde smooth olan ve bir tercihten değil, belirtilmiş bir varsayımdan gelen bir loss.

Bu yüzden Bölüm 3 için soru artık bir eğimin var olup olmadığı değildir. Onu nasıl hesaplayacağımız, ona karşı hareket etmenin neden yukarı değil aşağı götürdüğü — neredeyse her dersin inançla kabul etmeni istediği bir işaret — ve tekrar sormadan önce ne kadar adım atacağımızdır; bu sonuncusu bir training run’ın converge etmesini, cevap etrafında sonsuza dek salınmasını ya da sonsuza kaçmasını belirleyen tek sayı çıkar.

Bu bölümle birlikte okumaya değer diğer kaynaklar: Prince, Understanding Deep Learning §5.1–5.2 ve Ek C; kitaptaki her loss’u burada kullanılan sırayla maximum likelihood’tan kurar. Goodfellow, Bengio ve Courville, Deep Learning §3.1–3.11 ve §5.5; maximum-likelihood bölümü Bölüm 4’ün ihtiyaç duyduğu KL divergence’ı da türetir. Murphy, Probabilistic Machine Learning: An Introduction bölüm 2 ve §4.2; maximum likelihood’ın neyi garanti edip etmediği üzerine. Deisenroth, Faisal ve Ong, Mathematics for Machine Learning §6.1–6.4; sum rule, product rule ve Bayes’ rule’un düzgün anlatımı için. Tom Mitchell’ın kısa CMU notu Estimating Probabilities: MLE and MAP (2016); ve aynı sonuca çalıştırılabilir kodla ulaşan Dive into Deep Learning §22.7.