PyTorch: autograd ve otomatik türev

İlk derste doğrusal regresyonun gradyanlarını elle çıkardık, hem de yalnızca iki parametre için. Modern sinir ağlarında milyonlarca, büyük dil modellerinde milyarlarca parametre vardır; her birinin türevini kâğıt üzerinde çıkarmak imkânsızdır. PyTorch'un autograd mekanizması bu işi otomatik yapar: tensörlerle yaptığın her işlemi kaydeder, sonra tek bir komutla tüm parametrelere göre kesin türevleri hesaplar. Bu ne yaklaşık sayısal farklardır ne de sembolik cebir; bu otomatik türevdir (automatic differentiation).

Hesaplama grafı

requires_grad=True olan bir tensörle yapılan her işlem, yönlü ve döngüsüz bir grafa (DAG) yeni bir düğüm ekler. Grafın yaprakları girdiler ve parametreler, kökü ise kayıptır. İleri geçişte (forward pass) graf kurulur ve değerler hesaplanır; geri geçişte (backward pass) autograd kökten yapraklara doğru ilerler ve her düğümde zincir kuralını uygular. Sinir ağlarında bu sürece geri yayılım (backpropagation) denir.

PyTorch'ta graf dinamiktir (define-by-run): her ileri geçişte yeniden kurulur. Bu yüzden bir modelin içinde sıradan Python if ve for ifadelerini özgürce kullanabilirsin; graf, o anda gerçekten çalışan yola uyar.

requires_grad, backward() ve .grad

import torch

x = torch.tensor(3.0, requires_grad=True)
y = x ** 2 + 2 * x + 1
print(y)
y.backward()
print(x.grad)

tensor(16., grad_fn=<AddBackward0>)
tensor(8.)

• requires_grad=True, PyTorch'a “bu tensöre göre türev gerekecek, işlemleri kaydet” der. Parametreler (nn.Linear ağırlıkları vb.) bunu otomatik yapar.
• grad_fn, tensörü hangi işlemin oluşturduğunu gösterir; bu onun graftaki düğümüdür.
• y.backward(), dy/dx'i hesaplar ve sonucu yaprağın .grad özniteliğine yazar: y = x² + 2x + 1 için x = 3'te dy/dx = 2x + 2 = 8.

Parametre bir vektör olduğunda .grad da aynı şekilde bir vektördür: her eleman için bir kısmi türev. Örneğin f = ∑ vᵢ² için ∂f/∂vᵢ = 2vᵢ olur:

import torch

v = torch.tensor([1.0, -2.0, 3.0], requires_grad=True)
f = (v ** 2).sum()
f.backward()
print(v.grad)

tensor([ 2., -4.,  6.])

requires_grad bayrağı sonradan da değiştirilebilir: p.requires_grad_(False) bir parametreyi “dondurur”; gradyanı hesaplanmaz ve eğitim sırasında değişmez. Bu, transfer öğrenmede kullanılır: önceden eğitilmiş bir ağın katmanlarının çoğu dondurulur, yalnızca son katman yeni göreve uyarlanır. Bunu evrişimli ağlar dersinde göreceksin.

Zincir kuralı

import torch

w = torch.tensor(2.0, requires_grad=True)
b = torch.tensor(1.0, requires_grad=True)
x, y = torch.tensor(3.0), torch.tensor(10.0)
y_hat = w * x + b
loss = (y_hat - y) ** 2
print(type(loss.grad_fn).__name__, type(y_hat.grad_fn).__name__)
loss.backward()
print(loss.item(), w.grad.item(), b.grad.item())

PowBackward0 AddBackward0
9.0 -18.0 -6.0

import torch

w = torch.tensor(0.0, requires_grad=True)
x = torch.tensor(2.0)
y = torch.sigmoid(w * x)
y.backward()
print(y.item(), w.grad.item())

0.5 0.5

Geri geçişin gücü verimliliğindedir: tek bir backward() çağrısı kaybın tüm parametrelere göre gradyanını hesaplar ve maliyeti ileri geçişle aynı mertebededir (küçük bir sabit çarpan kadar). Her parametreyi ayrı ayrı hesaplasaydık, bir milyon parametreli bir ağ için bir milyon ileri geçiş gerekirdi.

Gradyanlar birikir: sıfırlama ve torch.no_grad()

.backward() eski gradyanın yerine yazmaz, ona ekler. Aşağıda y = x³'ün x = 2'deki türevi 3x² = 12'dir, ama üç çağrıdan sonra .grad 36 olur:

import torch

x = torch.tensor(2.0, requires_grad=True)
for i in range(3):
    y = x ** 3
    y.backward()
    print(x.grad)
x.grad.zero_()
print(x.grad)
with torch.no_grad():
    z = x * 2
print(z.requires_grad, x.detach().requires_grad)

tensor(12.)
tensor(24.)
tensor(36.)
tensor(0.)
False False

• x.grad.zero_() gradyanı yerinde sıfırlar (sondaki alt çizgi _ yerinde işlem demektir). Sonraki derslerde bunu optimizer.zero_grad() yapacak.
• with torch.no_grad(): bloğunda graf kurulmaz: parametreleri güncellerken ve modeli değerlendirirken (çıkarım) kullanılır, bellek ve zaman kazandırır.
• .detach(), aynı veriyi paylaşan ama graftan koparılmış bir tensör döndürür; örneğin bir değeri yazdırmak ya da NumPy'a çevirmek için.

Autograd ile gradyan inişi

Şimdi hepsini birleştirip y = 2x + 1 doğrusundan gürültüyle üretilmiş 20 noktaya doğrusal bir model uyduralım. Bu kez türev formülü yazmıyoruz; autograd onları her adımda hesaplıyor. Bu döngünün beş adımı tüm derin öğrenmenin temelidir: ileri geçiş → kayıp → backward → no_grad içinde güncelleme → gradyanları sıfırlama.

import torch

torch.manual_seed(42)
X = torch.linspace(0, 1, 20)
Y = 2 * X + 1 + 0.1 * torch.randn(20)
w = torch.zeros(1, requires_grad=True)
b = torch.zeros(1, requires_grad=True)
lr = 0.5
for step in range(201):
    loss = ((w * X + b - Y) ** 2).mean()
    loss.backward()
    with torch.no_grad():
        w -= lr * w.grad
        b -= lr * b.grad
    w.grad.zero_()
    b.grad.zero_()
    if step % 50 == 0:
        print(f'step {step:3d}  loss {loss.item():.4f}')
print(f'w = {w.item():.3f}, b = {b.item():.3f}')

step   0  loss 4.4302
step  50  loss 0.0085
step 100  loss 0.0084
step 150  loss 0.0084
step 200  loss 0.0084
w = 1.907, b = 1.068

Bu döngüyü iyi hatırla: sonraki derslerde onu kısaltacağız ama özü değişmeyecek. torch.optim.SGD optimizasyon aracının step() metodu her parametre için no_grad içinde tam olarak p -= lr * p.grad işlemini yapar, zero_grad() ise gradyanları temizler. nn.Linear gibi katmanlar w ve b'yi kendileri oluşturur ve requires_grad'ı senin yerine açar. Yani “sihirli” görünen üst düzey kod, bu beş satırın kullanışlı bir sarmalayıcısıdır.