Bu modul uch katta mavzuni bog’laydi: to’liq o’qitish sikli, ko’p qatlamli perseptron (MLP) va tasvir uchun konvolyutsion tarmoqlar (CNN).

To’liq training sikli

Har qanday PyTorch o’qitishning skeleti besh qadamdan iborat va u har epoch’da har batch uchun takrorlanadi:

for epoch in range(epochs):
    model.train()
    for xb, yb in train_loader:
        optimizer.zero_grad()          # 1. eski gradientlarni tozalash
        pred = model(xb)               # 2. forward
        loss = loss_fn(pred, yb)       # 3. xatoni o'lchash
        loss.backward()                # 4. backward — gradientlar
        optimizer.step()               # 5. og'irliklarni yangilash

    model.eval()
    with torch.no_grad():              # baholashda gradient kerak emas
        val_loss = evaluate(model, val_loader)

Epoch — butun train to’plamining bir marta to’liq o’tishi. model.train()/model.eval() juftligi dropout va batch norm kabi qatlamlarning rejimini almashtiradi — eval()siz baholash noto’g’ri natija beradi. Tugagan modelni saqlash: torch.save(model.state_dict(), "model.pt") — butun obyekt emas, og’irliklar lug’ati saqlanadi.

O’qitishning sog’lig’i ikki egri chiziqda ko’rinadi: train loss va validation loss. Ikkalasi tushsa — yaxshi; train tushib val o’ssa — overfitting boshlandi (davolari: ko’proq ma’lumot, augmentatsiya, dropout, kichikroq model, erta to’xtatish).

MLP va uning chegarasi

Ko’p qatlamli perseptron (MLP) — faqat Linear + aktivatsiya qatlamlaridan tuzilgan tarmoq. U jadval ma’lumotida yaxshi, lekin rasmda ikki muammoga uchraydi: 224×224×3 rasm 150 mingdan ortiq kirish — birinchi qatlamning o’zi millionlab parametr; va tekislashda (flatten) piksellarning fazoviy qo’shniligi yo’qoladi — "mushukning qulog’i qayerda bo’lsa ham mushuk" degan bilimni MLP har joy uchun qaytadan o’rganishi kerak.

Konvolyutsiya: filtr g’oyasi

CNN muammoni kichik filtr (kernel, masalan 3×3) bilan hal qiladi: filtr rasm bo’ylab suriladi va har joyda bitta qiymat hisoblaydi — natija feature map (xususiyat xaritasi). Bitta filtr butun rasm uchun bitta og’irliklar to’plamini ishlatadi (weight sharing) — parametrlar keskin kamayadi va "qayerda bo’lsa ham o’sha belgi" xossasi bepul keladi.

import torch.nn as nn

conv = nn.Conv2d(in_channels=3, out_channels=16, kernel_size=3, padding=1)
x = torch.rand(8, 3, 32, 32)
print(conv(x).shape)

Natija:

torch.Size([8, 16, 32, 32])

16 ta filtr — 16 ta feature map. padding=1 chetlarni to’ldirib o’lchamni saqlaydi; stride — filtr qadami. Pooling (nn.MaxPool2d(2)) har 2×2 sohadan eng kattasini olib, xaritani ikki barobar kichraytiradi — hisob kamayadi, muhim belgilar qoladi.

Klassik CNN shu bloklarning takrori: conv → ReLU → pool chuqurlashgan sari kanallar ko’payib, fazoviy o’lcham kichrayadi; oxirida to’liq bog’langan qatlam sinf ballarini beradi.

Amaliyot

1. Training siklining 5 qadamini yoddan yozing va har birining vazifasini bir jumlada izohlang.
2. zero_grad()ni tashlab ketilgan sikl qanday kasallanishini tushuntiring (458-modul 5-mashqdagi tajribangizga tayaning).
3. Conv2d(3, 32, 3) qatlamining parametrlar sonini qo’lda hisoblang (3·3·3·32 + 32) va sum(p.numel() for p in conv.parameters()) bilan tekshiring.
4. 28×28 rasm uchun mini-CNN yig’ing: Conv(1→8) → ReLU → MaxPool(2) → Flatten → Linear(8·14·14 → 10); har bosqich shape’ini chiqarib boring.
5. Train loss 0.1 gacha tushib, val loss 0.9 ga o’sgan holatga tashxis qo’ying va uchta davo taklif qiling.

Modul testi keyingi darsda.