Autograd - avtomatik hosila

Oldingi darslikda siz har bir qatlam uchun hosilani qo'lda chiqardingiz. Bu bo'limda o'sha ishni PyTorch bajaradi - va bu uning asosiy qobiliyati.

Birinchi hosila #

import torch

x = torch.tensor(3.0, requires_grad=True)
y = x ** 2
y.backward()

print("y =", y.item(), "| dy/dx =", x.grad.item())

y = 9.0 | dy/dx = 6.0

Matematika bilan solishtiramiz: y = x² ning hosilasi 2x, x = 3 da esa 2 · 3 = 6. PyTorch aynan shu javobni berdi - lekin siz hech qanday formula yozmadingiz.

Bir nechta o'zgaruvchi #

x = torch.tensor(2.0, requires_grad=True)
y = torch.tensor(5.0, requires_grad=True)

z = x * y + y ** 2
z.backward()

print("z =", z.item(), "| dz/dx =", x.grad.item(), "| dz/dy =", y.grad.item())

z = 35.0 | dz/dx = 5.0 | dz/dy = 12.0

Tekshiramiz: ∂z/∂x = y = 5, ∂z/∂y = x + 2y = 2 + 10 = 12. Ikkalasi ham to'g'ri.

Modelda minglab parametr bo'ladi va backward() ularning hammasi uchun hosilani bitta chaqiruvda hisoblaydi.

Hisoblash grafi #

Graf oldindan emas, hisoblash paytida quriladi - 1-bo'limda aytilgan define-by-run mana shu. Har bir natija tenzori o'zini kim yaratganini eslab qoladi:

a = torch.tensor(2.0, requires_grad=True)
b = a * 3
print("grad_fn bor:", b.grad_fn is not None)

grad_fn bor: True

Gradientlar to'planadi #

Bu PyTorch ning eng ko'p adashtiradigan xatti-harakati:

w = torch.tensor(1.0, requires_grad=True)

for i in range(3):
    out = w * 2
    out.backward()
    print(f"  {i+1}-chaqiruvdan keyin w.grad =", w.grad.item())

  1-chaqiruvdan keyin w.grad = 2.0
  2-chaqiruvdan keyin w.grad = 4.0
  3-chaqiruvdan keyin w.grad = 6.0

Hosila har safar 2 bo'lishi kerak edi, lekin u qo'shilib bordi: 2, 4, 6.

Yechim - har qadamdan oldin tozalash:

w = torch.tensor(1.0, requires_grad=True)

for i in range(3):
    if w.grad is not None:
        w.grad.zero_()
    out = w * 2
    out.backward()
    print(f"  {i+1}-chaqiruvdan keyin w.grad =", w.grad.item())

  1-chaqiruvdan keyin w.grad = 2.0
  2-chaqiruvdan keyin w.grad = 2.0
  3-chaqiruvdan keyin w.grad = 2.0

no_grad - hosila kerak bo'lmaganda #

Modelni sinayotganda hosila kerak emas. Uni hisoblash esa vaqt va xotira oladi:

a = torch.tensor(2.0, requires_grad=True)

b = a * 3
print("grad_fn bor:", b.grad_fn is not None)

with torch.no_grad():
    c = a * 3
print("no_grad ichida grad_fn:", c.grad_fn is not None)

grad_fn bor: True
no_grad ichida grad_fn: False

Ishlab chiqarishda torch.inference_mode() ham bor - u no_grad dan biroz tezroq va aynan bashorat uchun mo'ljallangan.

detach() #

Ba'zan tenzorni grafdan uzib olish kerak bo'ladi - masalan, uni jurnalga yozish yoki NumPy ga o'tkazish uchun:

qiymat = tenzor.detach().cpu().numpy()

requires_grad=True bo'lgan tenzorni to'g'ridan-to'g'ri .numpy() qilsangiz, xato chiqadi:

RuntimeError: Can't call numpy() on Tensor that requires grad.
Use tensor.detach().numpy() instead.

Xato xabarining o'zi yechimni aytib turibdi - PyTorch ning yaxshi tomoni shunda.

Xulosa #

• requires_grad=True tenzor bo'yicha hosila kerakligini bildiradi.
• backward() grafdagi barcha parametrlar uchun hosilani bitta chaqiruvda hisoblaydi.
• Natija .grad maydonida saqlanadi.
• Graf hisoblash paytida quriladi - har natija tenzorida grad_fn bo'ladi.
• Gradientlar to'planadi: backward() ni ikki marta chaqirsangiz, qiymat qo'shiladi.
• Shuning uchun har qadamdan oldin zero_grad() chaqiriladi.
• Uni unutish quvurni yiqitmaydi - model shunchaki yomon o'qiydi, yo'qotish sakraydi.
• To'planish ataylab qilingan: katta paketni bo'lib hisoblash uchun kerak.
• torch.no_grad() validatsiya va bashoratda tezlik hamda xotira tejaydi.
• .detach() tenzorni grafdan uzadi - NumPy ga o'tkazishdan oldin kerak.

Keyingi bo'limda nn.Module yordamida birinchi haqiqiy modelni quramiz.