22.2-dars: Konvolyutsiya

KIRISH x: (H, W),  YADRO k: (kh, kw)

chiqish[i, j] = SUM_{a, b} x[i + a, j + b] * k[a, b]
                a = 0..kh-1, b = 0..kw-1

QADAMLAR:
  1. yadroni chap-yuqori burchakka qo'yish
  2. ostidagi oyna bilan elementma-element ko'paytirish
  3. yig'indini chiqishga yozish
  4. bir qadam o'ngga siljish; qator tugasa - pastga

MISOL (3x3 yadro, 5x5 kirish, padding yo'q):
  chiqish 3x3 - yadro faqat 3 x 3 = 9 joyga to'liq sig'adi

BITTA CHIQISH = oyna va yadroning SKALYAR KO'PAYTMASI
  -> oyna yadroga "o'xshasa", javob katta
  -> yadro - naqsh shabloni

XIRALASHTIRISH (yig'indi = 1, yorqinlik saqlanadi):
  o'rtacha 3x3:  1/9 * [[1,1,1],[1,1,1],[1,1,1]]
  Gauss 3x3:     1/16 * [[1,2,1],[2,4,2],[1,2,1]]
  -> shovqin kamayadi, chegaralar yumshaydi

KESKINLASHTIRISH (yig'indi = 1):
  [[0,-1,0],[-1,5,-1],[0,-1,0]]  = aynan + (aynan - xira)

CHEGARA (yig'indi = 0, tekis joyda javob 0):
  Laplas:   [[0,1,0],[1,-4,1],[0,1,0]]          - hamma yo'nalish
  Sobel x:  [[-1,0,1],[-2,0,2],[-1,0,1]]        - vertikal chegara
  Sobel y:  [[-1,-2,-1],[0,0,0],[1,2,1]]        - gorizontal chegara
  kattalik: sqrt(gx^2 + gy^2)

YIG'INDI QOIDASI:
  yig'indi 1 -> tekis joy o'zgarmaydi
  yig'indi 0 -> tekis joy 0 ga aylanadi, faqat O'ZGARISH qoladi

SHOVQIN: chegara yadrolari shovqinni kuchaytiradi
  -> avval xiralashtirish, keyin chegara (Canny g'oyasi)

MUAMMO: padding siz har qatlamda rasm kichrayadi
  28 -> 26 -> 24 -> ...   (3x3 yadro)
  va chekka piksellar kamroq "ko'riladi"

PADDING p: chetga p qator/ustun qo'shish
  p = (k - 1) / 2  (toq k) -> o'lcham saqlanadi ("same")
  k=3 -> p=1, k=5 -> p=2, k=7 -> p=3

TURLARI (F.pad mode=...):
  constant (0)  - eng keng tarqalgan, chegara qorayadi
  reflect       - ko'zgu: [3 2 | 1 2 3 | 2 1]
  replicate     - chetini takrorlash: [1 1 | 1 2 3 | 3 3]
  circular      - aylanma: [2 3 | 1 2 3 | 1 2]

nn.Conv2d(..., padding=1, padding_mode="zeros"/"reflect"/...)
padding="same" - faqat stride=1 da

STRIDE s: oyna har safar s piksel siljiydi
  s = 2 -> chiqish taxminan 2 barobar kichik (har o'qda)

FORMULA (har o'q uchun alohida):
  H_chiq = floor((H + 2p - k) / s) + 1

MISOLLAR:
  H=28, k=3, p=1, s=1 -> 28          (same)
  H=28, k=3, p=1, s=2 -> 14
  H=27, k=3, p=1, s=2 -> 14
  H=8,  k=3, p=0, s=2 -> 3           (floor(2.5) + 1)

FLOOR NIMANI ANGLATADI:
  kasr chiqsa, oxirgi to'liq sig'maydigan oyna TASHLANADI
  -> oxirgi qator/ustun hech qachon ko'rilmasligi mumkin

DILATION d: yadro elementlari orasida d-1 bo'shliq
  samarali yadro: k_eff = d * (k - 1) + 1
  formulada k o'rniga k_eff

MATEMATIK KONVOLYUTSIYA:
  (x * k)[i, j] = SUM x[i - a, j - b] * k[a, b]
  -> yadro 180 gradusga BURILADI

CROSS-CORRELATION:
  (x . k)[i, j] = SUM x[i + a, j + b] * k[a, b]
  -> yadro burilmaydi

torch.nn.functional.conv2d, nn.Conv2d  -> CROSS-CORRELATION
scipy.signal.correlate2d               -> cross-correlation
scipy.signal.convolve2d                -> haqiqiy konvolyutsiya

conv(x, k) = corr(x, flip(k))

NEGA FARQ MUHIM EMAS (tarmoqda):
  yadro o'rgatiladi -> tarmoq kerak bo'lsa burilgan yadroni o'rganadi
  simmetrik yadroda (Gauss) ikkalasi bir xil

QACHON MUHIM:
  qo'lda yozilgan yadroni kutubxonalar orasida ko'chirganda
  signal ishlashda (scipy) va tarmoqda (torch) natija taqqoslanganda

CHIZIQLILIK:
  conv(a*x + b*y, k) = a*conv(x, k) + b*conv(y, k)
  conv(x, k1) + conv(x, k2) = conv(x, k1 + k2)

KETMA-KET:
  conv(conv(x, k1), k2) = conv(x, conv(k1, k2))    (katta yadro)
  -> nochiziqliksiz ikki qatlam = bitta qatlam
  -> shuning uchun qatlamlar orasida ReLU (20-qism)

im2col (unfold):
  har oynani ustun qilib yoyish: (N, C*k*k, L)   L - joylar soni
  og'irlik: (out, C*k*k)
  chiqish = W @ ustunlar -> (N, out, L) -> (N, out, H_chiq, W_chiq)

  -> konvolyutsiya = MATRITSA KO'PAYTMASI
  -> GPU/BLAS da tez, lekin xotira k*k marta ko'p

import numpy as np
import torch
import torch.nn.functional as F


def chiqish_olchami(h, k, p=0, s=1, d=1):
    return (h + 2 * p - d * (k - 1) - 1) // s + 1


def conv2d_qolda(x, k, padding=0, stride=1):
    """(H, W) x (kh, kw) - cross-correlation, torch kabi."""
    x = np.pad(x, padding)
    kh, kw = k.shape
    h = (x.shape[0] - kh) // stride + 1
    w = (x.shape[1] - kw) // stride + 1
    return np.array([[np.sum(x[i * stride:i * stride + kh,
                                j * stride:j * stride + kw] * k)
                      for j in range(w)] for i in range(h)])


SOBEL_X = torch.tensor([[-1., 0, 1], [-2, 0, 2], [-1, 0, 1]])
GAUSS = torch.tensor([[1., 2, 1], [2, 4, 2], [1, 2, 1]]) / 16

x = torch.rand(1, 1, 28, 28)                           # (N, C, H, W)
gx = F.conv2d(x, SOBEL_X.view(1, 1, 3, 3), padding=1)  # (1, 1, 28, 28)

chiqish[i, j] = sum(oyna * yadro)    - cross-correlation (torch)
H_chiq = floor((H + 2p - k) / s) + 1
same: p = (k - 1) / 2, faqat stride=1
yig'indi 1 -> silliqlash, yig'indi 0 -> chegara
conv = corr(flip(k)); o'rgatishda farq yo'q
conv - chiziqli: qatlamlar orasida ReLU shart

"""Konvolyutsiya qo'lda (sirpanuvchi oyna) va torch bilan aynan solishtirish."""

import numpy as np
import torch
import torch.nn.functional as F


def conv2d_qolda(x, k, padding=0, stride=1):
    """x: (H, W), k: (kh, kw). Aslida cross-correlation - torch kabi."""
    if padding:
        x = np.pad(x, padding)
    kh, kw = k.shape
    h_ch = (x.shape[0] - kh) // stride + 1
    w_ch = (x.shape[1] - kw) // stride + 1
    chiqish = np.zeros((h_ch, w_ch), dtype=np.float64)
    for i in range(h_ch):
        for j in range(w_ch):
            oyna = x[i * stride:i * stride + kh, j * stride:j * stride + kw]
            chiqish[i, j] = np.sum(oyna * k)
    return chiqish


def jadval(m, fmt="{:>5.0f}"):
    for qator in m:
        print("    " + " ".join(fmt.format(v + 0.0) for v in qator))


def main() -> None:
    x = np.array([[1, 2, 0, 3, 1],
                  [0, 1, 3, 1, 2],
                  [2, 1, 0, 2, 0],
                  [1, 3, 2, 1, 1],
                  [0, 2, 1, 0, 3]], dtype=np.float64)
    k = np.array([[1, 0, -1],
                  [2, 0, -2],
                  [1, 0, -1]], dtype=np.float64)

    print("=== 1. Kirish (5x5) va yadro (3x3) ===")
    jadval(x)
    print("  yadro:")
    jadval(k)

    print("\n=== 2. Bitta oyna qadam-baqadam (chiqish[0, 0]) ===")
    oyna = x[0:3, 0:3]
    kopaytma = oyna * k
    print("  oyna * yadro (elementma-element):")
    jadval(kopaytma)
    print(f"  yig'indi: {kopaytma.sum():.0f}")

    print("\n=== 3. To'liq chiqish (padding=0, stride=1) ===")
    y = conv2d_qolda(x, k)
    print(f"  shakl: {y.shape}  (5 - 3 + 1 = 3)")
    jadval(y)

    print("\n=== 4. torch.nn.functional.conv2d bilan solishtirish ===")
    xt = torch.tensor(x).view(1, 1, 5, 5)
    kt = torch.tensor(k).view(1, 1, 3, 3)
    print(f"  F.conv2d kirish (N,C,H,W): {tuple(xt.shape)}, "
          f"og'irlik (out,in,kh,kw): {tuple(kt.shape)}")
    for p, s in [(0, 1), (1, 1), (1, 2), (2, 3)]:
        qolda = conv2d_qolda(x, k, padding=p, stride=s)
        tt = F.conv2d(xt, kt, padding=p, stride=s)[0, 0].numpy()
        print(f"  padding={p}, stride={s}: shakl {qolda.shape}, "
              f"aynan teng: {np.array_equal(qolda, tt)}, "
              f"maks farq {np.abs(qolda - tt).max():.1e}")

    print("\n=== 5. float32 da ===")
    rng = np.random.default_rng(0)
    katta = rng.normal(0, 1, (32, 32))
    yadro = rng.normal(0, 1, (5, 5))
    q = conv2d_qolda(katta, yadro, padding=2)
    t32 = F.conv2d(torch.tensor(katta, dtype=torch.float32).view(1, 1, 32, 32),
                   torch.tensor(yadro, dtype=torch.float32).view(1, 1, 5, 5),
                   padding=2)[0, 0].numpy()
    farq = np.abs(q - t32).max()
    print(f"  32x32, yadro 5x5: maks farq {farq:.1e}")
    print(f"  np.allclose(atol=1e-5): {np.allclose(q, t32, atol=1e-5)}")
    print("  float32 yaxlitlash - farq faqat oxirgi raqamlarda")

    print("\n=== 6. Hisob hajmi ===")
    h, w, kk = 224, 224, 3
    amallar = h * w * kk * kk
    print(f"  224x224 rasm, 3x3 yadro, padding=1: {amallar:,} ko'paytirish")
    print(f"  64 kirish va 64 chiqish kanal bilan: "
          f"{amallar * 64 * 64:,}")
    print("  ⭐ Konvolyutsiya = har joyda bir xil yadro bilan skalyar ko'paytma")


if __name__ == "__main__":
    main()

=== 1. Kirish (5x5) va yadro (3x3) ===
        1     2     0     3     1
        0     1     3     1     2
        2     1     0     2     0
        1     3     2     1     1
        0     2     1     0     3
  yadro:
        1     0    -1
        2     0    -2
        1     0    -1

=== 2. Bitta oyna qadam-baqadam (chiqish[0, 0]) ===
  oyna * yadro (elementma-element):
        1     0     0
        0     0    -6
        2     0     0
  yig'indi: -3

=== 3. To'liq chiqish (padding=0, stride=1) ===
  shakl: (3, 3)  (5 - 3 + 1 = 3)
       -3    -2     1
        0     0     2
       -1     5     0

=== 4. torch.nn.functional.conv2d bilan solishtirish ===
  F.conv2d kirish (N,C,H,W): (1, 1, 5, 5), og'irlik (out,in,kh,kw): (1, 1, 3, 3)
  padding=0, stride=1: shakl (3, 3), aynan teng: True, maks farq 0.0e+00
  padding=1, stride=1: shakl (5, 5), aynan teng: True, maks farq 0.0e+00
  padding=1, stride=2: shakl (3, 3), aynan teng: True, maks farq 0.0e+00
  padding=2, stride=3: shakl (3, 3), aynan teng: True, maks farq 0.0e+00

=== 5. float32 da ===
  32x32, yadro 5x5: maks farq 1.8e-06
  np.allclose(atol=1e-5): True
  float32 yaxlitlash - farq faqat oxirgi raqamlarda

=== 6. Hisob hajmi ===
  224x224 rasm, 3x3 yadro, padding=1: 451,584 ko'paytirish
  64 kirish va 64 chiqish kanal bilan: 1,849,688,064
  ⭐ Konvolyutsiya = har joyda bir xil yadro bilan skalyar ko'paytma

"""Klassik yadrolar: xiralashtirish, chegara, Sobel (real torch)."""

import numpy as np
import torch
import torch.nn.functional as F
from sklearn.datasets import load_digits

YADROLAR = {
    "aynan": [[0, 0, 0], [0, 1, 0], [0, 0, 0]],
    "o'rtacha 3x3": [[1 / 9] * 3] * 3,
    "Gauss 3x3": [[1 / 16, 2 / 16, 1 / 16], [2 / 16, 4 / 16, 2 / 16],
                  [1 / 16, 2 / 16, 1 / 16]],
    "keskinlash": [[0, -1, 0], [-1, 5, -1], [0, -1, 0]],
    "Laplas": [[0, 1, 0], [1, -4, 1], [0, 1, 0]],
    "Sobel x": [[-1, 0, 1], [-2, 0, 2], [-1, 0, 1]],
    "Sobel y": [[-1, -2, -1], [0, 0, 0], [1, 2, 1]],
}


def qolla(rasm, yadro):
    x = rasm.view(1, 1, *rasm.shape)
    k = torch.tensor(yadro, dtype=torch.float32).view(1, 1, 3, 3)
    return F.conv2d(x, k, padding=1)[0, 0]


def ascii_chiz(m):
    for qator in m:
        s = ""
        for v in qator:
            s += " +" if v > 0.5 else (" -" if v < -0.5 else " .")
        print("   " + s)


def main() -> None:
    rng = np.random.default_rng(0)
    toza = torch.zeros(14, 14)
    toza[5:10, 4:11] = 1.0
    shovqin = torch.tensor(rng.normal(0, 0.2, (14, 14)), dtype=torch.float32)
    rasm = toza + shovqin
    tekis = (slice(1, 4), slice(1, 13))      # kvadratdan uzoq fon

    print("=== 1. Yadro yig'indisi nimani anglatadi ===")
    print(f"  {'yadro':<14} {'yig_indi':>9} {'tekis fonda':>12} "
          f"{'kvadrat ichida':>15}")
    for nom, k in YADROLAR.items():
        y = qolla(toza, k)
        print(f"  {nom:<14} {np.sum(k):>9.2f} {y[tekis].abs().mean():>12.3f} "
              f"{y[6:9, 6:9].mean():>15.3f}")
    print("  yig'indi 1 - yorqinlik saqlanadi; yig'indi 0 - tekis joyda 0")

    print("\n=== 2. Xiralashtirish shovqinni kamaytiradi ===")
    print(f"  shovqinli rasmda fon std: {rasm[tekis].std():.3f}")
    for nom in ["o'rtacha 3x3", "Gauss 3x3"]:
        y = qolla(rasm, YADROLAR[nom])
        print(f"  {nom:<13} dan keyin fon std: {y[tekis].std():.3f}")
    print(f"  nazariy (o'rtacha 3x3, mustaqil shovqin): 0.2 / 3 = "
          f"{0.2 / 3:.3f}")

    print("\n=== 3. Sobel x - vertikal chegaralar (toza kvadrat) ===")
    gx = qolla(toza, YADROLAR["Sobel x"])
    ascii_chiz(gx.numpy())
    print("  + : chapdan o'ngga yorqinlashadi, - : qorayadi")

    print("\n=== 4. Sobel y - gorizontal chegaralar ===")
    gy = qolla(toza, YADROLAR["Sobel y"])
    ascii_chiz(gy.numpy())
    print("  + : yuqoridan pastga yorqinlashadi, - : qorayadi")

    print("\n=== 5. Gradient kattaligi va shovqin ===")
    mag = torch.sqrt(gx ** 2 + gy ** 2)
    chegara = mag > 1.0
    print(f"  toza rasm: chegara piksellari {int(chegara.sum())}, "
          f"maks kattalik {mag.max():.2f}")
    for nom, kirish in [("shovqinli", rasm),
                        ("avval Gauss", qolla(rasm, YADROLAR["Gauss 3x3"]))]:
        m = torch.sqrt(qolla(kirish, YADROLAR["Sobel x"]) ** 2
                       + qolla(kirish, YADROLAR["Sobel y"]) ** 2)
        topildi = m > 1.0
        togri = int((topildi & chegara).sum())
        yolgon = int((topildi & ~chegara).sum())
        print(f"  {nom:<12} to'g'ri topilgan {togri:>3}, "
              f"yolg'on chegara {yolgon:>3}")

    print("\n=== 6. Raqam rasmida (load_digits) ===")
    raqam = torch.tensor(load_digits().images[0], dtype=torch.float32) / 16
    for nom in ["Sobel x", "Laplas"]:
        y = qolla(raqam, YADROLAR[nom])
        print(f"  {nom:<8}: min {y.min():.2f}, max {y.max():.2f}, "
              f"|y| > 0.5 bo'lgan piksellar {int((y.abs() > 0.5).sum())}/64")
    print("  ⭐ Yadro - naqsh detektori: yadroga o'xshash joyda javob katta")


if __name__ == "__main__":
    main()

=== 1. Yadro yig'indisi nimani anglatadi ===
  yadro           yig_indi  tekis fonda  kvadrat ichida
  aynan               1.00        0.000           1.000
  o'rtacha 3x3        1.00        0.000           1.000
  Gauss 3x3           1.00        0.000           1.000
  keskinlash          1.00        0.000           1.000
  Laplas              0.00        0.000           0.000
  Sobel x             0.00        0.000           0.000
  Sobel y             0.00        0.000           0.000
  yig'indi 1 - yorqinlik saqlanadi; yig'indi 0 - tekis joyda 0

=== 2. Xiralashtirish shovqinni kamaytiradi ===
  shovqinli rasmda fon std: 0.174
  o'rtacha 3x3  dan keyin fon std: 0.068
  Gauss 3x3     dan keyin fon std: 0.080
  nazariy (o'rtacha 3x3, mustaqil shovqin): 0.2 / 3 = 0.067

=== 3. Sobel x - vertikal chegaralar (toza kvadrat) ===
    . . . . . . . . . . . . . .
    . . . . . . . . . . . . . .
    . . . . . . . . . . . . . .
    . . . . . . . . . . . . . .
    . . . + + . . . . . - - . .
    . . . + + . . . . . - - . .
    . . . + + . . . . . - - . .
    . . . + + . . . . . - - . .
    . . . + + . . . . . - - . .
    . . . + + . . . . . - - . .
    . . . + + . . . . . - - . .
    . . . . . . . . . . . . . .
    . . . . . . . . . . . . . .
    . . . . . . . . . . . . . .
  + : chapdan o'ngga yorqinlashadi, - : qorayadi

=== 4. Sobel y - gorizontal chegaralar ===
    . . . . . . . . . . . . . .
    . . . . . . . . . . . . . .
    . . . . . . . . . . . . . .
    . . . . . . . . . . . . . .
    . . . + + + + + + + + + . .
    . . . + + + + + + + + + . .
    . . . . . . . . . . . . . .
    . . . . . . . . . . . . . .
    . . . . . . . . . . . . . .
    . . . - - - - - - - - - . .
    . . . - - - - - - - - - . .
    . . . . . . . . . . . . . .
    . . . . . . . . . . . . . .
    . . . . . . . . . . . . . .
  + : yuqoridan pastga yorqinlashadi, - : qorayadi

=== 5. Gradient kattaligi va shovqin ===
  toza rasm: chegara piksellari 48, maks kattalik 4.24
  shovqinli    to'g'ri topilgan  47, yolg'on chegara  45
  avval Gauss  to'g'ri topilgan  48, yolg'on chegara  21

=== 6. Raqam rasmida (load_digits) ===
  Sobel x : min -2.94, max 3.44, |y| > 0.5 bo'lgan piksellar 54/64
  Laplas  : min -2.06, max 1.44, |y| > 0.5 bo'lgan piksellar 27/64
  ⭐ Yadro - naqsh detektori: yadroga o'xshash joyda javob katta

"""Padding, stride va chiqish o'lchami formulasi (real torch)."""

import torch
import torch.nn.functional as F


def formula(h, k, p, s, d=1):
    k_eff = d * (k - 1) + 1
    return (h + 2 * p - k_eff) // s + 1


def main() -> None:
    torch.manual_seed(0)

    print("=== 1. Formula va haqiqiy shakl ===")
    print(f"  {'H':>4} {'k':>3} {'p':>3} {'s':>3} {'(H+2p-k)/s+1':>14} "
          f"{'formula':>8} {'torch':>6}")
    holatlar = [(28, 3, 0, 1), (28, 3, 1, 1), (28, 5, 2, 1), (28, 3, 1, 2),
                (27, 3, 1, 2), (32, 7, 3, 2), (8, 3, 0, 2), (224, 11, 2, 4)]
    hammasi = True
    for h, k, p, s in holatlar:
        x = torch.zeros(1, 1, h, h)
        w = torch.zeros(1, 1, k, k)
        haqiqiy = F.conv2d(x, w, padding=p, stride=s).shape[-1]
        kasr = (h + 2 * p - k) / s + 1
        f = formula(h, k, p, s)
        hammasi &= f == haqiqiy
        print(f"  {h:>4} {k:>3} {p:>3} {s:>3} {kasr:>14.2f} {f:>8} "
              f"{haqiqiy:>6}")
    print(f"  formula (pastga yaxlitlab) hamma holatda to'g'ri: {hammasi}")

    print("\n=== 2. 'same' padding ===")
    for k in [3, 5, 7]:
        p = (k - 1) // 2
        print(f"  k={k}: p=(k-1)/2={p} -> 32 dan {formula(32, k, p, 1)}")
    y = F.conv2d(torch.zeros(1, 1, 32, 32), torch.zeros(1, 1, 5, 5),
                 padding="same")
    print(f"  padding='same', k=5: {tuple(y.shape)}")
    try:
        F.conv2d(torch.zeros(1, 1, 32, 32), torch.zeros(1, 1, 3, 3),
                 padding="same", stride=2)
        print("  'same' + stride=2 ishladi (kutilmagan)")
    except (RuntimeError, ValueError) as xato:
        print(f"  'same' + stride=2: {type(xato).__name__} - "
              f"{str(xato)[:43]}")

    print("\n=== 3. Yaxlitlash: qaysi piksellar e'tiborsiz qoladi ===")
    for h, k, p, s in [(8, 3, 0, 2), (9, 3, 0, 2), (8, 3, 1, 2)]:
        x = torch.ones(1, 1, h, h, requires_grad=True)
        w = torch.ones(1, 1, k, k)
        F.conv2d(x, w, padding=p, stride=s).sum().backward()
        g = x.grad[0, 0]
        korilmagan = int((g == 0).sum())
        qatorlar = (g == 0).all(dim=1).nonzero().flatten().tolist()
        ustunlar = (g == 0).all(dim=0).nonzero().flatten().tolist()
        print(f"  H={h}, k={k}, p={p}, s={s}: chiqish {formula(h, k, p, s)}, "
              f"ko'rilmagan piksellar {korilmagan}, qatorlar {qatorlar}, "
              f"ustunlar {ustunlar}")

    print("\n=== 4. Padding turi: chegaradagi qiymat ===")
    x = torch.ones(1, 1, 6, 6)
    k = torch.full((1, 1, 3, 3), 1 / 9)
    print("  kirish hammasi 1, yadro - o'rtacha 3x3")
    print(f"  {'rejim':<10} {'burchak':>8} {'chekka':>7} {'markaz':>7}")
    for rejim in ["constant", "reflect", "replicate", "circular"]:
        xp = F.pad(x, (1, 1, 1, 1), mode=rejim)
        y = F.conv2d(xp, k)[0, 0]
        print(f"  {rejim:<10} {y[0, 0]:>8.3f} {y[0, 3]:>7.3f} "
              f"{y[3, 3]:>7.3f}")
    print("  nol padding chegarani qoraytiradi (burchak 4/9, chekka 6/9)")

    print("\n=== 5. Dilation - kengaytirilgan yadro ===")
    for d in [1, 2, 3]:
        y = F.conv2d(torch.zeros(1, 1, 32, 32), torch.zeros(1, 1, 3, 3),
                     dilation=d)
        print(f"  k=3, dilation={d}: samarali yadro {d * 2 + 1}x{d * 2 + 1}, "
              f"chiqish {y.shape[-1]} (formula {formula(32, 3, 0, 1, d)})")

    print("\n=== 6. O'lchamlar zanjiri ===")
    x = torch.zeros(1, 3, 64, 64)
    print(f"  kirish: {tuple(x.shape)}")
    for i, (k, p, s) in enumerate([(3, 1, 1), (3, 1, 2), (3, 1, 2),
                                   (3, 0, 1), (3, 1, 2)], 1):
        x = F.conv2d(x, torch.zeros(3, 3, k, k), padding=p, stride=s)
        print(f"  {i}-qadam k={k}, p={p}, s={s}: {tuple(x.shape)}")
    print("  ⭐ Chiqish = floor((H + 2p - k) / s) + 1")


if __name__ == "__main__":
    main()

=== 1. Formula va haqiqiy shakl ===
     H   k   p   s   (H+2p-k)/s+1  formula  torch
    28   3   0   1          26.00       26     26
    28   3   1   1          28.00       28     28
    28   5   2   1          28.00       28     28
    28   3   1   2          14.50       14     14
    27   3   1   2          14.00       14     14
    32   7   3   2          16.50       16     16
     8   3   0   2           3.50        3      3
   224  11   2   4          55.25       55     55
  formula (pastga yaxlitlab) hamma holatda to'g'ri: True

=== 2. 'same' padding ===
  k=3: p=(k-1)/2=1 -> 32 dan 32
  k=5: p=(k-1)/2=2 -> 32 dan 32
  k=7: p=(k-1)/2=3 -> 32 dan 32
  padding='same', k=5: (1, 1, 32, 32)
  'same' + stride=2: RuntimeError - padding='same' is not supported for strided

=== 3. Yaxlitlash: qaysi piksellar e'tiborsiz qoladi ===
  H=8, k=3, p=0, s=2: chiqish 3, ko'rilmagan piksellar 15, qatorlar [7], ustunlar [7]
  H=9, k=3, p=0, s=2: chiqish 4, ko'rilmagan piksellar 0, qatorlar [], ustunlar []
  H=8, k=3, p=1, s=2: chiqish 4, ko'rilmagan piksellar 0, qatorlar [], ustunlar []

=== 4. Padding turi: chegaradagi qiymat ===
  kirish hammasi 1, yadro - o'rtacha 3x3
  rejim       burchak  chekka  markaz
  constant      0.444   0.667   1.000
  reflect       1.000   1.000   1.000
  replicate     1.000   1.000   1.000
  circular      1.000   1.000   1.000
  nol padding chegarani qoraytiradi (burchak 4/9, chekka 6/9)

=== 5. Dilation - kengaytirilgan yadro ===
  k=3, dilation=1: samarali yadro 3x3, chiqish 30 (formula 30)
  k=3, dilation=2: samarali yadro 5x5, chiqish 28 (formula 28)
  k=3, dilation=3: samarali yadro 7x7, chiqish 26 (formula 26)

=== 6. O'lchamlar zanjiri ===
  kirish: (1, 3, 64, 64)
  1-qadam k=3, p=1, s=1: (1, 3, 64, 64)
  2-qadam k=3, p=1, s=2: (1, 3, 32, 32)
  3-qadam k=3, p=1, s=2: (1, 3, 16, 16)
  4-qadam k=3, p=0, s=1: (1, 3, 14, 14)
  5-qadam k=3, p=1, s=2: (1, 3, 7, 7)
  ⭐ Chiqish = floor((H + 2p - k) / s) + 1

"""Cross-correlation va konvolyutsiya, chiziqlilik, im2col (real torch/scipy)."""

import numpy as np
import torch
import torch.nn.functional as F
from scipy import signal


def main() -> None:
    rng = np.random.default_rng(0)
    x = rng.integers(0, 5, (6, 6)).astype(np.float64)
    k = np.array([[1, 2, 0],
                  [0, 1, 0],
                  [0, 0, -1]], dtype=np.float64)   # nosimmetrik
    xt = torch.tensor(x).view(1, 1, 6, 6)

    def torch_conv(yadro):
        return F.conv2d(xt, torch.tensor(yadro).view(1, 1, 3, 3))[0, 0].numpy()

    print("=== 1. torch nimani hisoblaydi ===")
    tt = torch_conv(k)
    korr = signal.correlate2d(x, k, mode="valid")
    konv = signal.convolve2d(x, k, mode="valid")
    print(f"  F.conv2d == scipy correlate2d: {np.array_equal(tt, korr)}")
    print(f"  F.conv2d == scipy convolve2d:  {np.array_equal(tt, konv)}")
    print("  torch 'conv2d' aslida CROSS-CORRELATION hisoblaydi")

    print("\n=== 2. Farq - yadroni 180 gradusga burish ===")
    burilgan = np.flip(k)
    print("  burilgan yadro:")
    for qator in burilgan:
        print("    " + " ".join(f"{v:>4.0f}" for v in qator))
    print(f"  convolve2d(x, k) == correlate2d(x, flip(k)): "
          f"{np.array_equal(konv, signal.correlate2d(x, burilgan, 'valid'))}")
    print(f"  F.conv2d(x, flip(k)) == convolve2d(x, k): "
          f"{np.array_equal(torch_conv(burilgan.copy()), konv)}")

    print("\n=== 3. Simmetrik yadroda farq yo'q ===")
    gauss = np.array([[1, 2, 1], [2, 4, 2], [1, 2, 1]]) / 16
    print(f"  Gauss: correlate == convolve: "
          f"{np.allclose(signal.correlate2d(x, gauss, 'valid'), signal.convolve2d(x, gauss, 'valid'))}")
    sobel = np.array([[-1, 0, 1], [-2, 0, 2], [-1, 0, 1]], dtype=float)
    a = signal.correlate2d(x, sobel, "valid")
    b = signal.convolve2d(x, sobel, "valid")
    print(f"  Sobel x: convolve == -correlate: {np.array_equal(b, -a)}")
    print("  o'rgatiladigan yadroda farq muhim emas - tarmoq burilgan")
    print("  versiyani o'rganadi")

    print("\n=== 4. Chiziqlilik ===")
    x2 = rng.normal(0, 1, (6, 6))
    chap = signal.correlate2d(2 * x + 3 * x2, k, "valid")
    ong = (2 * signal.correlate2d(x, k, "valid")
           + 3 * signal.correlate2d(x2, k, "valid"))
    print(f"  conv(2a + 3b) == 2 conv(a) + 3 conv(b): {np.allclose(chap, ong)}")
    ikki = (signal.correlate2d(x, k, "valid")
            + signal.correlate2d(x, sobel, "valid"))
    birga = signal.correlate2d(x, k + sobel, "valid")
    print(f"  conv(x, k1) + conv(x, k2) == conv(x, k1 + k2): "
          f"{np.allclose(ikki, birga)}")

    print("\n=== 5. Ketma-ket ikki yadro = bitta katta yadro ===")
    katta = rng.normal(0, 1, (12, 12))
    ketma = signal.convolve2d(signal.convolve2d(katta, gauss, "valid"),
                              sobel, "valid")
    birlashgan = signal.convolve2d(gauss, sobel)          # 5x5
    bir_marta = signal.convolve2d(katta, birlashgan, "valid")
    print(f"  birlashgan yadro shakli: {birlashgan.shape}")
    print(f"  Gauss keyin Sobel == bitta 5x5 yadro: "
          f"{np.allclose(ketma, bir_marta)}")
    print("  nochiziqlik (ReLU) bo'lmasa, qatlamlar bitta qatlamga qisqaradi")

    print("\n=== 6. im2col: konvolyutsiya = matritsa ko'paytmasi ===")
    torch.manual_seed(0)
    xb = torch.randn(2, 3, 8, 8)
    w = torch.randn(4, 3, 3, 3)
    ustunlar = F.unfold(xb, kernel_size=3, padding=1)      # (N, C*k*k, L)
    print(f"  unfold shakli: {tuple(ustunlar.shape)}  "
          f"(N, C*k*k = {3 * 9}, joylar L = {8 * 8})")
    y_mat = (w.view(4, -1) @ ustunlar).view(2, 4, 8, 8)
    y_conv = F.conv2d(xb, w, padding=1)
    print(f"  matmul natijasi shakli: {tuple(y_mat.shape)}")
    print(f"  F.conv2d bilan maks farq: {(y_mat - y_conv).abs().max():.1e}")
    print(f"  allclose: {torch.allclose(y_mat, y_conv, atol=1e-5)}")
    print("  ⭐ Konvolyutsiya - og'irligi baham ko'rilgan chiziqli amal")


if __name__ == "__main__":
    main()

=== 1. torch nimani hisoblaydi ===
  F.conv2d == scipy correlate2d: True
  F.conv2d == scipy convolve2d:  False
  torch 'conv2d' aslida CROSS-CORRELATION hisoblaydi

=== 2. Farq - yadroni 180 gradusga burish ===
  burilgan yadro:
      -1    0    0
       0    1    0
       0    2    1
  convolve2d(x, k) == correlate2d(x, flip(k)): True
  F.conv2d(x, flip(k)) == convolve2d(x, k): True

=== 3. Simmetrik yadroda farq yo'q ===
  Gauss: correlate == convolve: True
  Sobel x: convolve == -correlate: True
  o'rgatiladigan yadroda farq muhim emas - tarmoq burilgan
  versiyani o'rganadi

=== 4. Chiziqlilik ===
  conv(2a + 3b) == 2 conv(a) + 3 conv(b): True
  conv(x, k1) + conv(x, k2) == conv(x, k1 + k2): True

=== 5. Ketma-ket ikki yadro = bitta katta yadro ===
  birlashgan yadro shakli: (5, 5)
  Gauss keyin Sobel == bitta 5x5 yadro: True
  nochiziqlik (ReLU) bo'lmasa, qatlamlar bitta qatlamga qisqaradi

=== 6. im2col: konvolyutsiya = matritsa ko'paytmasi ===
  unfold shakli: (2, 27, 64)  (N, C*k*k = 27, joylar L = 64)
  matmul natijasi shakli: (2, 4, 8, 8)
  F.conv2d bilan maks farq: 3.8e-06
  allclose: True
  ⭐ Konvolyutsiya - og'irligi baham ko'rilgan chiziqli amal

F.conv2d(torch.rand(28, 28), w)                         # ⚠️
F.conv2d(torch.rand(28, 28).view(1, 1, 28, 28), w)      # ✅ (N, C, H, W)

nn.Linear(32 * 13 * 13, 10)    # "27 // 2 = 13" deb taxmin      # ⚠️
chiqish_olchami(27, 3, 1, 2)   # -> 14, keyin Linear(32*14*14)  # ✅

F.conv2d(x, w, padding="same", stride=2)                # ⚠️ RuntimeError
F.conv2d(x, w, padding=1, stride=2)                     # ✅

nn.Conv2d(1, 8, kernel_size=4, padding=2)   # 28 -> 29   # ⚠️
nn.Conv2d(1, 8, kernel_size=3, padding=1)   # 28 -> 28   # ✅

signal.convolve2d(x, k, "valid") == F.conv2d(...)       # ⚠️ yadro burilgan
signal.correlate2d(x, k, "valid") == F.conv2d(...)      # ✅

g = F.conv2d(x, SOBEL_X, padding=1)                     # ⚠️
g = F.conv2d(F.conv2d(x, GAUSS, padding=1), SOBEL_X, padding=1)  # ✅

nn.Sequential(nn.Conv2d(1, 8, 3), nn.Conv2d(8, 8, 3))               # ⚠️
nn.Sequential(nn.Conv2d(1, 8, 3), nn.ReLU(), nn.Conv2d(8, 8, 3))    # ✅

1.  # 5x5 kirish, 3x3 yadro, p=0, s=1 - chiqish?
2.  # 28x28, k=5, p=2, s=1 - chiqish?
3.  # 32x32, k=3, p=1, s=2 - chiqish?
4.  # 27x27, k=3, p=0, s=2 - chiqish?
5.  # o'rtacha 3x3 yadroning yig'indisi?
6.  # Sobel x qanday chegarani topadi?
7.  # yig'indisi 0 yadro tekis joyda nima beradi?
8.  # nn.Conv2d konvolyutsiyami yoki cross-correlation?
9.  # k=7 uchun "same" padding?
10. # k=3, dilation=2 samarali yadro o'lchami?
11. # nol padding bilan hammasi 1 rasmni o'rtacha 3x3 bilan - burchak qiymati?
12. # unfold (N, C, 8, 8), k=3, p=1 shakli (C=3)?

1.  F.conv2d(torch.rand(28, 28), w)

2.  F.conv2d(x, w, padding="same", stride=2)

3.  nn.Conv2d(1, 8, kernel_size=4, padding=2)   # o'lcham saqlansin

4.  assert np.allclose(signal.convolve2d(x, k, "valid"), F.conv2d(xt, kt)[0, 0])

5.  nn.Sequential(nn.Conv2d(1, 8, 3), nn.Conv2d(8, 8, 3))