nn.Module bilan birinchi model

Tenzor va autograd - qurilish g'ishtlari. Endi ulardan model yasaymiz. PyTorch da har qanday model nn.Module dan meros oladi.

Eng kichik qatlam: nn.Linear #

nn.Linear bitta chiziqli amalni bajaradi: y = x @ W.T + b.

import torch
import torch.nn as nn

torch.manual_seed(42)

qatlam = nn.Linear(3, 2)
print("og'irlik shakli:", qatlam.weight.shape)
print("siljish shakli: ", qatlam.bias.shape)

x = torch.randn(4, 3)
y = qatlam(x)
print("kirish:", x.shape, "-> chiqish:", y.shape)

og'irlik shakli: torch.Size([2, 3])
siljish shakli:  torch.Size([2])
kirish: torch.Size([4, 3]) -> chiqish: torch.Size([4, 2])

Diqqat qiling: kirishda 4 ta namuna bor edi, chiqishda ham 4 ta. Qatlam faqat oxirgi o'lchamni 3 dan 2 ga o'zgartirdi.

O'z modelingizni yozish #

Haqiqiy model bir nechta qatlamdan iborat bo'ladi. Uni yozish uchun nn.Module dan meros olinadi va ikkita narsa yoziladi: __init__ da qatlamlar, forward da ularning tartibi.

class KichikTarmoq(nn.Module):
    def __init__(self, kirish, yashirin, chiqish):
        super().__init__()
        self.qatlam1 = nn.Linear(kirish, yashirin)
        self.faol = nn.ReLU()
        self.qatlam2 = nn.Linear(yashirin, chiqish)

    def forward(self, x):
        x = self.qatlam1(x)
        x = self.faol(x)
        return self.qatlam2(x)

model = KichikTarmoq(3, 8, 1)
print(model)

KichikTarmoq(
  (qatlam1): Linear(in_features=3, out_features=8, bias=True)
  (faol): ReLU()
  (qatlam2): Linear(in_features=8, out_features=1, bias=True)
)

print(model) modelning tuzilishini ko'rsatadi - bu xatolarni topishda juda qulay.

Ma'lumot qanday oqadi #

Parametrlarni sanash #

jami = sum(p.numel() for p in model.parameters())
print("parametrlar soni:", jami)

for nom, p in model.named_parameters():
    print(f"  {nom:16s} {tuple(p.shape)}  {p.numel()} ta")

parametrlar soni: 41
  qatlam1.weight   (8, 3)  24 ta
  qatlam1.bias     (8,)  8 ta
  qatlam2.weight   (1, 8)  8 ta
  qatlam2.bias     (1,)  1 ta

24 + 8 + 8 + 1 = 41 - figuradagi son bilan mos tushdi. Bu odat foydali: model kutilganidan ancha katta yoki kichik bo'lsa, xato shu yerda ko'rinadi.

Paket bilan ishlash #

Model bitta namuna uchun emas, paket uchun yoziladi:

chiqish = model(torch.randn(5, 3))
print("5 ta namuna uchun chiqish shakli:", chiqish.shape)

5 ta namuna uchun chiqish shakli: torch.Size([5, 1])

Birinchi o'lcham har doim paket hajmi bo'ladi. Siz forward da u haqida o'ylamaysiz ham - qatlamlar uni o'zi tashib yuradi.

nn.Sequential - qisqa yozuv #

Agar qatlamlar shunchaki ketma-ket bo'lsa, sinf yozish shart emas:

ketma = nn.Sequential(
    nn.Linear(3, 8),
    nn.ReLU(),
    nn.Linear(8, 1),
)
print("Sequential parametrlari:", sum(p.numel() for p in ketma.parameters()))

Sequential parametrlari: 41

Bir xil model, ikki xil yozuv.

Xulosa #

• PyTorch da har qanday model nn.Module dan meros oladi.
• nn.Linear(kirish, chiqish) faqat oxirgi o'lchamni o'zgartiradi.
• Model ikki qismdan iborat: __init__ da qatlamlar, forward da ularning tartibi.
• super().__init__() majburiy - usiz parametrlar ro'yxatga olinmaydi va model o'qimaydi.
• Modelni model(x) deb chaqiring, model.forward(x) deb emas.
• print(model) tuzilishni ko'rsatadi - xato qidirishda birinchi qadam.
• model.parameters() barcha o'qitiladigan tenzorlarni beradi.
• named_parameters() ularni nomi bilan beradi - qaysi qatlam qancha joy olishi ko'rinadi.
• Model paket bilan ishlaydi: birinchi o'lcham har doim namunalar soni.
• nn.Sequential - qatlamlar ketma-ket bo'lganda qisqa muqobil.

Keyingi bo'limda modelga nima o'rganishni aytadigan ikki narsani qo'shamiz: yo'qotish funksiyasi va optimizator.