Yakuniy loyiha

import torch, time, os
import torch.nn as nn
from torch.utils.data import DataLoader, random_split
from torchvision import datasets, transforms

QURILMA = torch.device("cuda" if torch.cuda.is_available() else "cpu")
ORTACHA, OGISH = 0.2860, 0.3530
SINFLAR = ['Futbolka', 'Shim', 'Sviter', 'Libos', 'Palto',
           'Sandal', "Ko'ylak", 'Krossovka', 'Sumka', 'Botinka']
torch.manual_seed(42)
print("qurilma:", QURILMA)

oquv_t = transforms.Compose([
    transforms.RandomHorizontalFlip(),
    transforms.RandomAffine(degrees=8, translate=(0.08, 0.08)),
    transforms.ToTensor(), transforms.Normalize((ORTACHA,), (OGISH,))])

baho_t = transforms.Compose([
    transforms.ToTensor(), transforms.Normalize((ORTACHA,), (OGISH,))])

toliq   = datasets.FashionMNIST("./data", train=True, transform=oquv_t)
toliq_v = datasets.FashionMNIST("./data", train=True, transform=baho_t)
test    = datasets.FashionMNIST("./data", train=False, transform=baho_t)

g = torch.Generator().manual_seed(42)
o_idx, v_idx = random_split(range(len(toliq)), [54000, 6000], generator=g)
oquv  = torch.utils.data.Subset(toliq,   list(o_idx))
valid = torch.utils.data.Subset(toliq_v, list(v_idx))

def blok(kir, chiq):
    return nn.Sequential(
        nn.Conv2d(kir, chiq, 3, padding=1), nn.BatchNorm2d(chiq), nn.ReLU(),
        nn.Conv2d(chiq, chiq, 3, padding=1), nn.BatchNorm2d(chiq), nn.ReLU(),
        nn.MaxPool2d(2))

class YaxshiCNN(nn.Module):
    def __init__(self, sinf=10):
        super().__init__()
        self.xususiyat = nn.Sequential(blok(1, 32), blok(32, 64))
        self.tasnif = nn.Sequential(
            nn.Flatten(), nn.Dropout(0.3),
            nn.Linear(64 * 7 * 7, 128), nn.ReLU(),
            nn.Dropout(0.3), nn.Linear(128, sinf))

    def forward(self, x):
        return self.tasnif(self.xususiyat(x))

kriteriya = nn.CrossEntropyLoss()
opt = torch.optim.AdamW(model.parameters(), lr=0.001, weight_decay=0.01)
DAVRLAR = 15
rejalash = torch.optim.lr_scheduler.CosineAnnealingLR(opt, T_max=DAVRLAR)

@torch.no_grad()
def baholash(dl):
    model.eval(); j = t = 0; yo = 0.0
    for xb, yb in dl:
        xb, yb = xb.to(QURILMA), yb.to(QURILMA)
        o = model(xb); yo += kriteriya(o, yb).item() * len(yb)
        t += (o.argmax(1) == yb).sum().item(); j += len(yb)
    return yo / j, t / j

eng_yaxshi, eng_davr, sabr, kutildi = float('inf'), 0, 4, 0

for davr in range(1, DAVRLAR + 1):
    model.train(); s = 0.0; n = 0
    for xb, yb in o_dl:
        xb, yb = xb.to(QURILMA), yb.to(QURILMA)
        opt.zero_grad()
        l = kriteriya(model(xb), yb)
        l.backward(); opt.step()
        s += l.item() * len(yb); n += len(yb)

    vy, va = baholash(v_dl)
    rejalash.step()

    if vy < eng_yaxshi:
        eng_yaxshi, eng_davr, kutildi = vy, davr, 0
        torch.save({"model": model.state_dict(), "davr": davr,
                    "ortacha": ORTACHA, "ogish": OGISH,
                    "sinflar": SINFLAR}, "yakuniy.pt")
    else:
        kutildi += 1
        if kutildi >= sabr:
            print(f"erta to'xtatildi ({davr}-davr)")
            break

nz = torch.load("yakuniy.pt", weights_only=False)
model.load_state_dict(nz["model"])
ty, ta = baholash(t_dl)
print(f"TEST: yo'qotish={ty:.4f}  aniqlik={ta:.2%}")