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

Geri yayılım: altı ağırlıktan hangisi suçlu?

Suç çıkıştan başlar, katman katman geriye akar

Veri. Bir robot tutucusunun iki sensörü var: parmak basıncı ve kayma titreşimi. Bu okumalar (ölçekli: 1,0 ve 0,5) küçük bir ağa girer: 2 girdi → 2 gizli nöron → 1 çıktı, toplam altı ağırlık. Nesne sağlam tutulduğu için doğru cevap 1,0; ağ ise 0,701 diyor. Altı ağırlık bu cevabı birlikte üretti: hangisi ne kadar suçlu?

2 sensör → 2 gizli nöron → 1 çıktıaltı ağırlık

1 / 76

Öğrenme oranı 3

geri_yayilim.pypython

import numpy as np
sig = lambda z: 1 / (1 + np.exp(-z))
x = np.array([1.0, 0.5]) # basınç, kayma (ölçekli)
target, lr = 1.0, 3.0 # sağlam kavrama = 1
W1 = np.array([[0.6, 0.6], [-0.5, 0.4]]) # girdi → gizli
W2 = np.array([1.1, 0.3]) # gizli → çıkış
def forward(W1, W2):
h = sig(x @ W1) # gizli katman
return h, sig(h @ W2) # çıktı
L = lambda W1, W2: (forward(W1, W2)[1] - target) ** 2
history = {'step': [], 'loss': [], 'output': [], 'grad_norm_W1': [], 'grad_norm_W2': []} # eğitim geçmişi
for step in range(61):
h, out = forward(W1, W2) # ileri geçiş
loss = (out - target) ** 2 # kayıp
d_out = 2 * (out - target) * out * (1 - out) # çıkışın suçu
gW2 = d_out * h # suç × taşıdığı değer
d_h = d_out * W2 * h * (1 - h) # suç bir katman geri
gW1 = np.outer(x, d_h) # suç × girdi
for k, v in zip(history, (step, loss, out, np.linalg.norm(gW1), np.linalg.norm(gW2))): history[k].append(float(v)) # katman başına gradyan normu
if step == 0: # kontrol: oynat ve ölç
E = np.zeros((2, 2)); E[0, 0] = 1e-6
num = (L(W1 + E, W2) - L(W1 - E, W2)) / 2e-6
print(f"{gW1[0, 0]:.9f} = {num:.9f} ?")
W1 -= lr * gW1; W2 -= lr * gW2 # güncelleme
if step in (0, 1, 60):
print(step, f"{out:.3f}", f"{loss:.4f}") # adım, çıktı, kayıp
for k in ('loss', 'output', 'grad_norm_W1', 'grad_norm_W2'): # son ölçümler tablosu
print(f'{k:<14}{history[k][-1]:>12.6f}')
import csv
with open('egitim_gecmisi.csv', 'w', newline='') as f: # geçmişi CSV'ye yaz
csv.writer(f).writerows([list(history), *zip(*history.values())]) # satır başına bir adım
try:
import matplotlib.pyplot as plt # varsa grafik çiz
fig, ax = plt.subplots(1, 2, figsize=(9, 3.2))
ax[0].plot(history['step'], history['loss']); ax[0].set_yscale('log'); ax[0].set_title('loss')
for k in ('grad_norm_W1', 'grad_norm_W2'): ax[1].plot(history['step'], history[k], label=k)
ax[1].legend(); plt.show()
except ImportError:
print('matplotlib yok: grafik atlandı')

Eğitim paneli

Eğitim çalıştırılıyor…

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.

geri_yayilim.pypython

import numpy as np
sig = lambda z: 1 / (1 + np.exp(-z))
x = np.array([1.0, 0.5])                      # basınç, kayma (ölçekli)
target, lr = 1.0, 3.0                         # sağlam kavrama = 1
W1 = np.array([[0.6, 0.6], [-0.5, 0.4]])      # girdi → gizli
W2 = np.array([1.1, 0.3])                     # gizli → çıkış
def forward(W1, W2):
    h = sig(x @ W1)                           # gizli katman
    return h, sig(h @ W2)                     # çıktı
L = lambda W1, W2: (forward(W1, W2)[1] - target) ** 2
history = {'step': [], 'loss': [], 'output': [], 'grad_norm_W1': [], 'grad_norm_W2': []}  # eğitim geçmişi
for step in range(61):
    h, out = forward(W1, W2)                  # ileri geçiş
    loss = (out - target) ** 2                # kayıp
    d_out = 2 * (out - target) * out * (1 - out)  # çıkışın suçu
    gW2 = d_out * h                           # suç × taşıdığı değer
    d_h = d_out * W2 * h * (1 - h)            # suç bir katman geri
    gW1 = np.outer(x, d_h)                    # suç × girdi
    for k, v in zip(history, (step, loss, out, np.linalg.norm(gW1), np.linalg.norm(gW2))): history[k].append(float(v))  # katman başına gradyan normu
    if step == 0:                             # kontrol: oynat ve ölç
        E = np.zeros((2, 2)); E[0, 0] = 1e-6
        num = (L(W1 + E, W2) - L(W1 - E, W2)) / 2e-6
        print(f"{gW1[0, 0]:.9f} = {num:.9f} ?")
    W1 -= lr * gW1; W2 -= lr * gW2            # güncelleme
    if step in (0, 1, 60):
        print(step, f"{out:.3f}", f"{loss:.4f}")  # adım, çıktı, kayıp
for k in ('loss', 'output', 'grad_norm_W1', 'grad_norm_W2'):  # son ölçümler tablosu
    print(f'{k:<14}{history[k][-1]:>12.6f}')
import csv
with open('egitim_gecmisi.csv', 'w', newline='') as f:  # geçmişi CSV'ye yaz
    csv.writer(f).writerows([list(history), *zip(*history.values())])  # satır başına bir adım
try:
    import matplotlib.pyplot as plt           # varsa grafik çiz
    fig, ax = plt.subplots(1, 2, figsize=(9, 3.2))
    ax[0].plot(history['step'], history['loss']); ax[0].set_yscale('log'); ax[0].set_title('loss')
    for k in ('grad_norm_W1', 'grad_norm_W2'): ax[1].plot(history['step'], history[k], label=k)
    ax[1].legend(); plt.show()
except ImportError:
    print('matplotlib yok: grafik atlandı')

Kendi CSV’ni yükle

Çıktı

Çıktı burada görünecek.

Nasıl çalışır

İleri geçiş: girdiler gizli katmandan geçer, tek bir sayı çıkar. Kayıp = (çıktı − hedef)²: 0,09.
Bir ağırlığın gradyanı: onu çok az oynatınca kaybın ne kadar değiştiği. Her ağırlığı tek tek oynatmak yerine kısayol kullanılır.
Kısayol: bir nöronun suçu bir kez hesaplanır. Ona giren her ağırlığın gradyanı = o suç × ağırlığın taşıdığı değer. Suç çıkıştan başlar ve katman katman geriye aktarılır.
Güncelleme: her ağırlık kendi gradyanının tersine kayar. Altı gradyan da negatif, altı ağırlık da artar; çıktı 1 adımda 0,769, 60 adımda 0,968 olur.
Şunu dene: öğrenme oranını 0,5 yap, 60 adımda çıktı ancak 0,907 olur; 6 yap, 0,978’e çıkar.

Neden önemli

Geri yayılım, milyonlarca ağırlıklı bir ağı eğitmeyi mümkün kılan hesaptır: tek bir ileri ve tek bir geri geçişle bütün gradyanlar çıkar. Görüntüden nesne tanıyan, robot kolunu yöneten ya da dil üreten her ağ böyle eğitilir. PyTorch'taki loss.backward() tam olarak bu işi yapar.

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