Yokuş Aşağı: Gradient Descent ve Herkesin Atladığı İki Adım

Bu bölüm kendi başına anlaşılabilsin diye yeniden ifade edelim: Bölüm 1’deki taşıma bandından gelen sekiz parça, ama bu kez farklı bir soru soruyoruz. Kabul mü ret mi değil — o sonra geri gelecek — bir parçanın ağırlığını genişliğinden tahmin et.

import numpy as np

WIDTH  = np.array([18.0, 19.5, 20.2, 21.0, 24.0, 25.5, 23.0, 26.0])
WEIGHT = np.array([47.0, 52.0, 49.0, 55.0, 61.0, 66.0, 70.0, 58.0])

x = WIDTH  - WIDTH.mean()      # 22.15 mm
y = WEIGHT - WEIGHT.mean()     # 57.25 g

Ölçümler, Bölüm 1’deki gibi ve bu bölüm bitmeden faiziyle geri dönecek bir nedenle merkezlenmiş durumda. Model bir doğru, $\hat{y} = a x + b$, loss ise önceki bölümün türettiği ortalama karesel hata:

İki parametre. Neden sadece birçok değer denemiyoruz? Gerçekten yapalım — $a = 0$’den $5$’e ve $b = -5$’den $5$’e, $0.01$ adımlı bir grid:

grid 501 x 1001 = 501,501 evaluations in 3.67 s
  best found: a = 2.1000, b = -0.0000, L = 24.592450

İki sayıyı iki ondalık basamağa sabitlemek için yarım milyon değerlendirme — ve bu saniye tek bir makinedeki duvar saatidir; yeniden çalıştırınca üç ile altı arasında herhangi bir yere düşer. Tekrarlanabilen kısım değerlendirme sayısı ve minimumdur. Bu bölümün sonunda gradient descent, sekiz adımda dört ondalık basamağa ve otuz altı adımda tam float64 cevaba ulaşacak.

Ama argüman hız değil; tüm kursun yönünü belirleyen nokta bu. Grid search, $P$ parametre ve her biri için $k$ değer olduğunda $k^P$ değerlendirmeye mal olur. Eksen başına bin değerle:

Üçüncü satır büyük bir sayı değil, anlamsız bir sayı — gözlemlenebilir evrende kabaca $10^{80}$ atom var. Modeller büyüdükçe arama yavaşlamaz; var olmaktan çıkar. Bundan sonra gelen her şey o tablo yüzünden var.

Bir an için $b = 0$’ü sabitleyelim; böylece tek parametre ve tek eğri olur, yani son bölümün seni bıraktığı resim. Üzerinde bir nokta al, $a = 1$, ve sor: $a$’ü küçük bir $h$ kadar dürtersem loss, dürtme birimi başına ne kadar hareket eder?

Bu oran bir yükselme/basma oranıdır — eğri üzerindeki iki noktadan geçen doğrunun eğimi. $h$ küçüldükçe iki nokta birbirine kayar ve doğru teğete dönüşür. Onun eğimi türev $L'(a)$’dir: loss’un $a$’deki birim değişim başına değişme hızı. Hiçbir şeyin yaklaşık değeri değil, sonsuz küçük bir nicelik de değil. Sıradan oranların limiti.

Çalıştırmaya değer, çünkü sayılar tanımın söylemediği bir şey söyler:

def loss1(a):
    return np.mean((a * x - y) ** 2)

for h in [1.0, 1e-2, 1e-4, 1e-6, 1e-8, 1e-10, 1e-12, 1e-14]:
    q = (loss1(1.0 + h) - loss1(1.0)) / h
    print(f"h = {h:<8.0e}   slope estimate = {q:.10f}   error = {abs(q + 16.385):.3e}")

h = 1e+00      slope estimate = -8.9400000000    error = 7.445e+00
h = 1e-02      slope estimate = -16.3105500000   error = 7.445e-02
h = 1e-04      slope estimate = -16.3842555001   error = 7.445e-04
h = 1e-06      slope estimate = -16.3849925556   error = 7.444e-06
h = 1e-08      slope estimate = -16.3850003787   error = 3.787e-07
h = 1e-10      slope estimate = -16.3850444324   error = 4.443e-05
h = 1e-12      slope estimate = -16.3851154866   error = 1.155e-04
h = 1e-14      slope estimate = -17.0530256582   error = 6.680e-01

Burada iki şey oluyor ve ikisi de taşıyıcı kolon.

Hata, belirsiz biçimde $h$ ile orantılı değil — tam olarak $7.445\,h$. $h$’ü yüze böl, hata da yüze bölünür; her seferinde dört anlamlı basamağa kadar. O sabit süs değildir: loss’un ikinci türevinin yarısıdır ve iki bölüm sonra gelecek bir fikrin ilk görünümüdür — bir noktanın yakınında bir eğrinin, bir doğru artı $h^2$ ile orantılı bir düzeltme gibi görünmesi.

Sonra desen bozulur. $h = 10^{-8}$’in altında tahmin kötüleşir ve $10^{-14}$’de ikinci basamakta yanlıştır. Matematiksel hiçbir şey olmadı; önceki bölümün kayan nokta kutusu devreye girdi. $L(a+h)$ ve $L(a)$ ilk on basamaklarında aynıdır; onları çıkarmak bu basamakları yok eder ve enkazı minicik bir sayıya bölmek geriye kalanı büyütür. En iyi bir $h$ vardır — burada $10^{-8}$ civarında, yaklaşık makine epsilonunun karekökü — ve daha küçüğe gitmek daha dikkatli olmak değil, daha az dikkatli olmaktır. Bunu hatırla; bu bölümün sonundaki bir fonksiyon buna bağlı.

Ölçüm yerine kalkülüsle bulunan kesin eğim $-16.385$’dir. Yani ölçmeyi bırakıp türetmeye başlayabiliriz.

Kursun geri kalanının üzerine kurulduğu fikir şu; bir kez, yalın biçimde söyleyelim.

İki fonksiyonu bileştirmek, birini diğerine beslemektir: $(f \circ g)(x) = f(g(x))$. Daha fazlası değil.

Derin bir ağ bileşime benzemez. Tam olarak bileşimdir. Bir katman bir fonksiyondur; katmanları üst üste koymak onları bileştirmektir; “derinlik”, zincirdeki fonksiyon sayısıdır. Bölüm 5 bir ağ kurduğunda $f_4 \circ f_3 \circ f_2 \circ f_1$ kuruyor olacak, başka hiçbir şey değil. Bu da bizim amaçlarımız için kalkülüsün en önemli kuralının, bir bileşimin türevini alan kural olduğu anlamına gelir:

Hızlar çarpılır. $g$, $x$’ten üç kat hızlı değişiyorsa ve $f$, $g$’den iki kat hızlı değişiyorsa, $f$, $x$’den altı kat hızlı değişir. Bütün içerik budur; on katmandan geri geçen bir sinyalin on sayıyla çarpılmasının nedeni de budur — bu yüzden Bölüm 6, bu sayıların hepsi birden biraz birden küçük olduğunda ne olduğuna bir bölüm ayırır.

Bunu loss’umuza uygula. Kalıntıyı $r_i = a x_i + b - y_i$ olarak yaz; böylece $L = \frac{1}{n}\sum r_i^2$. Her $r_i$, $a$’ye, türevi $x_i$ olan iç fonksiyon $a x_i$ üzerinden bağlıdır. Zincir kuralı, terim terim:

Bu kıvrımlı $\partial$ sembolleri bir kısmi türevi işaretler: bir değişkene göre türev al ve diğer her şeyi sabit kabul et. Yeni bir şey olmuyor — öncekiyle aynı limit, sadece bir eksen boyunca alınıyor. Kısmi türevleri bir vektörde topla ve gradient elde edersin:

$(a, b) = (1, 4)$ noktasında bu vektör $(-16.385,\ 8.0)$’dir. İki sayı. Soru, ne anlama geldikleri; herkesin atladığı ilk adım da bu.

Gradient, eksenler boyunca eğimlerden oluşan bir vektördür. Kanıtladığımız tek şey bu. Bunları bir vektörde bir araya getirmenin belirli bir yöne işaret eden bir şey üretmesi bariz değildir — bariz olmamalıdır.

O yüzden gerçekten istediğimiz şeyi tanımlayalım. Bir birim vektör $\mathbf{u}$ seç, yani bir yön. Yönlü türev, o yönde yürürken loss’un değişme hızıdır:

Zincir kuralı bunu hesaplanabilir bir şeye dönüştürür. $\mathbf{u}$ boyunca yürümek $a$’i $u_1$ hızıyla ve $b$’yi $u_2$ hızıyla değiştirir; katkılar toplanır:

Herhangi bir yöndeki değişim hızı, gradient ile o yönün dot product’ıdır. Ve şimdi vurucu nokta, tek satırlık geometri. Dot product’ı vektörler arasındaki $\phi$ açısıyla yazarsak,

çünkü $\mathbf{u}$’in uzunluğu 1’dir. Kontrol ettiğin tek şey $\cos\phi$’dir; bu $\phi = 0$’de en büyük, yarım turda, yani $\phi = 180$ derecede en küçüktür. Dolayısıyla:

• En dik çıkış $\nabla L$’in kendisi boyuncadır ve oradaki eğim tam olarak $\lVert \nabla L \rVert$’dır.
• En dik iniş $-\nabla L$ boyuncadır ve oradaki eğim $-\lVert \nabla L \rVert$’dir.
• Gradient’a dik yönde loss hiç değişmez. Kontur haritasındaki çizgilerin gradient’ı dik açılarla kesmesinin nedeni budur.

Eksi işareti budur. Bir konvansiyon değil, birinin seçtiği işaret çevirmesi değil: en hızlı azalış yönü negatif gradient’tır, çünkü $\cos\phi$ yarım turda minimize edilir; başka hiçbir nedenle değil.

Bu tüm yönlerle ilgili bir iddia olduğuna göre, tüm yönlere karşı test et. 3.600 tanesini örnekle, derecenin onda biri başına bir tane, ve her birini dürterek ölç:

theta = np.array([1.0, 4.0])
g = grad(theta)
print("gradient      ", g)
print("its length    ", np.linalg.norm(g))
print("its angle     ", np.degrees(np.arctan2(g[1], g[0])) % 360, "degrees")

best = max(
    ((loss(theta + 1e-6 * u) - loss(theta - 1e-6 * u)) / 2e-6, np.degrees(ang))
    for ang, u in (
        (a, np.array([np.cos(a), np.sin(a)])) for a in np.arange(3600) * 2 * np.pi / 3600
    )
)
print("steepest slope", best[0], "at", best[1], "degrees")

gradient       [-16.385   8.   ]
its length     18.23371122399386
its angle      153.97598928042032 degrees
steepest slope 18.233709624837502 at 154.0 degrees

Gradient hakkında hiçbir şey bilmeyen, 3.600 yön üzerinde çalışan bir arama, en dik tırmanışını 154,0 derecede buluyor — aramanın 0,1 derecelik çözünürlüğü içinde gradient’ın kendi yönü. Orada bulduğu eğim, 18,2337, gradient’ın uzunluğu ile altı basamakta aynı. Teorem, gradient’ların ne anlama geldiğine dair bir hikâye değil; ölçülebilir bir gerçek ve ölçüm de bu.

Şimdi atlanan ikinci adım. Hangi yönün aşağı olduğunu biliyoruz. Ama buradan, o yönde yürümenin loss’u düşüreceği sonucu çıkmaz; çünkü “aşağı”, sonsuz küçük bir dürtme hakkında bir ifadedir, bir adım ise sonsuz küçük değildir.

Köprü doğrusallaştırmadır. Bir noktanın yakınında, düzgün bir fonksiyon teğeti artı bir düzeltmedir:

Bu birinci dereceden Taylor açılımıdır. Atılan $O(\lVert\boldsymbol{\delta}\rVert^2)$ eğriliktir — eğim tablosunun tahminini tam olarak $7.445\,h$ kadar yanlış yapan aynı terim. Atmayı düşündüğümüz adımı yerine koy, $\boldsymbol{\delta} = -\eta \nabla L$:

Loss $\eta \lVert \nabla L \rVert^2$ kadar düşer. Bunun her parçası negatif değildir, yani vaat gerçektir — yeterince küçük bir $\eta$ için, çünkü ihmal edilen terim $\eta^2$ gibi büyür ve sonunda onu yer. Bütün teori bu. İşte vaadin tutulması ve sonra bozulması:

eta = 0.2       promised    66.49364500   delivered   -16.01619240   ratio -0.240868
eta = 0.1       promised    33.24682250   delivered    12.61936315   ratio  0.379566
eta = 0.01      promised     3.32468225   delivered     3.11840766   ratio  0.937957
eta = 0.001     promised     0.33246822   delivered     0.33040548   ratio  0.993796
eta = 0.0001    promised     0.03324682   delivered     0.03322620   ratio  0.999380
eta = 1e-05     promised     0.00332468   delivered     0.00332448   ratio  0.999938

Aşağıdan oku. $\eta$ küçüldükçe gerçekleşen düşüş vaat edilene yakınsar — oran 0,99938, sonra 0,99994 — bu Taylor teoreminin doğru çıkmasıdır. Yukarıdan oku ve $\eta = 0.2$’de gerçekleşen “düşüş” eksi on altıdır. Adım yokuş aşağı gitti ve loss yükseldi.

Yani güncelleme kuralı

ve kimsenin söylemediği bir koşulla gelir: $\eta$ yeterince küçük olmalıdır. Tam olarak neye göre yeterince küçük olduğu, sonraki bölümün konusu.

En basit vadiyle başla, $f(x) = x^2$; burada $f'(x) = 2x$. Gradient descent’in bir adımı şudur:

Konum her adımda $(1 - 2\eta)$ ile çarpılır. Bu geometrik bir dizidir ve geometrik dizilerin tam olarak bir kuralı vardır: çarpan mutlak değerce 1’den küçükse küçülürler, değilse büyürler. Yani $\lvert 1 - 2\eta \rvert < 1$, yani $0 < \eta < 1$.

Sınır tam olarak $\eta = 1$’dedir. “1 civarında” değil, “1 genellikle çok büyüktür” değil. $\eta = 1$’de çarpan $-1$’dir ve nokta sonsuza kadar $x$ ile $-x$ arasında seker; ne yaklaşır ne kaçar. Altında yakınsar; üstünde dağılır. Aralık $\eta = 0.5$’de yeniden ikiye ayrılır; orada çarpan işaret değiştirir: bunun altında yaklaşma monotoniktir, üstünde nokta taşar ve taraf değiştirerek ilerler; tam olarak $0.5$’te çarpan 0’dır ve tek bir adım minimuma iner.

Dört satır cebirden dört rejim. Git ve sınırları kendin aş:

Ve şimdi ilginç olan:

Şimdi aynı argümandan çıkan genel kural. $1 - 2\eta$ çarpanı aslında $1 - \eta f''$ idi ve bir minimumun yakınında çok parametreli bir loss, her yön için böyle bir sayıya sahiptir — ikinci türevler matrisinin özdeğerleri. Her yönün aynı anda kararlı olması gerekir, bu yüzden tavan en büyüğü tarafından belirlenir:

$f(x) = x^2$ için $f'' = 2$, tavan 1’dir; az önce türettiğimiz de buydu. Bizim bant verimizde ikinci türev matrisi, $A$ girdilerin iki sütunlu matrisi olmak üzere $\frac{2}{n} A^{\top} A$’dir ve özdeğerleri 2 ile 14,89’dur; dolayısıyla tavan $2 / 14.89 = 0.13432$’tir. Bu, içinde beş anlamlı basamak olan bir tahmindir. Test et:

lr=0.1343    -> L =      24.5924
lr=0.13431   -> L =      24.5924
lr=0.13432   -> L =       4707.8       BLEW UP
lr=0.13433   -> L =  4.00452e+16       BLEW UP
lr=0.1344    -> L = 1.18229e+107       BLEW UP

Bir satır lineer cebir ile for döngüsünün yüz bin iterasyonu arasında beş ondalık basamaklık uyum.

Ve işte Bölüm 1’in geri geldiği yer. Yukarıdaki her şey merkezlenmiş ölçümleri kullandı. Aynı kodu ham milimetreler ve gramlar üzerinde çalıştır ve özdeğerler 2 ve 14,89 yerine 0,0298 ve 998,1 olur. Tavan 0,134’ten 0,002004’e çöker — yine aynı kesinlikle; lr=0.002003’de yakınsar, lr=0.002004’da patlar.

Tavandan daha kötüsü, özdeğerler arasındaki orandır. Koşul sayısı, vadinin yuvarlaktan ne kadar uzak olduğunu ölçer: uzun ince bir hendek, dik duvarlar için yeterince küçük bir oranı zorunlu kılar; sonra hendeğin tabanı da aynı sürünme hızıyla yürünür. Bizimki merkezlenmişte 7,44 iken hamda 33.452 olur. Her sürümün alabileceği en iyi oranla:

Aynı veri, aynı kod, sonunda aynı cevap — ve sekiz bin kat iş; çünkü kimse ortalamayı çıkarmadı. Bölüm 1’de aynı ihmal perceptron’a epoch sayısında altı bin kat maliyet çıkarmıştı ve oradaki teşhis geometrikti: veri orijinden uzakta yüzüyordu. Burada optimizasyon kılığına girmiş aynı geometri var ve input normalizasyonunun hijyen tavsiyesi değil aritmetik olmasının nedeni bu.¹

Yukarıdakilerin hiçbiri bir library gerektirmedi. İşte tüm optimiser.

def loss(theta):
    a, b = theta
    return np.mean((a * x + b - y) ** 2)


def grad(theta):
    a, b = theta
    residual = a * x + b - y
    return np.array([np.mean(2 * residual * x), np.mean(2 * residual)])


def descend(theta, lr, steps):
    theta = np.array(theta, dtype=float)
    for _ in range(steps):
        theta = theta - lr * grad(theta)   
    return theta


theta = descend([0.0, 0.0], lr=0.05, steps=60)
print(theta, loss(theta))

[ 2.10040296e+00 -2.76445533e-15] 24.592448791134984

Bu sekiz nokta için closed-form en küçük kareler cevabı $a = 2.100403$, $b = 0$ ve loss $24.592449$’dur. Döngü, bir closed form’un var olduğunu bilmeden bunu sekiz anlamlı basamağa kadar buldu — bu önemli, çünkü Bölüm 5’ten itibaren böyle bir form olmayacak.

Yörünge; çünkü asıl mesele onu izlemek:

   0 a=0.000000 b=0.000000 L=57.437500
   1 a=1.563750 b=0.000000 L=26.736582
   2 a=1.963288 b=-0.000000 L=24.732418
   5 a=2.098116 b=-0.000000 L=24.592488
  10 a=2.100400 b=-0.000000 L=24.592449
  60 a=2.100403 b=-0.000000 L=24.592449

Mesafenin çoğu ilk iki adımda kat edilir; çünkü gradient dipten en uzakken en büyüktür ve yaklaştıkça küçülür. Gradient descent bir minimumun yakınında otomatik olarak yavaşlar. Bu bir özelliktir ve Bölüm 6’da aynı zamanda bir problemdir.

Şimdiye kadarki argümanda bir delik var. Adım $\nabla L = \mathbf{0}$ olduğunda durur ve biz buna “minimum” diyorduk. Gradient’ı sıfır olan nokta bir kritik noktadır ve minimum olmak, kritik nokta olmanın yollarından yalnızca biridir:

• bir yerel minimum: her yönde yokuş yukarı, ama her yerdeki bu tür noktaların en düşüğü olmak zorunda değil;
• bir yerel maksimum: her yönde yokuş aşağı;
• bir eyer noktası: bazı yönlerde yokuş yukarı, bazı yönlerde yokuş aşağı. $f(x,y) = x^2 - y^2$ yüzeyi $\nabla f = (2x, -2y)$’a sahiptir; bu ifade orijinde sıfırdır ve fonksiyon aynı anda $x$ ekseni boyunca minimum, $y$ ekseni boyunca maksimumdur.

Gradient descent bunları ayırt edemez; çünkü yalnızca gradient’a bakar ve gradient üçünde de sıfırdır.

Bizim doğrumuzun tek bir kritik noktası var ve o da cevap — lineer model üzerindeki karesel hata loss’u konvekstir, tek bir kâsedir ve üzerinde descent, global minimumu bulmada başarısız olamaz. Bu özellik kursla temas edince hayatta kalmaz. Bir neural network’ün loss’u konveks değildir ve Bölüm 5’ten itibaren “minimum” diye tekil bir şey yoktur: farklı derinliklerde birçok tane vardır ve hangisini alacağın nereden başladığına bağlıdır. Bu bir cümledir ve bir cümle olarak kalacak; çünkü teori büyüktür, pratik sonuç küçüktür.

Tüm sonucu tek bir eğride görebilirsin. Farklı derinliklerde iki vadisi olan $f(x) = \tfrac{x^4}{4} - \tfrac{x^2}{2} + \tfrac{x}{10}$’ü al:

   x =  -1.046681   f(x) =  -0.352386   minimum
   x =   0.101031   f(x) =   0.005026   maximum
   x =   0.945649   f(x) =  -0.152639   minimum

Sığ vadiye inmek loss açısından %56,7 daha kötüdür ve algoritmanın bunu bilmesinin yolu yoktur; çünkü bir vadinin içinden bakınca her yön yokuş yukarıdır. Gradient descent içinde bunun bir onarımı yoktur ve gelmeyecek. Pratikte olan şey, bunun bu resmin ima ettiğinden çok daha az önemli olduğunun bulunmasıdır — gerçek bir ağın çok yüksek boyutlarında kritik noktaların çoğu tuzak değil eyer noktası çıkar,² ve Bölüm 5 küçük bir ağın gerçekten ne sıklıkla takıldığını ölçecek.

Yukarıdaki grad hakkında seni rahatsız etmesi gereken bir şey var: her adım için tüm dataset’i topluyor. Sekiz parça hiçbir şey. Bir milyon, parametreleri bir kez hareket ettirmek için bir milyon gradient hesaplaması demektir.

Kaçış şu: gradient bir ortalamadır ve bir ortalama bir örneklemden tahmin edilebilir. Rastgele küçük bir avuç üzerinde hesapla — bir minibatch — ve onunla adım at. Tahmin gürültülüdür; aynı zamanda yanlı değildir ve yüzlerce ucuz gürültülü adım, pahalı tek bir kesin adımı yener. Yüz bin sentetik parçada, adımlar yerine örnek başına gradient’ları sayarsak:

Aynı yere ulaşmak için iki yüz on dokuz kat daha az aritmetik. Ve uç nokta — her seferinde bir örnek, Robbins ve Monro’nun özgün stochastic approximation’ı³ — kazanan değildir: 32’lik batch’lerden beş kat kötüdür; çünkü matris çarpan donanımda 32 örnek neredeyse 1 örnekten fazla maliyet getirmezken, gürültü batch size’ın kareköküyle düşer. Bu trade-off, okuyacağın her eğitim script’inde bir batch_size olmasının nedenidir.

Momentum diğer ucuz düzeltmedir ve doğrudan hendeği hedefler. Kötü koşullanmış bir vadide adımlar dar yönde zikzak çizerken uzun yönde sürünür. Momentum geçmiş gradient’ların kayan ortalamasını tutar; böylece salınan bileşenler birbirini götürür, tutarlı olan birikir:⁴

İki ekstra satır. Ham, merkezlenmemiş bantta — koşul sayısı 33.452, elimizdeki en kötü durum — düz descent’in alabileceği en iyi oranda:

momentum beta=0.0   ->    79,513 steps to 1%
momentum beta=0.9   ->     1,609 steps to 1%
momentum beta=0.99  ->       461 steps to 1%

İki satır kod için 172 kat. Bölüm 6 bunu Adam’a dönüştürür; mekanizma zaten burada.

Bu bölümdeki her gradient elle türetildi ve bu yüzden yanlış olabilir. Çözüm, baştaki eğim tablosudur: türevi sayısal olarak ölç ve karşılaştır. Aynı $h$ için çok daha doğru olan ve önde gelen hata terimini iptal eden central difference’ı kullan, $\frac{L(\theta+h) - L(\theta-h)}{2h}$.

def numeric_grad(f, theta, h=1e-5):
    theta = np.asarray(theta, dtype=float)
    out = np.zeros_like(theta)
    for i in range(theta.size):
        bump = np.zeros_like(theta)
        bump[i] = h
        out[i] = (f(theta + bump) - f(theta - bump)) / (2 * h)     
    return out


def gradcheck(f, df, theta, h=1e-5):
    analytic = np.asarray(df(theta), dtype=float)
    numeric = numeric_grad(f, theta, h)
    return np.max(np.abs(analytic - numeric) / np.maximum(1e-8, np.abs(analytic) + np.abs(numeric)))

Karşılaştırmanın göreli formu önemlidir: $10^{-4}$ mutlak fark, büyüklüğü $10^{-3}$ olan bir gradient üzerinde felakettir ve $10^{6}$ büyüklüğündekinde önemsizdir.

relative error: 1.8929136036763527e-11
with 2 dropped: 0.33333333331650744

İlk satır yukarıdaki elle türetilmiş gradient. İkincisi, bir bileşende 2 çarpanı unutulmuş aynı fonksiyon — tek karakterlik bir yazım hatası — ve kontrol bunu anında yakalar. Yaklaşık $10^{-7}$ altındaki her şey uyumdur; $10^{-4}$ üzerindeki her şey bug’dır. Bu fonksiyonu sakla: Bölüm 5 onu bir automatic differentiation engine’i debug etmek için kullanacak ve yanlış bir gradient’ın bulunabilir olmasının tek nedeni o.

Bu bölümdeki her şey, hiç açıkça söylenmemiş tek bir varsayıma dayanıyordu: $\partial L / \partial \theta$’ü yazabiliyor olman.

İki parametreli bir doğru için bu bir satır cebirdi. Neredeyse hemen bir satır olmaktan çıkar. Bir symbolic algebra system’den, bir ağın loss’unun tek bir birinci katman weight’ine göre, tek bir örnek için türevini iste ve cevaptaki aritmetiği say:

Üçüncü satır 57 parametreli bir ağ — Bölüm 6’da dipnot olacak kadar küçük bir ağ — ve gradient’ını elle yazmak tek bir eğitim örneği için yaklaşık 97.869 işlem demektir. Bunu kurtaran bir notasyon yok. Onu kurtaran şey, bir bileşime uygulanan zincir kuralının muazzam bir yapıya sahip olduğu, aynı ara niceliklerin tekrar tekrar ortaya çıktığı ve bunları doğru sırayla hesaplamanın tüm türevleri kabaca tek bir forward pass fiyatına verdiği gözlemidir. Bu Bölüm 5.

Ama önce daha küçük bir problem var ve hemen bekliyor.

Artık herhangi bir türevlenebilir loss üzerinde yokuş aşağı yuvarlanacak bir makinemiz var. Onu bandın asıl sorusuna yönelt — kabul mü ret mi, hedef 1 ya da 0 — çıktıya bir sigmoid koy ki olasılık tahmin etsin ve karesel hatayı minimize et. Çalışır. Ama en çok yanıldığında neredeyse hiç hareket etmez ve gradient bunun nedenini söyler:

Kendinden emin biçimde, feci şekilde yanlış olan bir model — cevap 1 iken 0.0000454 tahmin eden — $9 \times 10^{-5}$ karesel hata gradient’ı üretir. Başının dertte olduğuna dair hiçbir fikri yoktur. Henüz türetmediğimiz bir loss’tan gelen diğer sütun 1.0 bildirir: maksimum aciliyet, tam da hak edildiği yerde.

Bu da sonraki bölümün açtığı soruyu doğurur. Önceki bölüm bir loss’un gürültü hakkında bir varsayım olduğunu ve karesel hatanın Gaussian gürültü varsaydığını söyledi. Evet-hayır cevabının nasıl bir gürültü modeli vardır — ve aynı türetmeyi onun üzerinde yürütünce hangi loss çıkar?

Yöntem bunların hepsinden daha eski: Cauchy, 1847’de Académie des Sciences’a verdiği bir notta, denklem sistemlerini karesel kalıntılarının toplamı üzerinde yokuş aşağı yürüyerek çözmenin bir yolu olarak tarif etti. Bu bölümle birlikte okunmaya değer diğerleri: Sebastian Ruder’in An overview of gradient descent optimization algorithms çalışması (arXiv:1609.04747); momentum’dan Adam’a kadar konuyu okunabilir on dört sayfada kapsar. Nocedal ve Wright’ın Numerical Optimization kitabının 3. bölümü (2. baskı, Springer, 2006); teorem 3.3, bir kuadratik üzerinde steepest descent’in yakınsama hızını koşul sayısı cinsinden verir — koşullanmanın adım sayısını neden belirlediğinin teorisi budur, gerçi yukarıda ölçülen sabit adımlı $2/\lambda_{\max}$ tavanı yerine line search’i ele alır. Ya da aynı zemini daha az makineyle işleyen Deisenroth, Faisal ve Ong’un Mathematics for Machine Learning kitabının §5.8 ve §7.1 bölümleri; Prince’in Understanding Deep Learning kitabının §6.1’i ve Goodfellow, Bengio ve Courville’in Deep Learning kitabının §4.3’ü; burada yer olduğundan daha fazla ölçümle minibatch analizini veren Dive into Deep Learning §12.1–12.3; ve learning rate’i türetmekten çok ayarlanan bir şey olarak en pratik biçimde ele alan Géron’un Hands-On Machine Learning kitabının 4. bölümü (3. baskı). MIT 6.390 notları, gradient descent’i sınıflandırmadan önce koyar; bu kursun yaptığı gibi ve aynı nedenle.