Bölüm 2 · Öğrenmenin motoru · Ders 10

Zincir kuralı: geri yayılım ile gradyan inişi buluşuyor

İki ağırlıklı bir ağ, bütün kayıp arazisi ve halka halka türev

Veri. Bir robot kolunun eklem servosuna 20 farklı komut (−3 ile 3 arası) verdik ve eklemin açısını ölçtük (radyan). Açı önce hızla artar, sonra mekanik sınıra yaklaşınca doyar: bir S eğrisi. 1 girdi → 1 gizli nöron → 1 çıktılık ağın tam iki ağırlığı var (w1 eğriyi diker, w2 yüksekliğini belirler); bu yüzden bütün kayıp arazisini çizebiliyoruz. Veriyi üreten gerçek değerler 2 ve 3.

20 ölçüm: servo komutu → eklem açısıaçı doyuyor: S eğrisi

1 / 109

Öğrenme oranı 0.5

zincir_kurali.pypython

import numpy as np
sig = lambda z: 1 / (1 + np.exp(-z))
rng = np.random.default_rng(19)
u = np.sort(rng.uniform(-3, 3, 20)) # servo komutu
y = 3 * sig(2 * u) + rng.normal(0, 0.2, 20) # eklem açısı (rad)
w1, w2, lr = 0.2, 1.0, 0.5 # iki ağırlık
def loss(w1, w2):
return np.mean((w2 * sig(w1 * u) - y) ** 2)
print(f"başta kayıp {loss(w1, w2):.2f}")
for step in range(100):
z = w1 * u # halka 1
h = sig(z) # halka 2: gizli nöron
pred = w2 * h # halka 3: çıktı
d_pred = 2 * (pred - y) / len(u) # ∂L/∂ŷ, bir kez
g2 = np.sum(d_pred * h) # ∂ŷ/∂w2 = h
d_z = d_pred * w2 * h * (1 - h) # · ∂ŷ/∂h · ∂h/∂z
g1 = np.sum(d_z * u) # · ∂z/∂w1 = u
if step == 0: # kontrol: w1’i dürt
num = (loss(w1 + 1e-6, w2) - loss(w1, w2)) / 1e-6
print(f"g1 {g1:.7f} dürtme {num:.7f}")
w1, w2 = w1 - lr * g1, w2 - lr * g2 # optimizer.step()
print(f"kayıp {loss(w1, w2):.3f} w {w1:.2f} {w2:.2f}")

Sahnedeki her sayı, aynı algoritmanın tarayıcında yapılan gerçek çalıştırmasından gelir (sabit tohum, her seferinde aynı sonuç). Python kodunu kendi bilgisayarında çalıştırırsan rastgele başlangıçlar farklı olacağı için sayılar biraz değişebilir.

Veri seti

Tüm veri setleri →

Bu dersin kodu verisini kendi içinde üretir; indirilecek dosya yok. Kodu yine de aşağıda tarayıcında çalıştırabilirsin.

Kodu tarayıcıda çalıştırPython · NumPy · matplotlib · Pyodide

Python ve NumPy bu sayfada, tarayıcında çalışır (Pyodide). Kodu değiştirip yeniden çalıştırabilirsin; dersin veri setleri çalışma klasöründe hazır. Kod matplotlib kullanırsa grafikler çıktının altında görünür, yazdığı dosyalar (ör. egitim_gecmisi.csv) indirilebilir.

zincir_kurali.pypython

import numpy as np
sig = lambda z: 1 / (1 + np.exp(-z))
rng = np.random.default_rng(19)
u = np.sort(rng.uniform(-3, 3, 20))           # servo komutu
y = 3 * sig(2 * u) + rng.normal(0, 0.2, 20)   # eklem açısı (rad)
w1, w2, lr = 0.2, 1.0, 0.5                    # iki ağırlık
def loss(w1, w2):
    return np.mean((w2 * sig(w1 * u) - y) ** 2)
print(f"başta kayıp {loss(w1, w2):.2f}")
for step in range(100):
    z = w1 * u                                # halka 1
    h = sig(z)                                # halka 2: gizli nöron
    pred = w2 * h                             # halka 3: çıktı
    d_pred = 2 * (pred - y) / len(u)          # ∂L/∂ŷ, bir kez
    g2 = np.sum(d_pred * h)                   # ∂ŷ/∂w2 = h
    d_z = d_pred * w2 * h * (1 - h)           # · ∂ŷ/∂h · ∂h/∂z
    g1 = np.sum(d_z * u)                      # · ∂z/∂w1 = u
    if step == 0:                             # kontrol: w1’i dürt
        num = (loss(w1 + 1e-6, w2) - loss(w1, w2)) / 1e-6
        print(f"g1 {g1:.7f}  dürtme {num:.7f}")
    w1, w2 = w1 - lr * g1, w2 - lr * g2       # optimizer.step()
print(f"kayıp {loss(w1, w2):.3f}  w {w1:.2f} {w2:.2f}")

Kendi CSV’ni yükle

Çıktı

Çıktı burada görünecek.

Nasıl çalışır

Türev bir eğimdir: ağırlık çok az oynayınca kaybın ne kadar değiştiği. Diğer ağırlık sabitken alınan türev kısmi türevdir; ikisinin listesi gradyandır.
Zincir kuralı: kayıp, w1’e dört halkalık bir zincirle bağlı (w1 → z → h → ŷ → kayıp). Her halkanın eğimi çarpılır: ∂L/∂w1 = ∂L/∂ŷ · ∂ŷ/∂h · ∂h/∂z · ∂z/∂w1.
Geri yayılım bu çarpımı kayıptan geriye doğru yapar ve çıkıştaki eğimi (∂L/∂ŷ) iki ağırlık için de yeniden kullanır. Gradyan inişi o gradyanla adım atar: yeni ağırlık = ağırlık − öğrenme oranı × eğim.
PyTorch'ta aynı ayrım görünür: loss.backward() geri yayılımı çalıştırır, optimizer.step() gradyan adımını atar.
Şunu dene: öğrenme oranını 0,1 yap; 10. adımda kayıp hâlâ 0,6 civarındadır ve 100 adımda w1 ancak 1,6’ya gelir. 1,5 yap: ilk adımlarda vadiye büyük sıçramalarla iner.

Neden önemli

Derin öğrenme kütüphanelerinin hepsi bu iki parçanın üstüne kurulu: türevleri zincir kuralıyla otomatik hesaplayan bir motor (autograd) ve o türevlerle adım atan bir optimizasyoncu. Robotikte eklem ve motor modellerinin doyum eğrileri, sensör tepkileri ve öğrenen kontrolcüler aynı yolla ayarlanır.

ESOF 323, 11. hafta: robotlarda derin öğrenme →