Rasm klassifikatsiyasi — to'liq o'qitish

import torch
from torchvision import datasets, transforms

ozgartirish = transforms.Compose([
    transforms.ToTensor(),                      # 0-255 -> 0.0-1.0, HWC -> CHW
    transforms.Normalize((0.1307,), (0.3081,)), # MNIST o'rtachasi va dispersiyasi
])

oqitish = datasets.MNIST("data", train=True, download=True,
                         transform=ozgartirish)
test = datasets.MNIST("data", train=False, transform=ozgartirish)

print("o'qitish:", len(oqitish))
print("test    :", len(test))

# parcha
transforms.Normalize((0.1307,), (0.3081,))

from torch.utils.data import DataLoader

oqitish_yuk = DataLoader(oqitish, batch_size=64, shuffle=True)
test_yuk = DataLoader(test, batch_size=1000)

rasmlar, javoblar = next(iter(oqitish_yuk))
print("partiya:", tuple(rasmlar.shape))
print("javoblar:", tuple(javoblar.shape))
print("qiymat oralig'i:", float(rasmlar.min()), float(rasmlar.max()))

import torch.nn as nn

class RaqamModel(nn.Module):
    def __init__(self):
        super().__init__()
        self.belgilar = nn.Sequential(
            nn.Conv2d(1, 32, 3, padding=1),   # 28x28
            nn.ReLU(),
            nn.MaxPool2d(2),                   # 14x14
            nn.Conv2d(32, 64, 3, padding=1),
            nn.ReLU(),
            nn.MaxPool2d(2),                   # 7x7
        )
        self.klassifikator = nn.Sequential(
            nn.Flatten(),
            nn.Linear(64 * 7 * 7, 128),
            nn.ReLU(),
            nn.Dropout(0.25),
            nn.Linear(128, 10),
        )

    def forward(self, x):
        return self.klassifikator(self.belgilar(x))


model = RaqamModel()
print("parametr:", sum(p.numel() for p in model.parameters()))

import torch.optim as optim

qurilma = torch.device("cuda" if torch.cuda.is_available() else "cpu")
model = model.to(qurilma)

yoqotish_f = nn.CrossEntropyLoss()
optimizator = optim.Adam(model.parameters(), lr=0.001)


def bir_epoch(model, yuk, qurilma, optimizator, yoqotish_f):
    model.train()                      # dropout YOQILADI
    jami_yoqotish = 0.0
    togri = 0
    jami = 0

    for rasmlar, javoblar in yuk:
        rasmlar = rasmlar.to(qurilma)
        javoblar = javoblar.to(qurilma)

        optimizator.zero_grad()        # eski gradientlarni tozalash
        chiqish = model(rasmlar)
        yoqotish = yoqotish_f(chiqish, javoblar)
        yoqotish.backward()            # gradientlarni hisoblash
        optimizator.step()             # vaznlarni yangilash

        jami_yoqotish += yoqotish.item() * rasmlar.size(0)
        togri += (chiqish.argmax(1) == javoblar).sum().item()
        jami += rasmlar.size(0)

    return jami_yoqotish / jami, togri / jami

zero_grad()  ->  backward()  ->  step()
tozalash        hisoblash       yangilash

@torch.no_grad()
def baho(model, yuk, qurilma):
    model.eval()                       # dropout O'CHADI
    togri = 0
    jami = 0
    for rasmlar, javoblar in yuk:
        rasmlar = rasmlar.to(qurilma)
        javoblar = javoblar.to(qurilma)
        chiqish = model(rasmlar)
        togri += (chiqish.argmax(1) == javoblar).sum().item()
        jami += javoblar.size(0)
    return togri / jami

# parcha — vaqt oladi, o'zingiz ishga tushiring
for epoch in range(1, 4):
    yoq, oqitish_aniq = bir_epoch(
        model, oqitish_yuk, qurilma, optimizator, yoqotish_f)
    test_aniq = baho(model, test_yuk, qurilma)
    print(f"epoch {epoch}: yo'qotish {yoq:.4f}  "
          f"o'qitish {oqitish_aniq:.4f}  test {test_aniq:.4f}")

parametr: 421642 | qurilma: cuda
epoch 1: yo'qotish 0.1597  o'qitish 0.9504  test 0.9831
epoch 2: yo'qotish 0.0551  o'qitish 0.9831  test 0.9875
epoch 3: yo'qotish 0.0391  o'qitish 0.9876  test 0.9891

import torch


@torch.no_grad()
def chalkashlik_matritsasi(model, yuk, qurilma, sinflar=10):
    """Qator = haqiqiy sinf, ustun = model bashorati."""
    model.eval()
    M = torch.zeros(sinflar, sinflar, dtype=torch.long)
    for rasmlar, javoblar in yuk:
        bashorat = model(rasmlar.to(qurilma)).argmax(1).cpu()
        for h, b in zip(javoblar, bashorat):
            M[h, b] += 1
    return M


def matritsani_chiqar(M):
    n = M.size(0)
    print("     " + "".join(f"{i:>6}" for i in range(n)))
    for i in range(n):
        qator = "".join(f"{int(M[i, j]):>6}" for j in range(n))
        print(f"  {i}: {qator}")


def eng_yomon_chalkashlik(M, nechta=5):
    """Diagonal EMAS eng katta qiymatlar — eng ko'p adashish."""
    n = M.size(0)
    juftlar = [(int(M[i, j]), i, j)
               for i in range(n) for j in range(n) if i != j]
    juftlar.sort(reverse=True)
    return juftlar[:nechta]

# parcha — o'qitilgan model kerak
M = chalkashlik_matritsasi(model, test_yuk, qurilma)
matritsani_chiqar(M)

print("\nEng ko'p adashish:")
for son, haqiqiy, bashorat in eng_yomon_chalkashlik(M):
    print(f"  {haqiqiy} -> {bashorat} deb o'qildi: {son} marta")

Eng ko'p adashish:
  9 -> 5 deb o'qildi: 8 marta
  5 -> 3 deb o'qildi: 7 marta
  9 -> 7 deb o'qildi: 6 marta
  9 -> 4 deb o'qildi: 6 marta
  6 -> 5 deb o'qildi: 6 marta

aniqlik: 0.9902 | eng yomon sinf: 9 (0.9782)

def sinf_boyicha_aniqlik(M):
    """Har bir sinf uchun alohida aniqlik."""
    natija = {}
    for i in range(M.size(0)):
        jami = int(M[i].sum())
        natija[i] = int(M[i, i]) / jami if jami else 0.0
    return natija

# parcha
torch.save(model.state_dict(), "raqam_model.pt")

yangi = RaqamModel()
yangi.load_state_dict(torch.load("raqam_model.pt"))
yangi.eval()