PyTorch: autograd və avtomatik törəmə

Birinci dərsdə xətti reqressiyanın qradiyentlərini əl ilə çıxardıq — cəmi iki parametr üçün. Müasir neyron şəbəkələrdə isə milyonlarla, böyük dil modellərində milyardlarla parametr var; hər biri üçün törəməni kağızda çıxarmaq mümkün deyil. PyTorch-un autograd mexanizmi bu işi avtomatik görür: tenzorlarla etdiyin hər əməliyyatı yadda saxlayır, sonra isə bir əmrlə bütün parametrlərə görə dəqiq törəmələri hesablayır. Bu, nə təxmini ədədi fərqlər, nə də simvolik riyaziyyatdır — bu, avtomatik törəmədir (automatic differentiation).

Hesablama qrafı

requires_grad=True olan tenzorla hər əməliyyat istiqamətlənmiş dövrsüz qrafda (DAG) yeni düyün yaradır. Qrafın yarpaqları girişlər və parametrlərdir, kökü isə itkidir. İrəli keçid (forward pass) zamanı qraf qurulur və qiymətlər hesablanır; geri keçid (backward pass) zamanı autograd kökdən yarpaqlara doğru hərəkət edir və hər düyündə zəncir qaydasını tətbiq edir. Neyron şəbəkələrdə bu prosesə geriyə yayılma (backpropagation) deyilir.

PyTorch-da qraf dinamikdir (define-by-run): hər irəli keçiddə yenidən qurulur. Ona görə modelin içində adi Python if və for operatorlarından sərbəst istifadə etmək olar — qraf həmin anda icra olunan yola uyğun gələcək.

requires_grad, backward() və .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 deyir: «bu tenzora görə törəmə lazım olacaq, əməliyyatları yadda saxla». Parametrlər (nn.Linear-in çəkiləri və s.) bunu avtomatik edir.
• grad_fn tenzoru hansı əməliyyatın yaratdığını göstərir; bu, qrafdakı düyündür.
• y.backward() dy/dx-i hesablayır və nəticəni yarpağın .grad atributuna yazır: y = x² + 2x + 1 üçün dy/dx = 2x + 2 = 8 (x = 3).

Parametr vektor olanda .grad da eyni formada vektordur: hər element üçün xüsusi törəmə. Məsələn, f = ∑ vᵢ² funksiyası üçün ∂f/∂vᵢ = 2vᵢ:

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ğını sonradan da dəyişmək olar: p.requires_grad_(False) parametri «dondurur» — onun qradiyenti hesablanmır və o, öyrətmə zamanı dəyişmir. Bu üsuldan köçürmə öyrənməsində (transfer learning) istifadə olunur: əvvəlcədən öyrədilmiş şəbəkənin əksər qatları dondurulur, yalnız son qat yeni tapşırığa uyğunlaşdırılır. Bunu konvolyusiya şəbəkələri dərsində görəcəyik.

Zəncir qaydası

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 keçidin gücü onun səmərəliliyindədir: bir backward() çağırışı itkinin bütün parametrlərə görə qradiyentini hesablayır və bunun dəyəri irəli keçidin dəyəri ilə eyni tərtibdədir (kiçik sabit əmsal qədər). Hər parametr üçün ayrıca hesablama aparsaydıq, milyon parametrli şəbəkə üçün milyon irəli keçid lazım olardı.

Qradiyentlər toplanır: sıfırlama və torch.no_grad()

.backward() köhnə qradiyenti əvəz etmir, ona əlavə edir. Aşağıda y = x³ funksiyasının x = 2-də törəməsi 3x² = 12-dir, amma üç ç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_() qradiyenti yerində sıfırlayır (alt xətt _ yerində dəyişiklik deməkdir). Növbəti dərslərdə bunu optimizer.zero_grad() edəcək.
• with torch.no_grad(): blokunda qraf qurulmur: parametrləri yeniləyərkən və modeli qiymətləndirərkən (inference) işlədilir, yaddaşa və vaxta qənaət edir.
• .detach() eyni verilənə baxan, lakin qrafdan ayrılmış tenzor qaytarır — məsələn, qiyməti çap etmək və ya NumPy-a çevirmək üçün.

Autograd ilə qradiyent enişi

İndi hər şeyi birləşdirək. y = 2x + 1 düzxəttindən küylə yaradılmış 20 nöqtəyə xətti model uyğunlaşdıraq. Bu dəfə törəmə düsturlarını yazmırıq — hər addımda autograd onları hesablayır. Dövrün beş addımı bütün dərin öyrənmənin əsasıdır: irəli keçid → itki → backward → no_grad daxilində yeniləmə → qradiyentləri 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övrü diqqətlə yadda saxla: növbəti dərslərdə onu qısaldacağıq, amma mahiyyəti dəyişməyəcək. torch.optim.SGD optimallaşdırıcısının step() metodu hər parametr üçün məhz p -= lr * p.grad əməliyyatını no_grad daxilində icra edir, zero_grad() isə qradiyentləri təmizləyir. nn.Linear kimi qatlar w və b-ni özləri yaradır və requires_grad-ı özləri qoşur. Yəni «sehrli» görünən yüksək səviyyəli kod bu beş sətrin rahat qablaşdırılmasıdır.