25.7-dars: PyTorch — tenzor

25-QISM — ML VA AI · 7-dars

1. Kirish va motivatsiya

25.2–25.6 da klassik ML (scikit-learn) ni ko'rdik — jadval ma'lumot, feature engineering. Lekin rasm, matn, ovoz kabi murakkab ma'lumot uchun chuqur o'qitish (deep learning — neyron tarmoq) kerak: model feature'ni avtomatik o'rganadi 25.5-bob. Chuqur o'qitishning poydevori — tenzor va avtomatik gradient. Bu — zamonaviy AI (ChatGPT, rasm tanish) ning asosi.

PyTorch — chuqur o'qitishning eng mashhur kutubxonasi (Meta). Yuragi — tenzor (tensor): NumPy massivi 24.1-bob kabi ko'p o'lchamli massiv, lekin ikki qo'shimcha kuch: GPU (grafik protsessorda tez hisoblash — minglab yadro), avtomatik gradient (autograd — hosila avtomatik, o'qitish uchun). Tenzor NumPy'ga juda o'xshaydi (+, *, reshape, matmul), lekin neyron tarmoq uchun moslangan. Tenzor — chuqur o'qitishning "atomi".

Real vaziyat. Bir loyiha rasm tanish kerak edi — klassik ML (feature qo'lda) yomon ishladi (rasm feature'ini qo'lda yozib bo'lmaydi). PyTorch (neyron tarmoq) qo'llandi: model rasmdan feature'ni o'zi o'rgandi. Asosi — tenzor (rasm → tenzor) va avtomatik gradient (o'qitish). Zamonaviy AI — tenzor ustida. Tenzorni bilish — chuqur o'qitish boshi.

Bu darsda PyTorch tenzorni o'rganamiz.

Bu darsda:

• PyTorch va tenzor nima
• Tenzor yaratish va amallar
• NumPy bilan bog'lanish
• Tenzor atributlari (shape, dtype)
• Avtomatik gradient (autograd)
• Matritsa amallari (matmul)
• GPU (tushuncha)
• Amaliy: tenzor bilan hisoblash

ℹ Misollarda PyTorch (torch.manual_seed(42)) bilan sinaladi.

2. Nazariya — chuqur tushuntirish

2.1. PyTorch va tenzor nima

Tenzor — NumPy massivi + qo'shimcha kuch:

import torch
a = torch.tensor([1.0, 2.0, 3.0])     # 1D tenzor
b = torch.tensor([[1, 2], [3, 4]])    # 2D tenzor

PyTorch — chuqur o'qitish kutubxonasi; tenzor — uning asosiy ma'lumot tuzilmasi: NumPy massivi 24.1-bob kabi ko'p o'lchamli massiv (torch.tensor(...)), lekin ikki qo'shimcha: GPU (tez parallel hisoblash), autograd (avtomatik gradient — o'qitish). Tenzor NumPy'ga juda o'xshaydi (amallar, shakl), lekin neyron tarmoq uchun. Skalyar (0D), vektor (1D), matritsa (2D), yuqori (3D+ — rasm, batch). Chuqur o'qitishning "atomi".

2.2. Tenzor yaratish va amallar

NumPy kabi:

torch.tensor([1, 2, 3])          # ro'yxatdan
torch.zeros(3); torch.ones(2, 3)  # nol/bir
torch.arange(6)                   # ketma-ketlik
torch.randn(2, 3)                 # tasodifiy (normal)
a + 10; a * 2; a ** 2             # vektorlangan (24.1 kabi)

Tenzor yaratish (NumPy 24.1 kabi): torch.tensor(ro'yxat), torch.zeros/torch.ones (shakl bilan), torch.arange (ketma-ketlik), torch.randn (tasodifiy — normal taqsimot). Amallar vektorlangan 24.1-bob: a + 10, a * 2, a + b (element-element), a > 2 (bool). NumPy bilgan uchun oson — deyarli bir xil API. Bu neyron tarmoq hisoblarining asosi.

2.3. NumPy bilan bog'lanish

Tenzor ↔ NumPy:

import numpy as np
t = torch.from_numpy(np.array([1, 2, 3]))   # NumPy → tenzor
n = t.numpy()                                # tenzor → NumPy
# xotirani bo'lishadi (nusxa emas — ehtiyot)

Tenzor va NumPy oson o'zaro: torch.from_numpy(massiv) (NumPy → tenzor), .numpy() (tenzor → NumPy). Bu ma'lumot tayyorlash (pandas/NumPy — 24-qism) va model (PyTorch) orasida ko'prik. Ehtiyot: from_numpy xotirani bo'lishadi (biri o'zgarsa, ikkinchi ham). Bu integratsiya PyTorch'ni ekotizimga ulaydi (NumPy, pandas, scikit-learn). NumPy → tenzor → model.

2.4. Tenzor atributlari

Tenzor haqida:

a.shape       # o'lcham (24.1 kabi)
a.dtype       # tur (torch.float32)
a.ndim        # o'lchamlar soni
a.reshape(2, 3)   # shakl o'zgartirish
a.to(torch.float64)   # tur o'zgartirish

Tenzor atributlari (NumPy 24.1 kabi): .shape (o'lcham), .dtype (tur — torch.float32 odatda, chuqur o'qitish uchun), .ndim (o'lchamlar). .reshape (shakl), .to(dtype) (tur). Muhim: chuqur o'qitishda float32 (neyron tarmoq — o'nli son). Shakl (shape) juda muhim (neyron tarmoq qatlamlari shakl mos bo'lsin). NumPy bilim bevosita qo'l keladi.

2.5. Avtomatik gradient (autograd)

Tenzorning eng kuchli imkoniyati:

x = torch.tensor(2.0, requires_grad=True)
y = x ** 2 + 3 * x        # y = x^2 + 3x
y.backward()              # gradientni hisobla
x.grad                    # dy/dx = 2x + 3 = 7 (x=2 da)

Avtomatik gradient (autograd) — tenzorning eng muhim imkoniyati: requires_grad=True (gradient kuzatilsin), y.backward() (gradientni avtomatik hisobla), x.grad (hosila — dy/dx). PyTorch amallarni kuzatadi va hosilani avtomatik hisoblaydi (qo'lda emas!). Bu neyron tarmoq o'qitishining asosi: gradient orqali model parametrlarini yaxshilash (gradient descent). "Avtomatik hosila" — chuqur o'qitishning sehri.

2.6. Matritsa amallari (matmul)

Neyron tarmoq asosi — matritsa ko'paytma:

torch.matmul(A, B)       # matritsa ko'paytma (yoki A @ B)
A @ B                    # bir xil
A.T                      # transpozitsiya
# neyron tarmoq: kirish @ vazn = chiqish

Matritsa amallari: torch.matmul(A, B) yoki A @ B (matritsa ko'paytma — 24.2 dot kabi), A.T (transpozitsiya). Neyron tarmoqning asosi — kirish @ vazn (weights) = chiqish (har qatlam matritsa ko'paytma). GPU matritsa ko'paytmani juda tez qiladi (parallel) — shuning uchun chuqur o'qitish GPU'da. Chiziqli algebra — neyron tarmoq matematikasi. Tenzor matritsa amallari uchun.

2.7. GPU (tushuncha)

Tez parallel hisoblash:

device = "cuda" if torch.cuda.is_available() else "cpu"
a = a.to(device)         # tenzorni GPU'ga
# GPU: minglab yadro (matritsa ko'paytma parallel)
# CPU: kam yadro (ketma-ket)

GPU (grafik protsessor) — chuqur o'qitishning tezligi: minglab yadro (matritsa ko'paytmani parallel — bir vaqtda ko'p), CPU esa kam yadro (ketma-ket). torch.cuda.is_available() (GPU bormi), .to("cuda") (tenzorni GPU'ga). Katta neyron tarmoq (millionlab parametr) CPU'da soatlar, GPU'da daqiqalar. Tenzor GPU'da ishlashi — PyTorch'ning NumPy'dan asosiy farqi. (Bu darsda CPU — GPU tushuncha.)

2.8. Tenzor — chuqur o'qitish atomi

Tenzor — chuqur o'qitishning atomi: barcha ma'lumot (rasm, matn, ovoz) tenzorga aylanadi (rasm — 3D tenzor: balandlik × kenglik × rang), model parametrlari tenzor, hisoblash tenzor amallari. Uch asosiy imkoniyat: NumPy kabi (oson — vektorlangan amal), autograd (avtomatik gradient — o'qitish), GPU (tez — parallel). Klassik ML (scikit-learn) feature qo'lda; chuqur o'qitish tenzor + gradient bilan feature'ni avtomatik o'rganadi 25.8-bob. Tenzorni tushunish — zamonaviy AI boshi.

3. Tez ma'lumotnoma

import torch

# yaratish:
torch.tensor([1.0, 2.0, 3.0])       # ro'yxatdan
torch.zeros(3); torch.ones(2, 3)
torch.arange(6); torch.randn(2, 3)

# amallar (NumPy kabi):
a + 10; a * 2; a ** 2; a @ b        # vektorlangan, matmul
a.shape; a.dtype; a.reshape(2, 3)

# NumPy bilan:
torch.from_numpy(np_array)          # NumPy → tenzor
tensor.numpy()                       # tenzor → NumPy

# autograd (avtomatik gradient):
x = torch.tensor(2.0, requires_grad=True)
y = x ** 2 + 3 * x
y.backward()
x.grad                               # dy/dx

# GPU:
device = "cuda" if torch.cuda.is_available() else "cpu"
a.to(device)

Tenzor xulosasi

Tenzor: NumPy massivi + GPU + autograd · yaratish/amallar (24.1 kabi)
from_numpy/numpy: NumPy ko'prigi · shape/dtype (float32)
autograd: y.backward(), x.grad (avtomatik hosila) · matmul (neyron tarmoq)

4. Batafsil misollar

Misollarda PyTorch (torch.manual_seed(42)) bilan sinaladi.

Misol 1 — Tenzor yaratish va amallar

"""tenzor yaratish (tensor/zeros/arange); amallar (+, *, matmul) — NumPy kabi."""

import warnings
warnings.filterwarnings("ignore")

import torch


def main() -> None:
    print("=== 1. Tenzor yaratish ===")
    a = torch.tensor([1.0, 2.0, 3.0, 4.0])
    print(f"  {a.tolist()}, shape: {list(a.shape)}, dtype: {a.dtype}")

    print("\n=== 2. Turli yaratish ===")
    print(f"  zeros(3): {torch.zeros(3).tolist()}")
    print(f"  arange(6): {torch.arange(6).tolist()}")

    print("\n=== 3. Vektorlangan amallar (24.1 kabi) ===")
    print(f"  a + 10: {(a + 10).tolist()}")
    print(f"  a * 2: {(a * 2).tolist()}")
    print(f"  a ** 2: {(a ** 2).tolist()}")

    print("\n=== 4. Agregat va shakl ===")
    print(f"  sum: {float(a.sum())}, mean: {float(a.mean())}")
    b = torch.arange(6).reshape(2, 3)
    print(f"  reshape(2,3): {b.tolist()}")
    print("  ⭐ tenzor — NumPy massivi kabi (vektorlangan amal)")


if __name__ == "__main__":
    main()

Natijaning muhim qismi:

=== 1. Tenzor yaratish ===
  [1.0, 2.0, 3.0, 4.0], shape: [4], dtype: torch.float32

=== 2. Turli yaratish ===
  zeros(3): [0.0, 0.0, 0.0]
  arange(6): [0, 1, 2, 3, 4, 5]

=== 3. Vektorlangan amallar (24.1 kabi) ===
  a + 10: [11.0, 12.0, 13.0, 14.0]
  a * 2: [2.0, 4.0, 6.0, 8.0]
  a ** 2: [1.0, 4.0, 9.0, 16.0]

=== 4. Agregat va shakl ===
  sum: 10.0, mean: 2.5
  reshape(2,3): [[0, 1, 2], [3, 4, 5]]
  ⭐ tenzor — NumPy massivi kabi (vektorlangan amal)

Nima ko'rsatdi: 2.1, 2.2, 2.4-bo'limlar.

Misol 2 — NumPy bilan bog'lanish va matritsa

"""from_numpy/numpy (NumPy ko'prigi); matmul (matritsa ko'paytma — neyron tarmoq asosi)."""

import warnings
warnings.filterwarnings("ignore")

import numpy as np
import torch


def main() -> None:
    print("=== 1. NumPy → tenzor ===")
    n = np.array([1.0, 2.0, 3.0])
    t = torch.from_numpy(n)
    print(f"  NumPy {n.tolist()} → tenzor {t.tolist()}")

    print("\n=== 2. Tenzor → NumPy ===")
    back = t.numpy()
    print(f"  tenzor → NumPy: {back.tolist()}")

    print("\n=== 3. Matritsa ko'paytma (matmul) ===")
    A = torch.tensor([[1.0, 2.0], [3.0, 4.0]])
    B = torch.tensor([[5.0, 6.0], [7.0, 8.0]])
    print(f"  A @ B = {torch.matmul(A, B).tolist()}")

    print("\n=== 4. Transpozitsiya ===")
    print(f"  A: {A.tolist()}")
    print(f"  A.T: {A.T.tolist()}")
    print("  ⭐ NumPy ko'prigi, matmul (neyron tarmoq: kirish @ vazn)")


if __name__ == "__main__":
    main()

Natijaning muhim qismi:

=== 1. NumPy → tenzor ===
  NumPy [1.0, 2.0, 3.0] → tenzor [1.0, 2.0, 3.0]

=== 2. Tenzor → NumPy ===
  tenzor → NumPy: [1.0, 2.0, 3.0]

=== 3. Matritsa ko'paytma (matmul) ===
  A @ B = [[19.0, 22.0], [43.0, 50.0]]

=== 4. Transpozitsiya ===
  A: [[1.0, 2.0], [3.0, 4.0]]
  A.T: [[1.0, 3.0], [2.0, 4.0]]
  ⭐ NumPy ko'prigi, matmul (neyron tarmoq: kirish @ vazn)

Nima ko'rsatdi: 2.3, 2.6-bo'limlar.

Misol 3 — Avtomatik gradient (autograd)

"""autograd: requires_grad, backward(), grad — avtomatik hosila (o'qitish asosi)."""

import warnings
warnings.filterwarnings("ignore")

import torch


def main() -> None:
    print("=== 1. Gradient kuzatish (requires_grad) ===")
    x = torch.tensor(2.0, requires_grad=True)
    print(f"  x = {float(x)}, gradient kuzatiladi")

    print("\n=== 2. Funksiya: y = x^2 + 3x ===")
    y = x ** 2 + 3 * x
    print(f"  y = {float(y)} (x=2 da: 4 + 6 = 10)")

    print("\n=== 3. Gradient (backward) ===")
    y.backward()
    print(f"  dy/dx = 2x + 3 = {float(x.grad)} (x=2 da: 4 + 3 = 7)")

    print("\n=== 4. Boshqa nuqtada ===")
    x2 = torch.tensor(5.0, requires_grad=True)
    y2 = x2 ** 2 + 3 * x2
    y2.backward()
    print(f"  x=5 da dy/dx = {float(x2.grad)} (2*5+3 = 13)")
    print("  ⭐ autograd — hosila avtomatik (neyron tarmoq o'qitish)")


if __name__ == "__main__":
    main()

Natijaning muhim qismi:

=== 1. Gradient kuzatish (requires_grad) ===
  x = 2.0, gradient kuzatiladi

=== 2. Funksiya: y = x^2 + 3x ===
  y = 10.0 (x=2 da: 4 + 6 = 10)

=== 3. Gradient (backward) ===
  dy/dx = 2x + 3 = 7.0 (x=2 da: 4 + 3 = 7)

=== 4. Boshqa nuqtada ===
  x=5 da dy/dx = 13.0 (2*5+3 = 13)
  ⭐ autograd — hosila avtomatik (neyron tarmoq o'qitish)

Nima ko'rsatdi: 2.5-bo'lim.

Misol 4 — Amaliy: chiziqli model gradient bilan

Real chuqur o'qitish boshi: oddiy chiziqli model (y = wx + b) va gradient — model qanday o'rganishi. Bu — neyron tarmoq o'qitishining namunasi.

"""to'liq: chiziqli model (y=wx+b), yo'qotish (loss), gradient — o'qitish mexanizmi."""

import warnings
warnings.filterwarnings("ignore")

import torch


def main() -> None:
    # ma'lumot: y = 2x (model buni o'rganishi kerak)
    X = torch.tensor([1.0, 2.0, 3.0, 4.0])
    y_haqiqiy = torch.tensor([2.0, 4.0, 6.0, 8.0])

    print("=== 1. Parametr (o'rganiladigan) ===")
    w = torch.tensor(0.5, requires_grad=True)     # boshlang'ich taxmin
    print(f"  boshlang'ich w = {float(w)} (haqiqiy: 2)")

    print("\n=== 2. Bashorat va yo'qotish (loss) ===")
    y_bashorat = w * X
    loss = ((y_bashorat - y_haqiqiy) ** 2).mean()   # o'rtacha kvadratik xato
    print(f"  bashorat: {[round(v, 2) for v in y_bashorat.tolist()]}")
    print(f"  loss (xato): {round(float(loss), 3)}")

    print("\n=== 3. Gradient (loss'ni kamaytirish yo'nalishi) ===")
    loss.backward()
    print(f"  dloss/dw = {round(float(w.grad), 3)}")

    print("\n=== 4. Parametrni yangilash (gradient descent) ===")
    with torch.no_grad():
        w_yangi = w - 0.01 * w.grad          # kichik qadam
    print(f"  w: {float(w)} → {round(float(w_yangi), 3)} (2 ga yaqinlashdi)")
    print("  ⭐ gradient — model parametrini yaxshilash (o'qitish)")


if __name__ == "__main__":
    main()

Natijaning muhim qismi:

=== 1. Parametr (o'rganiladigan) ===
  boshlang'ich w = 0.5 (haqiqiy: 2)

=== 2. Bashorat va yo'qotish (loss) ===
  bashorat: [0.5, 1.0, 1.5, 2.0]
  loss (xato): 16.875

=== 3. Gradient (loss'ni kamaytirish yo'nalishi) ===
  dloss/dw = -22.5

=== 4. Parametrni yangilash (gradient descent) ===
  w: 0.5 → 0.725 (2 ga yaqinlashdi)
  ⭐ gradient — model parametrini yaxshilash (o'qitish)

Nima ko'rsatdi: 2.1–2.8-bo'limlar.

5. To'g'ri va noto'g'ri tushunishlar

6. Keng tarqalgan xatolar va yechimlari

1. requires_gradsiz gradient

x = torch.tensor(2.0)
y.backward()   # xato (grad kuzatilmagan)             # ⚠️
x = torch.tensor(2.0, requires_grad=True)              # ✅

2. Shakl mos emas (matmul)

torch.matmul(A_2x3, B_2x3)   # ⚠️ (3 ≠ 2)
torch.matmul(A_2x3, B_3x2)   # ✅ (ichki o'lcham mos)

3. float32 o'rniga int

torch.tensor([1, 2, 3])   # int (gradient yo'q)        # ⚠️
torch.tensor([1.0, 2.0])  # float32                     # ✅

4. backward ikki marta

y.backward(); y.backward()   # xato (grafik tozalangan)  # ⚠️
# retain_graph=True yoki qayta hisobla                   # ✅

5. grad yig'iladi (zero_grad)

# har backward grad qo'shiladi                          # ⚠️
x.grad.zero_()   # oldin tozala                          # ✅

6. no_gradsiz yangilash

w = w - 0.01 * w.grad   # grafikka qo'shiladi            # ⚠️
with torch.no_grad(): w -= ...                            # ✅

7. from_numpy xotira bo'lishish

t = torch.from_numpy(n); n[0] = 99   # t ham o'zgaradi   # ehtiyot

7. Integratsiya — bu bilim qayerda kerak bo'ladi

• 24.1-dars (o'tilgan): NumPy massiv — tenzor asosi
• 25.8-dars: Neyron tarmoq — tenzor ustida
• 25.9-dars: Model o'qitish — gradient
• 24.2-dars (o'tilgan): Matritsa amallari (dot)
• 25.10-dars: LLM — tenzor (embedding)

8. Eng yaxshi amaliyotlar

1. NumPy bilimini ishlat (tenzor o'xshash).

2. float32 (chuqur o'qitish).

3. requires_grad=True (o'qitiladigan parametr).

4. backward() — avtomatik gradient.

5. no_grad — yangilashda.

6. Shaklni tekshir (matmul mos).

7. from_numpy/numpy — ko'prik.

8. GPU'da katta model (.to(device)).

9. Amaliy topshiriq

Vazifa 1: Bashorat qiling

1.  # PyTorch nima?
2.  # tenzor nima?
3.  # tenzor vs NumPy?
4.  # torch.tensor nima?
5.  # matmul nima?
6.  # autograd nima?
7.  # requires_grad nima?
8.  # backward nima?
9.  # grad nima?
10. # GPU nega tez?
11. # from_numpy nima?
12. # float32 nega?

Vazifa 2: Xatolarni tuzating

1.  x = torch.tensor(2.0); y.backward()   # requires_grad

2.  torch.matmul(A_2x3, B_2x3)            # shakl

3.  torch.tensor([1, 2, 3])   # int        # float

4.  w = w - 0.01 * w.grad                  # no_grad

5.  # har backward grad qo'shiladi         # zero_

1.  x = torch.tensor(2.0, requires_grad=True)

2.  torch.matmul(A_2x3, B_3x2)

3.  torch.tensor([1.0, 2.0, 3.0])

4.  with torch.no_grad(): w -= 0.01 * w.grad

5.  x.grad.zero_()

Vazifa 3: Tenzor

Yaratish:

1. tensor, zeros
2. Amallar
3. shape, dtype
4. reshape

Vazifa 4: NumPy/matmul

Bog'lanish:

1. from_numpy
2. numpy
3. matmul
4. .T

Vazifa 5: Autograd

Gradient:

1. requires_grad
2. Funksiya
3. backward
4. grad

Vazifa 6: Chiziqli model

O'qitish:

1. Parametr
2. Bashorat, loss
3. Gradient
4. Yangilash

Vazifa 7: O'ylash

Tenzor NumPy massiviga o'xshaydi, lekin ikki qo'shimcha: avtomatik gradient (autograd) va GPU. Avtomatik gradient chuqur o'qitishning sehri — model o'zi hosilani hisoblab, parametrini yaxshilaydi. Nima uchun "avtomatik gradient" chuqur o'qitishni mumkin qildi, va nega bu klassik ML (25.2 — feature qo'lda) va chuqur o'qitish (feature avtomatik) orasidagi farqning texnik asosi?

Nimani mustahkamlaydi: 2.1–2.8-bo'limlar.

Xulosa

Bu darsda PyTorch tenzorni o'rgandik.

Eng muhim uch fikr:

1. Tenzor — NumPy massivi + qo'shimcha kuch. PyTorch — chuqur o'qitish kutubxonasi; tenzor — uning asosi: NumPy massivi 24.1-bob kabi ko'p o'lchamli massiv (torch.tensor), lekin ikki qo'shimcha — GPU (tez parallel) va autograd (avtomatik gradient). Yaratish (NumPy kabi): torch.tensor, zeros/ones, arange, randn. Amallar vektorlangan 24.1-bob: a + 10, a * 2, a @ b (matmul). Atributlar: .shape, .dtype (float32 — chuqur o'qitish), .reshape. NumPy ko'prigi: from_numpy, .numpy(). NumPy bilim bevosita qo'l keladi.

2. Avtomatik gradient (autograd). Autograd — tenzorning eng muhim imkoniyati: requires_grad=True (gradient kuzatilsin), y.backward() (gradientni avtomatik hisobla), x.grad (hosila — dy/dx). PyTorch amallarni kuzatib, hosilani avtomatik hisoblaydi (qo'lda emas). Bu neyron tarmoq o'qitishining asosi: gradient orqali model parametrlarini yaxshilash (gradient descent — w = w - lr * grad). Matritsa amallari (matmul, @) — neyron tarmoq asosi (kirish @ vazn = chiqish). GPU — minglab yadro (matritsa ko'paytmani parallel — tez).

3. Tenzor — chuqur o'qitish atomi. Barcha ma'lumot (rasm — 3D tenzor, matn, ovoz) tenzorga aylanadi, model parametrlari tenzor, hisoblash tenzor amallari. Uch imkoniyat: NumPy kabi (oson — vektorlangan), autograd (avtomatik gradient), GPU (tez). Avtomatik gradient chuqur o'qitishni mumkin qildi: neyron tarmoq millionlab parametrli (har biri o'qitiladi) — gradientni qo'lda hisoblab bo'lmaydi, autograd avtomatik qiladi. Bu klassik ML (inson feature — 25.5) va chuqur o'qitish (model feature'ni avtomatik o'rganadi — ko'p qatlam, millionlab parametr) farqining texnik asosi. Tenzorni tushunish — zamonaviy AI boshi.

Keyingi darsda PyTorch: neyron tarmoq ni o'rganamiz: tenzor va gradient ustida neyron tarmoq qurish — qatlamlar, faollashtirish funksiyalari, nn.Module — chuqur o'qitish modeli.