26.8-dars: Matn-rasm va multimodal modellar

UMUMIY QUVUR:
  matn ("kichik ko'k uchburchak")
    -> TOKENIZATOR -> MATN ENCODER (Transformer, 24-qism)
    -> matn embeddinglari (har token uchun vektor yoki bitta vektor)
    -> SHART sifatida generatorga
    -> GENERATOR (diffusion U-Net yoki Transformer; 26.5-26.6)
    -> (latent diffusion bo'lsa) VAE DEKODER -> rasm

SHART QANDAY BERILADI:
  1. qo'shish/konkatenatsiya: bitta matn vektori c -> h = h + W c
     (26.6-darsdagi sinf embeddingi kabi; 3-misoldagi VAE)
  2. CROSS-ATTENTION (24.3-dars): rasm xususiyatlari - so'rov (Q),
     matn tokenlari - kalit va qiymat (K, V)
       attention(Q = W_q h_rasm, K = W_k e_matn, V = W_v e_matn)
     har rasm joyi "qaysi so'zga qarash kerak"ni o'zi tanlaydi
  3. classifier-free guidance 26.6-bob: matn shartini 10-20% tashlab o'rgatish,
     samplingda eps_u + w * (eps_c - eps_u)

MATN ENCODERI QAYERDAN:
  oldindan o'rgatilgan CLIP matn encoderi yoki katta til modeli encoderi
  (odatda muzlatilgan); generator faqat uning chiqishini "o'qishni" o'rganadi

NEGA BITTA VEKTOR YETMAYDI:
  "chapda qizil doira, o'ngda ko'k kvadrat" - qaysi rang qaysi shaklga
  tegishli ekani so'zlar orasidagi munosabatda; bitta o'rtacha vektorda
  bu munosabat yo'qoladi (2-misol: so'zlar xaltasi tartibni ko'rmaydi)

CROSS-ATTENTION (24.3 dagi formula):
  Q = h_rasm W_q      (n_joy, d)       - rasmning har joyi
  K = e_matn W_k      (n_token, d)     - matn tokenlari
  V = e_matn W_v
  chiqish = softmax(Q K^T / sqrt(d)) V
  -> har joy o'ziga kerakli so'zlarni "o'qiydi"

DIFFUSION U-NET DA:
  har rezolyutsiya blokida: self-attention (rasm ichida) + cross-attention (matnga)
  attention xaritalari - qaysi so'z rasmning qaysi qismiga ta'sir qilgani
  (tahrirlash usullari shu xaritalarni boshqaradi)

G'OYA (Radford va boshq., 2021 - CLIP):
  ikki encoder: f_rasm(x) -> z_r, f_matn(t) -> z_t; ikkalasi ham normallangan
  maqsad: mos juftlik (x_i, t_i) yaqin, mos bo'lmagan (x_i, t_j) uzoq
  internetdan olingan juda ko'p rasm-matn juftliklarida o'rgatilgan

INFONCE (batchda B ta juftlik):
  S = tau * Z_r Z_t^T                   (B, B) o'xshashlik matritsasi
  tau = exp(log_harorat)                - o'rganiladigan harorat
  loss_r = CE(S, [0..B-1])              - har rasm uchun B ta matndan to'g'risi
  loss_t = CE(S^T, [0..B-1])            - har matn uchun B ta rasmdan to'g'risi
  loss = (loss_r + loss_t) / 2

  diagonal - musbat juftliklar, qolgan B-1 ta - manfiy
  tasodifiy boshlanishda loss ~ log B  (bizda log 128 = 4.852)

1-MISOL:
  loss 5.275 -> 2.001 (urug' 0), harorat 14.3 -> 19.3
  boshida log B dan yuqori: harorat tasodifiy o'xshashliklarni kuchaytiradi
  oxirida ~2: batchda bir kombinatsiyadan ~9 juftlik bor ->
  ular bir-biriga "soxta manfiy" -> pastki chegara ~ log 9 = 2.2 atrofida

BIZNING MODEL:
  rasm encoder: Conv(3->16) -> max-pool 4x4 -> 256 -> 64 -> 32
  matn encoder: so'z embeddinglari O'RTACHASI -> MLP -> 32  (so'zlar xaltasi)
  400 qadam, batch 128, 14 ta kombinatsiya, 6 ta tavsif shabloni

ZERO-SHOT:
  har sinf uchun matn: "katta qizil doira", ..., (18 ta)
  bashorat = argmax_k cos(f_rasm(x), f_matn(matn_k))
  klassifikatorni qayta o'rgatish YO'Q - yangi sinf = yangi matn

KOMPOZITSION TEST (bizning tajriba):
  o'quvda 14 kombinatsiya; 4 tasi hech qachon ko'rsatilmagan:
    ko'k katta uchburchak, qizil kichik kvadrat,
    qizil kichik uchburchak, yashil katta doira
  lekin har so'z (ko'k, katta, uchburchak ...) o'quvda boshqa kombinatsiyalarda bor

1-MISOL (3 urug'):
  ko'rilgan kombinatsiyalar:   0.974
  ko'rilmagan kombinatsiyalar: 0.519      (tasodifiy 0.056)
  ko'rilmaganlarda: rang 1.000, o'lcham 0.948, shakl 0.540

  "qizil kichik kvadrat" -> 88% holatda "qizil kichik doira"
  sabab: o'quvda qizil kichik shakl FAQAT doira edi ->
  model "qizil + kichik => doira" yorlig'ini (shortcut) o'rgangan

ODDIY KLASSIFIKATOR BILAN FARQ:
  14 sinfli klassifikator ko'rilmagan kombinatsiyani umuman ayta olmaydi
  CLIP esa 0.519 - tasodifiydan 9 barobar yuqori, lekin 0.974 dan ancha past

QIDIRUV: so'rov z_t, galereya {z_r}; kosinus bo'yicha tartiblash

O'LCHOVLAR:
  P@k (precision@k)  - top-k dagi to'g'ri natijalar ulushi
  R-precision        - top-R da, R = to'g'ri natijalar soni (bizda 40)
  R@k (recall@k)     - to'g'ri javob top-k ichidami (bitta to'g'ri bo'lsa)
  (25.7-25.9 darslardagi semantik qidiruv o'lchovlari bilan bir xil)

2-MISOL (18 so'rov, 720 rasm, 3 urug'):
                       ko'rilgan   ko'rilmagan
  matn->rasm P@10        0.955       0.758
  matn->rasm R-prec      0.923       0.673
  rasm->matn R@1         0.974       0.519
  rasm->matn R@3         0.999       0.898

  qidiruv (matn->rasm) ko'rilmaganlarda zero-shot dan yaxshiroq:
  top-10 uchun galereyadagi eng "ishonchli" 10 ta rasm yetarli

SO'ZLAR XALTASI (bizning encoder):
  "katta qizil doira" ~ "qizil katta doira"        kosinus 1.000 (tartib yo'q)
  "qizil katta doira" ~ "qizil emas katta doira"   kosinus 1.000 ("emas" lug'atda yo'q)
  so'rov "qizil emas katta doira" -> top-20 ning 1.00 qismi QIZIL

KATTA CLIP MODELLARIDA HAM MA'LUM ZAIF JOYLAR:
  inkor ("... emas", "... siz")
  sanash ("uchta olma")
  fazoviy munosabatlar ("chapda", "ustida")
  atributni to'g'ri obyektga bog'lash ("qizil kub va ko'k shar")
  sabab: kontrastiv maqsad ko'pincha "qaysi so'zlar bor" ni bilish bilan
  yechiladi - tartib va munosabatni o'rganishga majburlamaydi

AMALDA:
  tartibni ko'radigan encoder (Transformer) + munosabatli qiyin manfiy
  misollar (hard negatives) bilan o'rgatish

SHARTLI VAE (26.2 dagi VAE + shart c):
  encoder:  q(z | x, c)       dekoder: p(x | z, c)
  loss = ||x - x_hat||^2 / (2 * 0.1^2) + KL(q(z|x,c) || N(0, I))
  generatsiya: z ~ N(0, I), c = matn(tavsif) -> dekoder

IKKI XIL SHART (3-misol):
  matn:  c = MLP(so'z embeddinglari o'rtachasi)  - so'zlar orqali
  ID:    c = Embedding(18)[kombinatsiya raqami]   - har kombinatsiyaga alohida vektor
  ID shartida ko'rilmagan kombinatsiyaning vektori HECH QACHON o'rgatilmaydi

BAHOLASH:
  o'z atribut klassifikatorlarimiz (rang, o'lcham, shakl) - HAMMA 18
  kombinatsiyada o'rgatilgan hakam; generatsiyaning har atributi to'g'rimi

3-MISOL ('hammasi to'g'ri', 3 urug'):
             ko'rilgan   ko'rilmagan
  matn         0.396       0.304
  ID           0.473       0.000
  -> ko'rilganda ID biroz yaxshi, ko'rilmaganda faqat matn sharti ishlaydi

G'OYA (dastlabki matn-rasm tizimlarida ishlatilgan):
  bir so'rovga K ta nomzod generatsiya qilish
  CLIP bilan cos(f_rasm(nomzod), f_matn(so'rov)) hisoblash
  eng yuqorisini qaytarish

4-MISOL ('hammasi to'g'ri'):
    K     ko'rilgan   ko'rilmagan
    1       0.333       0.285
    8       0.460       0.375
  AUC (CLIP bahosi -> to'g'rilik): ko'rilgan 0.896, ko'rilmagan 0.764

NARX: K barobar generatsiya + K ta CLIP baholash
CHEKLOV: tanlovchi ham o'sha ma'lumotda o'rgangan - ko'r nuqtalari umumiy
  (ko'rilmagan kombinatsiyada foyda kichikroq)

(faqat umumiy ma'lum arxitektura; aniq o'lcham va xarajat raqamlari
 bu yerda keltirilmaydi)

STABLE DIFFUSION (latent diffusion, 26.6):
  VAE: rasm -> kichik latent (8 barobar kichraytirilgan)
  matn encoder: oldindan o'rgatilgan CLIP matn encoderi (muzlatilgan)
  U-Net: latentda diffusion, matn - cross-attention orqali
  classifier-free guidance, kam qadamli samplerlar (DDIM va boshq.)

DALL-E (OpenAI oilasi):
  birinchi versiya - rasm tokenlari ustida avtoregressiv Transformer
    + CLIP bilan qayta saralash 2.8-bob
  keyingi versiyalar - diffusion asosidagi dekoder, CLIP embeddinglari
  yoki til modeli bilan kuchaytirilgan matn tushunish

UMUMIY TENDENSIYALAR:
  kuchliroq matn encoderi -> so'rovga yaxshiroq moslik
  latent fazo -> arzonroq hisob
  guidance -> moslik va xilma-xillik murosasi 26.6-bob
  baholash: FID + CLIP-score + inson baholashi (26.7)

import torch
import torch.nn.functional as F

# ikki encoder, normallangan vektorlar
zi = F.normalize(rasm_encoder(X), dim=-1)
zt = F.normalize(matn_encoder(matnlar), dim=-1)

# InfoNCE (simmetrik), o'rganiladigan harorat
logit = log_harorat.exp().clamp(max=100) * zi @ zt.T
nishon = torch.arange(len(zi))
loss = (F.cross_entropy(logit, nishon) + F.cross_entropy(logit.T, nishon)) / 2

# zero-shot
bashorat = (zi @ matn_encoder(sinf_tavsiflari).T).argmax(1)

# matn -> rasm qidiruvi va P@10
top = (matn_encoder([sorov]) @ galereya.T)[0].argsort(descending=True)[:10]
p10 = (Y[top] == togri_sinf).float().mean()

# shartli VAE: shart - matn embeddingi
c = matn_shart(tavsiflar)
rasm = dekoder(torch.cat([torch.randn(n, z_dim, generator=g), c], 1))

# best-of-K: CLIP bahosi bo'yicha eng yaxshi nomzod
ball = (rasm_encoder(nomzodlar) * matn_encoder([sorov])).sum(1)
eng = nomzodlar[ball.argmax()]

matn encoder -> shart (vektor yoki cross-attention) -> generator
CLIP: ikki encoder, InfoNCE, o'rganiladigan harorat
zero-shot: sinf = matn; kompozitsion umumlashma - qisman
qidiruv: P@k, R-precision, R@k; ko'rilgan va ko'rilmaganni alohida
so'zlar xaltasi: tartib va inkor yo'q
kompozitsion shart umumlashadi, ID shart - yo'q
best-of-K: CLIP bilan qayta saralash, narxi K barobar

"""CLIP g'oyasi noldan: sintetik shakllar va o'zbekcha tavsiflar, InfoNCE, zero-shot klassifikatsiya."""

import math

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

SHAKLLAR = ["doira", "kvadrat", "uchburchak"]
RANGLAR = ["qizil", "yashil", "ko'k"]
OLCHAMLAR = ["katta", "kichik"]
RGB = {"qizil": (0.9, 0.15, 0.15), "yashil": (0.15, 0.8, 0.2), "ko'k": (0.2, 0.3, 0.95)}
KOMBO = [(r, o, s) for s in SHAKLLAR for r in RANGLAR for o in OLCHAMLAR]      # 18 ta
KORILMAGAN = {("ko'k", "katta", "uchburchak"), ("qizil", "kichik", "kvadrat"),
              ("yashil", "katta", "doira"), ("qizil", "kichik", "uchburchak")}
SHABLONLAR = ["{r} {o} {s}", "{o} {r} {s}", "{r} rangli {o} {s}", "bu {o} {r} {s}",
              "{o} {s}, rangi {r}", "rasmda {r} {s}, o'lchami {o}"]


def chiz(rang, olcham, shakl, rng):
    """16x16 RGB rasm: fon + bitta shakl (joyi, rangi biroz tasodifiy)."""
    r = 6.0 if olcham == "katta" else 3.2
    cy, cx = rng.uniform(r + 0.5, 15.5 - r, size=2)
    y, x = np.mgrid[0:16, 0:16] + 0.5
    if shakl == "doira":
        m = (y - cy) ** 2 + (x - cx) ** 2 <= r ** 2
    elif shakl == "kvadrat":
        m = (np.abs(y - cy) <= 0.85 * r) & (np.abs(x - cx) <= 0.85 * r)
    else:
        m = (y >= cy - r) & (y <= cy + r) & (np.abs(x - cx) <= (y - (cy - r)) / 2)
    rasm = 0.1 + 0.05 * rng.standard_normal((3, 16, 16))
    rang_q = np.array(RGB[rang]) + rng.uniform(-0.08, 0.08, 3)
    rasm[:, m] = rang_q[:, None]
    return rasm.astype(np.float32)


def toplam(kombolar, n_har, seed):
    rng = np.random.default_rng(seed)
    X, T, Y = [], [], []
    for ki, (r, o, s) in enumerate(KOMBO):
        if (r, o, s) not in kombolar:
            continue
        for _ in range(n_har):
            X.append(chiz(r, o, s, rng))
            T.append(SHABLONLAR[rng.integers(len(SHABLONLAR))].format(r=r, o=o, s=s))
            Y.append(ki)
    return torch.tensor(np.array(X)), T, torch.tensor(Y)


class RasmEncoder(nn.Module):
    """Kichik CNN: 3x16x16 -> konvolyutsiya (16 kanal) -> max-pool 4x4 -> 256 -> 64 -> 32."""

    def __init__(self, d=32):
        super().__init__()
        self.tarmoq = nn.Sequential(
            nn.Conv2d(3, 16, 3, padding=1), nn.ReLU(), nn.MaxPool2d(4),
            nn.Flatten(), nn.Linear(16 * 16, 64), nn.ReLU(), nn.Linear(64, d))

    def forward(self, x):
        return F.normalize(self.tarmoq(x), dim=-1)


class MatnEncoder(nn.Module):
    """So'z embeddinglari o'rtachasi (bag of words) + MLP. So'z tartibini KO'RMAYDI."""

    def __init__(self, lugat, d=32):
        super().__init__()
        self.lugat = {w: i + 1 for i, w in enumerate(lugat)}          # 0 - to'ldiruvchi
        self.emb = nn.Embedding(len(lugat) + 1, 32, padding_idx=0)
        self.mlp = nn.Sequential(nn.Linear(32, 64), nn.ReLU(), nn.Linear(64, d))

    def tokenla(self, matnlar):
        idx = [[self.lugat.get(w, 0) for w in m.replace(",", "").split()] for m in matnlar]
        L = max(len(i) for i in idx)
        return torch.tensor([i + [0] * (L - len(i)) for i in idx])

    def forward(self, matnlar):
        t = self.tokenla(matnlar)
        e = self.emb(t)
        o = e.sum(1) / (t > 0).sum(1, keepdim=True).clamp(min=1)
        return F.normalize(self.mlp(o), dim=-1)


def lugat_yasash():
    sozlar = set()
    for r, o, s in KOMBO:
        for sh in SHABLONLAR:
            sozlar.update(sh.format(r=r, o=o, s=s).replace(",", "").split())
    return sorted(sozlar)


def orgat_clip(X, T, seed, qadamlar=400, B=128):
    torch.manual_seed(seed)
    re_, me = RasmEncoder(), MatnEncoder(lugat_yasash())
    log_harorat = nn.Parameter(torch.tensor(math.log(1 / 0.07)))
    opt = torch.optim.Adam(list(re_.parameters()) + list(me.parameters()) + [log_harorat], lr=2e-3)
    g = torch.Generator().manual_seed(seed)
    for q in range(qadamlar):
        i = torch.randperm(len(X), generator=g)[:B]
        zi, zt = re_(X[i]), me([T[j] for j in i.tolist()])
        logit = log_harorat.exp().clamp(max=100) * zi @ zt.T               # (B, B)
        nishon = torch.arange(B)
        loss = (F.cross_entropy(logit, nishon) + F.cross_entropy(logit.T, nishon)) / 2   # InfoNCE
        opt.zero_grad()
        loss.backward()
        opt.step()
        if q == 0:
            boshlangich = loss.item()
    re_.eval()
    me.eval()
    return re_, me, boshlangich, loss.item(), log_harorat.exp().item()


def main() -> None:
    torch.set_num_threads(1)
    korilgan = set(KOMBO) - KORILMAGAN
    X, T, _ = toplam(korilgan, 150, seed=0)
    Xt, _, Yt = toplam(set(KOMBO), 40, seed=1)
    print("=== 1. Ma'lumot: 16x16 shakllar va o'zbekcha tavsiflar ===")
    print(f"  atributlar: {len(SHAKLLAR)} shakl x {len(RANGLAR)} rang x {len(OLCHAMLAR)} o'lcham = {len(KOMBO)} kombinatsiya")
    print(f"  o'quvda ko'rilmagan {len(KORILMAGAN)} ta: "
          + "; ".join(" ".join(k) for k in sorted(KORILMAGAN)))
    print(f"  o'quv juftliklari: {len(X)}, test rasmlari: {len(Xt)} (har kombinatsiyadan 40)")
    print(f"  tavsif namunalari: {T[0]!r}, {T[1]!r}, {T[2]!r}")
    print(f"  lug'at: {len(lugat_yasash())} so'z")

    print("\n=== 2. InfoNCE bilan o'rgatish (3 urug') ===")
    yozuvlar = [f"{o} {r} {s}" for r, o, s in KOMBO]
    korilmagan_m = torch.tensor([KOMBO[y] in KORILMAGAN for y in Yt.tolist()])
    natija, birinchi = [], None
    for seed in range(3):
        re_, me, l0, l1, harorat = orgat_clip(X, T, seed)
        with torch.no_grad():
            bashorat = (re_(Xt) @ me(yozuvlar).T).argmax(1)
        tog = bashorat == Yt
        if birinchi is None:
            birinchi = bashorat
        attr = [np.mean([KOMBO[p][j] == KOMBO[y][j] for p, y in zip(bashorat.tolist(), Yt.tolist())
                         if KOMBO[y] in KORILMAGAN]) for j in range(3)]
        natija.append((tog[~korilmagan_m].float().mean().item(), tog[korilmagan_m].float().mean().item(), *attr))
        print(f"  urug' {seed}: loss {l0:.3f} -> {l1:.3f} (log B = {math.log(128):.3f}), harorat {harorat:.1f}")

    print("\n=== 3. Zero-shot: 18 ta tavsifdan eng o'xshashi ===")
    v = np.array(natija)
    se = v.std(0, ddof=1) / math.sqrt(3)
    print(f"  tasodifiy daraja: {1 / 18:.3f}")
    print(f"  ko'rilgan kombinatsiyalar:   aniqlik {v[:, 0].mean():.3f} +- {se[0]:.3f}")
    print(f"  ko'rilmagan kombinatsiyalar: aniqlik {v[:, 1].mean():.3f} +- {se[1]:.3f}")
    print(f"  ko'rilmaganlarda atribut bo'yicha: rang {v[:, 2].mean():.3f}, o'lcham {v[:, 3].mean():.3f}, "
          f"shakl {v[:, 4].mean():.3f}")
    f = v[:, 0] - v[:, 1]
    fse = f.std(ddof=1) / math.sqrt(3)
    print(f"  ko'rilgan - ko'rilmagan: {f.mean():+.3f} (SE {fse:.3f}) -> "
          + ("sezilarli" if f.mean() > 2 * fse else "sezilarli emas"))
    print("  oddiy 14 sinfli klassifikator ko'rilmagan kombinatsiyani umuman ayta olmaydi (sinf yo'q)")

    print("\n=== 4. Ko'rilmagan kombinatsiyalar: model nimani tanladi (urug' 0) ===")
    for kombo in sorted(KORILMAGAN):
        ki = KOMBO.index(kombo)
        p = birinchi[Yt == ki].tolist()
        eng = max(set(p), key=lambda c: (p.count(c), -c))
        print(f"  {' '.join(kombo):<24} to'g'ri {p.count(ki) / len(p):.2f}; eng ko'p tanlangan: "
              f"{' '.join(KOMBO[eng])} ({p.count(eng) / len(p):.2f})")
    print("  ⭐ rang va o'lcham kombinatsiyalanadi; shakl - eng qiyin qism")


if __name__ == "__main__":
    main()

=== 1. Ma'lumot: 16x16 shakllar va o'zbekcha tavsiflar ===
  atributlar: 3 shakl x 3 rang x 2 o'lcham = 18 kombinatsiya
  o'quvda ko'rilmagan 4 ta: ko'k katta uchburchak; qizil kichik kvadrat; qizil kichik uchburchak; yashil katta doira
  o'quv juftliklari: 2100, test rasmlari: 720 (har kombinatsiyadan 40)
  tavsif namunalari: 'qizil katta doira', 'qizil katta doira', 'katta qizil doira'
  lug'at: 13 so'z

=== 2. InfoNCE bilan o'rgatish (3 urug') ===
  urug' 0: loss 5.275 -> 2.001 (log B = 4.852), harorat 19.3
  urug' 1: loss 5.106 -> 2.025 (log B = 4.852), harorat 20.3
  urug' 2: loss 5.590 -> 1.930 (log B = 4.852), harorat 18.8

=== 3. Zero-shot: 18 ta tavsifdan eng o'xshashi ===
  tasodifiy daraja: 0.056
  ko'rilgan kombinatsiyalar:   aniqlik 0.974 +- 0.010
  ko'rilmagan kombinatsiyalar: aniqlik 0.519 +- 0.043
  ko'rilmaganlarda atribut bo'yicha: rang 1.000, o'lcham 0.948, shakl 0.540
  ko'rilgan - ko'rilmagan: +0.455 (SE 0.050) -> sezilarli
  oddiy 14 sinfli klassifikator ko'rilmagan kombinatsiyani umuman ayta olmaydi (sinf yo'q)

=== 4. Ko'rilmagan kombinatsiyalar: model nimani tanladi (urug' 0) ===
  ko'k katta uchburchak    to'g'ri 0.82; eng ko'p tanlangan: ko'k katta uchburchak 0.82-bob
  qizil kichik kvadrat     to'g'ri 0.12; eng ko'p tanlangan: qizil kichik doira 0.88-bob
  qizil kichik uchburchak  to'g'ri 0.15; eng ko'p tanlangan: qizil kichik doira 0.80-bob
  yashil katta doira       to'g'ri 0.97; eng ko'p tanlangan: yashil katta doira 0.97-bob
  ⭐ rang va o'lcham kombinatsiyalanadi; shakl - eng qiyin qism

"""Matn -> rasm qidiruvi (P@k, R-precision, R@k) va so'zlar xaltasi matn encoderining cheklovlari."""

import math

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

SHAKLLAR = ["doira", "kvadrat", "uchburchak"]
RANGLAR = ["qizil", "yashil", "ko'k"]
OLCHAMLAR = ["katta", "kichik"]
RGB = {"qizil": (0.9, 0.15, 0.15), "yashil": (0.15, 0.8, 0.2), "ko'k": (0.2, 0.3, 0.95)}
KOMBO = [(r, o, s) for s in SHAKLLAR for r in RANGLAR for o in OLCHAMLAR]      # 18 ta
KORILMAGAN = {("ko'k", "katta", "uchburchak"), ("qizil", "kichik", "kvadrat"),
              ("yashil", "katta", "doira"), ("qizil", "kichik", "uchburchak")}
SHABLONLAR = ["{r} {o} {s}", "{o} {r} {s}", "{r} rangli {o} {s}", "bu {o} {r} {s}",
              "{o} {s}, rangi {r}", "rasmda {r} {s}, o'lchami {o}"]


def chiz(rang, olcham, shakl, rng):
    """16x16 RGB rasm: fon + bitta shakl (joyi, rangi biroz tasodifiy)."""
    r = 6.0 if olcham == "katta" else 3.2
    cy, cx = rng.uniform(r + 0.5, 15.5 - r, size=2)
    y, x = np.mgrid[0:16, 0:16] + 0.5
    if shakl == "doira":
        m = (y - cy) ** 2 + (x - cx) ** 2 <= r ** 2
    elif shakl == "kvadrat":
        m = (np.abs(y - cy) <= 0.85 * r) & (np.abs(x - cx) <= 0.85 * r)
    else:
        m = (y >= cy - r) & (y <= cy + r) & (np.abs(x - cx) <= (y - (cy - r)) / 2)
    rasm = 0.1 + 0.05 * rng.standard_normal((3, 16, 16))
    rang_q = np.array(RGB[rang]) + rng.uniform(-0.08, 0.08, 3)
    rasm[:, m] = rang_q[:, None]
    return rasm.astype(np.float32)


def toplam(kombolar, n_har, seed):
    rng = np.random.default_rng(seed)
    X, T, Y = [], [], []
    for ki, (r, o, s) in enumerate(KOMBO):
        if (r, o, s) not in kombolar:
            continue
        for _ in range(n_har):
            X.append(chiz(r, o, s, rng))
            T.append(SHABLONLAR[rng.integers(len(SHABLONLAR))].format(r=r, o=o, s=s))
            Y.append(ki)
    return torch.tensor(np.array(X)), T, torch.tensor(Y)


class RasmEncoder(nn.Module):
    """Kichik CNN: 3x16x16 -> konvolyutsiya (16 kanal) -> max-pool 4x4 -> 256 -> 64 -> 32."""

    def __init__(self, d=32):
        super().__init__()
        self.tarmoq = nn.Sequential(
            nn.Conv2d(3, 16, 3, padding=1), nn.ReLU(), nn.MaxPool2d(4),
            nn.Flatten(), nn.Linear(16 * 16, 64), nn.ReLU(), nn.Linear(64, d))

    def forward(self, x):
        return F.normalize(self.tarmoq(x), dim=-1)


class MatnEncoder(nn.Module):
    """So'z embeddinglari o'rtachasi (bag of words) + MLP. So'z tartibini KO'RMAYDI."""

    def __init__(self, lugat, d=32):
        super().__init__()
        self.lugat = {w: i + 1 for i, w in enumerate(lugat)}          # 0 - to'ldiruvchi
        self.emb = nn.Embedding(len(lugat) + 1, 32, padding_idx=0)
        self.mlp = nn.Sequential(nn.Linear(32, 64), nn.ReLU(), nn.Linear(64, d))

    def tokenla(self, matnlar):
        idx = [[self.lugat.get(w, 0) for w in m.replace(",", "").split()] for m in matnlar]
        L = max(len(i) for i in idx)
        return torch.tensor([i + [0] * (L - len(i)) for i in idx])

    def forward(self, matnlar):
        t = self.tokenla(matnlar)
        e = self.emb(t)
        o = e.sum(1) / (t > 0).sum(1, keepdim=True).clamp(min=1)
        return F.normalize(self.mlp(o), dim=-1)


def lugat_yasash():
    sozlar = set()
    for r, o, s in KOMBO:
        for sh in SHABLONLAR:
            sozlar.update(sh.format(r=r, o=o, s=s).replace(",", "").split())
    return sorted(sozlar)


def orgat_clip(X, T, seed, qadamlar=400, B=128):
    torch.manual_seed(seed)
    re_, me = RasmEncoder(), MatnEncoder(lugat_yasash())
    log_harorat = nn.Parameter(torch.tensor(math.log(1 / 0.07)))
    opt = torch.optim.Adam(list(re_.parameters()) + list(me.parameters()) + [log_harorat], lr=2e-3)
    g = torch.Generator().manual_seed(seed)
    for q in range(qadamlar):
        i = torch.randperm(len(X), generator=g)[:B]
        zi, zt = re_(X[i]), me([T[j] for j in i.tolist()])
        logit = log_harorat.exp().clamp(max=100) * zi @ zt.T               # (B, B)
        nishon = torch.arange(B)
        loss = (F.cross_entropy(logit, nishon) + F.cross_entropy(logit.T, nishon)) / 2   # InfoNCE
        opt.zero_grad()
        loss.backward()
        opt.step()
        if q == 0:
            boshlangich = loss.item()
    re_.eval()
    me.eval()
    return re_, me, boshlangich, loss.item(), log_harorat.exp().item()


def main() -> None:
    torch.set_num_threads(1)
    korilgan = set(KOMBO) - KORILMAGAN
    X, T, _ = toplam(korilgan, 150, seed=0)
    Xt, _, Yt = toplam(set(KOMBO), 40, seed=1)
    yozuvlar = [f"{o} {r} {s}" for r, o, s in KOMBO]
    yangi = torch.tensor([k in KORILMAGAN for k in KOMBO])

    print("=== 1. Matn -> rasm qidiruvi: 18 so'rov, galereya 720 rasm (har kombinatsiyadan 40) ===")
    print("  P@10 - top-10 dagi to'g'ri rasmlar ulushi; R-precision - top-40 da (40 ta to'g'ri bor)")
    print("  rasm -> matn R@1 / R@3 - to'g'ri tavsif 18 tadan top-1 / top-3 da")
    natija = []
    modellar = []
    for seed in range(3):
        re_, me, *_ = orgat_clip(X, T, seed)
        modellar.append((re_, me))
        with torch.no_grad():
            o = me(yozuvlar) @ re_(Xt).T                                 # (18, 720)
        top = o.argsort(1, descending=True)
        togri = Yt[top] == torch.arange(18)[:, None]                     # (18, 720)
        p10 = togri[:, :10].float().mean(1)
        rp = togri[:, :40].float().mean(1)
        rank = (o.T.argsort(1, descending=True) == Yt[:, None]).float().argmax(1)   # rasm -> matn
        r1 = (rank < 1).float()
        r3 = (rank < 3).float()
        yangi_r = yangi[Yt]
        natija.append([p10[~yangi].mean(), p10[yangi].mean(), rp[~yangi].mean(), rp[yangi].mean(),
                       r1[~yangi_r].mean(), r1[yangi_r].mean(), r3[~yangi_r].mean(), r3[yangi_r].mean()])
    v = np.array(natija, dtype=float)
    print("                        ko'rilgan         ko'rilmagan")
    for j, nom in enumerate(("matn->rasm P@10", "matn->rasm R-prec", "rasm->matn R@1", "rasm->matn R@3")):
        a, b = v[:, 2 * j], v[:, 2 * j + 1]
        print(f"  {nom:<19} {a.mean():.3f} +- {a.std(ddof=1) / math.sqrt(3):.3f}   "
              f"{b.mean():.3f} +- {b.std(ddof=1) / math.sqrt(3):.3f}")
    print(f"  tasodifiy daraja: P@10 {1 / 18:.3f}, R@1 {1 / 18:.3f}, R@3 {3 / 18:.3f}")

    print("\n=== 2. Ko'rilmagan so'rovlar: top-10 da qaysi rasmlar (urug' 0) ===")
    re_, me = modellar[0]
    with torch.no_grad():
        galereya = re_(Xt)
        for kombo in sorted(KORILMAGAN):
            so = me([" ".join((kombo[1], kombo[0], kombo[2]))])
            top = (so @ galereya.T)[0].argsort(descending=True)[:10]
            topilgan = [KOMBO[i] for i in Yt[top].tolist()]
            sanoq = {j: [t[j] == kombo[j] for t in topilgan].count(True) for j in range(3)}
            print(f"  {' '.join(kombo):<24} to'liq mos {topilgan.count(kombo):>2}/10; rang {sanoq[0]}/10, "
                  f"o'lcham {sanoq[1]}/10, shakl {sanoq[2]}/10")

    print("\n=== 3. Matn encoderining cheklovlari (so'zlar xaltasi) ===")
    with torch.no_grad():
        juftlar = [("katta qizil doira", "qizil katta doira"),
                   ("qizil katta doira", "qizil emas katta doira"),
                   ("qizil katta doira", "katta doira, rangi qizil"),
                   ("qizil katta doira", "yashil katta doira"),
                   ("qizil katta doira", "qizil kichik kvadrat")]
        for a, b in juftlar:
            kos = (me([a]) @ me([b]).T).item()
            print(f"  {a!r:<22} ~ {b!r:<28} kosinus {kos:.3f}")
        so = me(["qizil emas katta doira"])
        top = (so @ galereya.T)[0].argsort(descending=True)[:20]
        qizil = np.mean([KOMBO[i][0] == "qizil" for i in Yt[top].tolist()])
    print(f"  so'rov 'qizil emas katta doira': top-20 dagi qizil rasmlar ulushi {qizil:.2f}")
    print("  'emas' lug'atda yo'q -> e'tiborsiz; so'z tartibi ham ko'rinmaydi")
    print("  ⭐ inkor va munosabatlar ('chapda', 'emas') - CLIP turidagi modellarning ma'lum zaif joyi")


if __name__ == "__main__":
    main()

=== 1. Matn -> rasm qidiruvi: 18 so'rov, galereya 720 rasm (har kombinatsiyadan 40) ===
  P@10 - top-10 dagi to'g'ri rasmlar ulushi; R-precision - top-40 da (40 ta to'g'ri bor)
  rasm -> matn R@1 / R@3 - to'g'ri tavsif 18 tadan top-1 / top-3 da
                        ko'rilgan         ko'rilmagan
  matn->rasm P@10     0.955 +- 0.006   0.758 +- 0.042
  matn->rasm R-prec   0.923 +- 0.013   0.673 +- 0.045
  rasm->matn R@1      0.974 +- 0.010   0.519 +- 0.043
  rasm->matn R@3      0.999 +- 0.001   0.898 +- 0.033
  tasodifiy daraja: P@10 0.056, R@1 0.056, R@3 0.167

=== 2. Ko'rilmagan so'rovlar: top-10 da qaysi rasmlar (urug' 0) ===
  ko'k katta uchburchak    to'liq mos 10/10; rang 10/10, o'lcham 10/10, shakl 10/10
  qizil kichik kvadrat     to'liq mos  6/10; rang 10/10, o'lcham 10/10, shakl 6/10
  qizil kichik uchburchak  to'liq mos  6/10; rang 7/10, o'lcham 10/10, shakl 9/10
  yashil katta doira       to'liq mos 10/10; rang 10/10, o'lcham 10/10, shakl 10/10

=== 3. Matn encoderining cheklovlari (so'zlar xaltasi) ===
  'katta qizil doira'    ~ 'qizil katta doira'          kosinus 1.000
  'qizil katta doira'    ~ 'qizil emas katta doira'     kosinus 1.000
  'qizil katta doira'    ~ 'katta doira, rangi qizil'   kosinus 0.891
  'qizil katta doira'    ~ 'yashil katta doira'         kosinus 0.614
  'qizil katta doira'    ~ 'qizil kichik kvadrat'       kosinus 0.167
  so'rov 'qizil emas katta doira': top-20 dagi qizil rasmlar ulushi 1.00
  'emas' lug'atda yo'q -> e'tiborsiz; so'z tartibi ham ko'rinmaydi
  ⭐ inkor va munosabatlar ('chapda', 'emas') - CLIP turidagi modellarning ma'lum zaif joyi

"""Matn sharti bilan kichik generator (shartli VAE): ko'rilmagan kombinatsiyalarda atributlar to'g'riligi."""

import math

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

SHAKLLAR = ["doira", "kvadrat", "uchburchak"]
RANGLAR = ["qizil", "yashil", "ko'k"]
OLCHAMLAR = ["katta", "kichik"]
RGB = {"qizil": (0.9, 0.15, 0.15), "yashil": (0.15, 0.8, 0.2), "ko'k": (0.2, 0.3, 0.95)}
KOMBO = [(r, o, s) for s in SHAKLLAR for r in RANGLAR for o in OLCHAMLAR]      # 18 ta
KORILMAGAN = {("ko'k", "katta", "uchburchak"), ("qizil", "kichik", "kvadrat"),
              ("yashil", "katta", "doira"), ("qizil", "kichik", "uchburchak")}
SHABLONLAR = ["{r} {o} {s}", "{o} {r} {s}", "{r} rangli {o} {s}", "bu {o} {r} {s}",
              "{o} {s}, rangi {r}", "rasmda {r} {s}, o'lchami {o}"]


def chiz(rang, olcham, shakl, rng):
    """16x16 RGB rasm: fon + bitta shakl (joyi, rangi biroz tasodifiy)."""
    r = 6.0 if olcham == "katta" else 3.2
    cy, cx = rng.uniform(r + 0.5, 15.5 - r, size=2)
    y, x = np.mgrid[0:16, 0:16] + 0.5
    if shakl == "doira":
        m = (y - cy) ** 2 + (x - cx) ** 2 <= r ** 2
    elif shakl == "kvadrat":
        m = (np.abs(y - cy) <= 0.85 * r) & (np.abs(x - cx) <= 0.85 * r)
    else:
        m = (y >= cy - r) & (y <= cy + r) & (np.abs(x - cx) <= (y - (cy - r)) / 2)
    rasm = 0.1 + 0.05 * rng.standard_normal((3, 16, 16))
    rang_q = np.array(RGB[rang]) + rng.uniform(-0.08, 0.08, 3)
    rasm[:, m] = rang_q[:, None]
    return rasm.astype(np.float32)


def toplam(kombolar, n_har, seed):
    rng = np.random.default_rng(seed)
    X, T, Y = [], [], []
    for ki, (r, o, s) in enumerate(KOMBO):
        if (r, o, s) not in kombolar:
            continue
        for _ in range(n_har):
            X.append(chiz(r, o, s, rng))
            T.append(SHABLONLAR[rng.integers(len(SHABLONLAR))].format(r=r, o=o, s=s))
            Y.append(ki)
    return torch.tensor(np.array(X)), T, torch.tensor(Y)


class MatnEncoder(nn.Module):
    """So'z embeddinglari o'rtachasi (bag of words) + MLP. So'z tartibini KO'RMAYDI."""

    def __init__(self, lugat, d=32):
        super().__init__()
        self.lugat = {w: i + 1 for i, w in enumerate(lugat)}          # 0 - to'ldiruvchi
        self.emb = nn.Embedding(len(lugat) + 1, 32, padding_idx=0)
        self.mlp = nn.Sequential(nn.Linear(32, 64), nn.ReLU(), nn.Linear(64, d))

    def tokenla(self, matnlar):
        idx = [[self.lugat.get(w, 0) for w in m.replace(",", "").split()] for m in matnlar]
        L = max(len(i) for i in idx)
        return torch.tensor([i + [0] * (L - len(i)) for i in idx])

    def forward(self, matnlar):
        t = self.tokenla(matnlar)
        e = self.emb(t)
        o = e.sum(1) / (t > 0).sum(1, keepdim=True).clamp(min=1)
        return F.normalize(self.mlp(o), dim=-1)


def lugat_yasash():
    sozlar = set()
    for r, o, s in KOMBO:
        for sh in SHABLONLAR:
            sozlar.update(sh.format(r=r, o=o, s=s).replace(",", "").split())
    return sorted(sozlar)


class AtributKlassifikator(nn.Module):
    """Baholovchi: bitta CNN tanasi, uchta bosh (rang, o'lcham, shakl). BARCHA 18 kombinatsiyada o'rgatiladi."""

    def __init__(self):
        super().__init__()
        self.tana = nn.Sequential(nn.Conv2d(3, 16, 3, padding=1), nn.ReLU(), nn.MaxPool2d(4),
                                  nn.Flatten(), nn.Linear(256, 64), nn.ReLU())
        self.boshlar = nn.ModuleList([nn.Linear(64, 3), nn.Linear(64, 2), nn.Linear(64, 3)])

    def forward(self, x):
        h = self.tana(x)
        return [b(h) for b in self.boshlar]


def atribut_nishon(Y):
    k = torch.tensor([[RANGLAR.index(r), OLCHAMLAR.index(o), SHAKLLAR.index(s)] for r, o, s in KOMBO])
    return k[Y]


def orgat_atribut(X, Y, seed=0):
    torch.manual_seed(seed)
    m = AtributKlassifikator()
    opt = torch.optim.Adam(m.parameters(), lr=5e-3)
    A = atribut_nishon(Y)
    g = torch.Generator().manual_seed(seed)
    for _ in range(500):
        i = torch.randperm(len(X), generator=g)[:128]
        loss = sum(F.cross_entropy(o, A[i, j]) for j, o in enumerate(m(X[i])))
        opt.zero_grad()
        loss.backward()
        opt.step()
    m.eval()
    return m


class ShartliVAE(nn.Module):
    """Shartli VAE: shart c - matn embeddingi (kompozitsion) yoki kombinatsiya ID si (one-hot)."""

    def __init__(self, shart_turi, z=8, d=32):
        super().__init__()
        self.shart_turi = shart_turi
        if shart_turi == "matn":
            self.shart = MatnEncoder(lugat_yasash(), d)
        else:
            self.shart = nn.Embedding(len(KOMBO), d)
        self.enc = nn.Sequential(nn.Linear(768 + d, 128), nn.ReLU(), nn.Linear(128, 2 * z))
        self.dec = nn.Sequential(nn.Linear(z + d, 128), nn.ReLU(), nn.Linear(128, 768), nn.Sigmoid())
        self.z = z

    def c(self, matnlar, idx):
        if self.shart_turi == "matn":
            return self.shart.mlp(self._ortacha(matnlar))
        return self.shart(idx)

    def _ortacha(self, matnlar):
        t = self.shart.tokenla(matnlar)
        return self.shart.emb(t).sum(1) / (t > 0).sum(1, keepdim=True).clamp(min=1)

    def forward(self, x, c):
        mu, logvar = self.enc(torch.cat([x.flatten(1), c], 1)).chunk(2, 1)
        return mu, logvar

    def dekod(self, z, c):
        return self.dec(torch.cat([z, c], 1)).view(-1, 3, 16, 16)


def orgat_cvae(X, T, Y, shart_turi, seed, qadamlar=500, B=128):
    torch.manual_seed(seed)
    m = ShartliVAE(shart_turi)
    opt = torch.optim.Adam(m.parameters(), lr=2e-3)
    g = torch.Generator().manual_seed(seed)
    for _ in range(qadamlar):
        i = torch.randperm(len(X), generator=g)[:B]
        c = m.c([T[j] for j in i.tolist()], Y[i])
        mu, logvar = m(X[i], c)
        z = mu + (0.5 * logvar).exp() * torch.randn(mu.shape, generator=g)
        qayta = ((m.dekod(z, c) - X[i]) ** 2).sum((1, 2, 3)) / (2 * 0.1 ** 2)
        kl = 0.5 * (mu ** 2 + logvar.exp() - 1 - logvar).sum(1)
        loss = (qayta + kl).mean()
        opt.zero_grad()
        loss.backward()
        opt.step()
    m.eval()
    return m


def rangli_ascii(rasmlar):
    """Har piksel: nuqta - fon, Q/Y/K - eng kuchli kanal (qizil/yashil/ko'k)."""
    satrlar = []
    for r in range(16):
        qism = []
        for x in rasmlar:
            q = ""
            for c in range(16):
                p = x[:, r, c]
                q += "\u00b7" if p.max() < 0.4 else "QYK"[int(p.argmax())]
            qism.append(q)
        satrlar.append("    " + "   ".join(qism))
    return "\n".join(satrlar)


def main() -> None:
    torch.set_num_threads(1)
    korilgan = set(KOMBO) - KORILMAGAN
    X, T, Y = toplam(korilgan, 150, seed=0)
    Xa, _, Ya = toplam(set(KOMBO), 60, seed=2)             # baholovchi uchun: hamma kombinatsiya
    Xt, _, Yt = toplam(set(KOMBO), 20, seed=3)
    baholovchi = orgat_atribut(Xa, Ya)
    with torch.no_grad():
        aniq = [(o.argmax(1) == atribut_nishon(Yt)[:, j]).float().mean().item()
                for j, o in enumerate(baholovchi(Xt))]
    print("=== 1. Baholovchi: atribut klassifikatorlari (haqiqiy test rasmlarida) ===")
    print(f"  rang {aniq[0]:.3f}, o'lcham {aniq[1]:.3f}, shakl {aniq[2]:.3f}")
    print("  (baholovchi hamma 18 kombinatsiyani ko'rgan - u faqat hakam, generator emas)")

    print("\n=== 2. Shartli VAE: matn sharti va kombinatsiya ID si (3 urug') ===")
    print("  har kombinatsiyaga 40 namuna, shart - 'o'lcham rang shakl' tavsifi")
    yozuvlar = [f"{o} {r} {s}" for r, o, s in KOMBO]
    nishon = atribut_nishon(torch.arange(len(KOMBO)).repeat_interleave(40))
    yangi = torch.tensor([KOMBO[i] in KORILMAGAN for i in range(len(KOMBO))]).repeat_interleave(40)
    natija, rasmlar = {}, {}
    for tur in ("matn", "ID"):
        for seed in range(3):
            m = orgat_cvae(X, T, Y, tur, seed)
            g = torch.Generator().manual_seed(100 + seed)
            with torch.no_grad():
                idx = torch.arange(len(KOMBO)).repeat_interleave(40)
                c = m.c([yozuvlar[i] for i in idx.tolist()], idx)
                s = m.dekod(torch.randn((len(idx), m.z), generator=g), c)
                tog = torch.stack([o.argmax(1) == nishon[:, j] for j, o in enumerate(baholovchi(s))], 1)
            hamma = tog.all(1)
            natija.setdefault(tur, []).append([tog[~yangi].float().mean(0).tolist() + [hamma[~yangi].float().mean().item()],
                                               tog[yangi].float().mean(0).tolist() + [hamma[yangi].float().mean().item()]])
            if seed == 0:
                rasmlar[tur] = s
    print("  shart   to'plam        rang    o'lcham  shakl   hammasi")
    for tur, v in natija.items():
        v = np.array(v)                                      # (urug', to'plam, 4)
        for j, nom in enumerate(("ko'rilgan", "ko'rilmagan")):
            q = v[:, j].mean(0)
            print(f"  {tur:<6}  {nom:<12} {q[0]:>6.3f}  {q[1]:>6.3f}  {q[2]:>6.3f}  {q[3]:>7.3f}")

    print("\n=== 3. Ko'rilmagan kombinatsiyalarda 'hammasi to'g'ri': matn - ID (juftlashgan) ===")
    a = np.array(natija["matn"])[:, 1, 3]
    b = np.array(natija["ID"])[:, 1, 3]
    f = a - b
    se = f.std(ddof=1) / math.sqrt(3)
    print(f"  matn {a.mean():.3f}, ID {b.mean():.3f}, farq {f.mean():+.3f} (SE {se:.3f}) -> "
          + ("sezilarli" if abs(f.mean()) > 2 * se else "sezilarli emas"))
    print(f"  tasodifiy daraja (3 x 2 x 3 atribut): {1 / 18:.3f}")
    print("  ID sharti: ko'rilmagan kombinatsiya embeddingi hech qachon o'rgatilmagan (tasodifiy)")

    print("\n=== 4. Ko'rilmagan so'rov 'katta ko'k uchburchak' (urug' 0, 2 namuna) ===")
    ki = KOMBO.index(("ko'k", "katta", "uchburchak"))
    print("  chapda: matn sharti | o'ngda: ID sharti   (Q/Y/K - qizil/yashil/ko'k)")
    print(rangli_ascii([rasmlar["matn"][ki * 40], rasmlar["matn"][ki * 40 + 1],
                        rasmlar["ID"][ki * 40], rasmlar["ID"][ki * 40 + 1]]))


if __name__ == "__main__":
    main()

=== 1. Baholovchi: atribut klassifikatorlari (haqiqiy test rasmlarida) ===
  rang 1.000, o'lcham 1.000, shakl 0.958
  (baholovchi hamma 18 kombinatsiyani ko'rgan - u faqat hakam, generator emas)

=== 2. Shartli VAE: matn sharti va kombinatsiya ID si (3 urug') ===
  har kombinatsiyaga 40 namuna, shart - 'o'lcham rang shakl' tavsifi
  shart   to'plam        rang    o'lcham  shakl   hammasi
  matn    ko'rilgan     0.810   1.000   0.474    0.396
  matn    ko'rilmagan   0.642   0.994   0.417    0.304
  ID      ko'rilgan     0.911   1.000   0.501    0.473
  ID      ko'rilmagan   0.377   0.477   0.250    0.000

=== 3. Ko'rilmagan kombinatsiyalarda 'hammasi to'g'ri': matn - ID (juftlashgan) ===
  matn 0.304, ID 0.000, farq +0.304 (SE 0.015) -> sezilarli
  tasodifiy daraja (3 x 2 x 3 atribut): 0.056
  ID sharti: ko'rilmagan kombinatsiya embeddingi hech qachon o'rgatilmagan (tasodifiy)

=== 4. Ko'rilmagan so'rov 'katta ko'k uchburchak' (urug' 0, 2 namuna) ===
  chapda: matn sharti | o'ngda: ID sharti   (Q/Y/K - qizil/yashil/ko'k)
    ················   ················   ················   ················
    ················   ················   ·····Q·Q········   ················
    ················   ················   ················   ················
    ······KKK·······   ················   ················   ················
    ····KKKKKKKK····   ·····KKKKK······   ············Q···   ················
    ····KKKKKKKKK···   ········Q·K·K···   ················   ············Y···
    ····KKKKKKKK····   ·······QQK·KKK··   ·············Q··   ···········Y····
    ···KKKKKKKKKK···   ·······QQ·KKKK··   ···········Y····   ··········QY·Y··
    ···KKKKKKKKKK···   ·······KKKKKK···   ·······Y········   ···········YYY··
    ···KKKKKKKKKK···   ······QQKKKKKK··   ·····Y·Y········   ·········YYYYY··
    ···KKKKKKKKKK···   ····KKKKKKKKKK··   ·····YYYYYY·····   ········YYYYYY··
    ···KKKKKKKKKK···   ····KKKKKKKKKK··   ······YYY·······   ·······YYYYYYY··
    ····KKKKKKKKK···   ····KQKKKKKKKK··   ················   ·········Y······
    ····K·····QQQ···   ····QKKKKQKQKQ··   ················   ···········Q····
    ················   ······QQQKQQ····   ················   ················
    ················   ················   ················   ················

"""CLIP bilan qayta saralash: shartli VAE nomzodlaridan eng mosini tanlash (best-of-K)."""

import math

import numpy as np
import torch
import torch.nn as nn
import torch.nn.functional as F
from sklearn.metrics import roc_auc_score

SHAKLLAR = ["doira", "kvadrat", "uchburchak"]
RANGLAR = ["qizil", "yashil", "ko'k"]
OLCHAMLAR = ["katta", "kichik"]
RGB = {"qizil": (0.9, 0.15, 0.15), "yashil": (0.15, 0.8, 0.2), "ko'k": (0.2, 0.3, 0.95)}
KOMBO = [(r, o, s) for s in SHAKLLAR for r in RANGLAR for o in OLCHAMLAR]      # 18 ta
KORILMAGAN = {("ko'k", "katta", "uchburchak"), ("qizil", "kichik", "kvadrat"),
              ("yashil", "katta", "doira"), ("qizil", "kichik", "uchburchak")}
SHABLONLAR = ["{r} {o} {s}", "{o} {r} {s}", "{r} rangli {o} {s}", "bu {o} {r} {s}",
              "{o} {s}, rangi {r}", "rasmda {r} {s}, o'lchami {o}"]


def chiz(rang, olcham, shakl, rng):
    """16x16 RGB rasm: fon + bitta shakl (joyi, rangi biroz tasodifiy)."""
    r = 6.0 if olcham == "katta" else 3.2
    cy, cx = rng.uniform(r + 0.5, 15.5 - r, size=2)
    y, x = np.mgrid[0:16, 0:16] + 0.5
    if shakl == "doira":
        m = (y - cy) ** 2 + (x - cx) ** 2 <= r ** 2
    elif shakl == "kvadrat":
        m = (np.abs(y - cy) <= 0.85 * r) & (np.abs(x - cx) <= 0.85 * r)
    else:
        m = (y >= cy - r) & (y <= cy + r) & (np.abs(x - cx) <= (y - (cy - r)) / 2)
    rasm = 0.1 + 0.05 * rng.standard_normal((3, 16, 16))
    rang_q = np.array(RGB[rang]) + rng.uniform(-0.08, 0.08, 3)
    rasm[:, m] = rang_q[:, None]
    return rasm.astype(np.float32)


def toplam(kombolar, n_har, seed):
    rng = np.random.default_rng(seed)
    X, T, Y = [], [], []
    for ki, (r, o, s) in enumerate(KOMBO):
        if (r, o, s) not in kombolar:
            continue
        for _ in range(n_har):
            X.append(chiz(r, o, s, rng))
            T.append(SHABLONLAR[rng.integers(len(SHABLONLAR))].format(r=r, o=o, s=s))
            Y.append(ki)
    return torch.tensor(np.array(X)), T, torch.tensor(Y)


class RasmEncoder(nn.Module):
    """Kichik CNN: 3x16x16 -> konvolyutsiya (16 kanal) -> max-pool 4x4 -> 256 -> 64 -> 32."""

    def __init__(self, d=32):
        super().__init__()
        self.tarmoq = nn.Sequential(
            nn.Conv2d(3, 16, 3, padding=1), nn.ReLU(), nn.MaxPool2d(4),
            nn.Flatten(), nn.Linear(16 * 16, 64), nn.ReLU(), nn.Linear(64, d))

    def forward(self, x):
        return F.normalize(self.tarmoq(x), dim=-1)


class MatnEncoder(nn.Module):
    """So'z embeddinglari o'rtachasi (bag of words) + MLP. So'z tartibini KO'RMAYDI."""

    def __init__(self, lugat, d=32):
        super().__init__()
        self.lugat = {w: i + 1 for i, w in enumerate(lugat)}          # 0 - to'ldiruvchi
        self.emb = nn.Embedding(len(lugat) + 1, 32, padding_idx=0)
        self.mlp = nn.Sequential(nn.Linear(32, 64), nn.ReLU(), nn.Linear(64, d))

    def tokenla(self, matnlar):
        idx = [[self.lugat.get(w, 0) for w in m.replace(",", "").split()] for m in matnlar]
        L = max(len(i) for i in idx)
        return torch.tensor([i + [0] * (L - len(i)) for i in idx])

    def forward(self, matnlar):
        t = self.tokenla(matnlar)
        e = self.emb(t)
        o = e.sum(1) / (t > 0).sum(1, keepdim=True).clamp(min=1)
        return F.normalize(self.mlp(o), dim=-1)


def lugat_yasash():
    sozlar = set()
    for r, o, s in KOMBO:
        for sh in SHABLONLAR:
            sozlar.update(sh.format(r=r, o=o, s=s).replace(",", "").split())
    return sorted(sozlar)


def orgat_clip(X, T, seed, qadamlar=400, B=128):
    torch.manual_seed(seed)
    re_, me = RasmEncoder(), MatnEncoder(lugat_yasash())
    log_harorat = nn.Parameter(torch.tensor(math.log(1 / 0.07)))
    opt = torch.optim.Adam(list(re_.parameters()) + list(me.parameters()) + [log_harorat], lr=2e-3)
    g = torch.Generator().manual_seed(seed)
    for q in range(qadamlar):
        i = torch.randperm(len(X), generator=g)[:B]
        zi, zt = re_(X[i]), me([T[j] for j in i.tolist()])
        logit = log_harorat.exp().clamp(max=100) * zi @ zt.T               # (B, B)
        nishon = torch.arange(B)
        loss = (F.cross_entropy(logit, nishon) + F.cross_entropy(logit.T, nishon)) / 2   # InfoNCE
        opt.zero_grad()
        loss.backward()
        opt.step()
        if q == 0:
            boshlangich = loss.item()
    re_.eval()
    me.eval()
    return re_, me, boshlangich, loss.item(), log_harorat.exp().item()


class AtributKlassifikator(nn.Module):
    """Baholovchi: bitta CNN tanasi, uchta bosh (rang, o'lcham, shakl). BARCHA 18 kombinatsiyada o'rgatiladi."""

    def __init__(self):
        super().__init__()
        self.tana = nn.Sequential(nn.Conv2d(3, 16, 3, padding=1), nn.ReLU(), nn.MaxPool2d(4),
                                  nn.Flatten(), nn.Linear(256, 64), nn.ReLU())
        self.boshlar = nn.ModuleList([nn.Linear(64, 3), nn.Linear(64, 2), nn.Linear(64, 3)])

    def forward(self, x):
        h = self.tana(x)
        return [b(h) for b in self.boshlar]


def atribut_nishon(Y):
    k = torch.tensor([[RANGLAR.index(r), OLCHAMLAR.index(o), SHAKLLAR.index(s)] for r, o, s in KOMBO])
    return k[Y]


def orgat_atribut(X, Y, seed=0):
    torch.manual_seed(seed)
    m = AtributKlassifikator()
    opt = torch.optim.Adam(m.parameters(), lr=5e-3)
    A = atribut_nishon(Y)
    g = torch.Generator().manual_seed(seed)
    for _ in range(500):
        i = torch.randperm(len(X), generator=g)[:128]
        loss = sum(F.cross_entropy(o, A[i, j]) for j, o in enumerate(m(X[i])))
        opt.zero_grad()
        loss.backward()
        opt.step()
    m.eval()
    return m


class ShartliVAE(nn.Module):
    """Shartli VAE: shart c - matn embeddingi (kompozitsion) yoki kombinatsiya ID si (one-hot)."""

    def __init__(self, shart_turi, z=8, d=32):
        super().__init__()
        self.shart_turi = shart_turi
        if shart_turi == "matn":
            self.shart = MatnEncoder(lugat_yasash(), d)
        else:
            self.shart = nn.Embedding(len(KOMBO), d)
        self.enc = nn.Sequential(nn.Linear(768 + d, 128), nn.ReLU(), nn.Linear(128, 2 * z))
        self.dec = nn.Sequential(nn.Linear(z + d, 128), nn.ReLU(), nn.Linear(128, 768), nn.Sigmoid())
        self.z = z

    def c(self, matnlar, idx):
        if self.shart_turi == "matn":
            return self.shart.mlp(self._ortacha(matnlar))
        return self.shart(idx)

    def _ortacha(self, matnlar):
        t = self.shart.tokenla(matnlar)
        return self.shart.emb(t).sum(1) / (t > 0).sum(1, keepdim=True).clamp(min=1)

    def forward(self, x, c):
        mu, logvar = self.enc(torch.cat([x.flatten(1), c], 1)).chunk(2, 1)
        return mu, logvar

    def dekod(self, z, c):
        return self.dec(torch.cat([z, c], 1)).view(-1, 3, 16, 16)


def orgat_cvae(X, T, Y, shart_turi, seed, qadamlar=500, B=128):
    torch.manual_seed(seed)
    m = ShartliVAE(shart_turi)
    opt = torch.optim.Adam(m.parameters(), lr=2e-3)
    g = torch.Generator().manual_seed(seed)
    for _ in range(qadamlar):
        i = torch.randperm(len(X), generator=g)[:B]
        c = m.c([T[j] for j in i.tolist()], Y[i])
        mu, logvar = m(X[i], c)
        z = mu + (0.5 * logvar).exp() * torch.randn(mu.shape, generator=g)
        qayta = ((m.dekod(z, c) - X[i]) ** 2).sum((1, 2, 3)) / (2 * 0.1 ** 2)
        kl = 0.5 * (mu ** 2 + logvar.exp() - 1 - logvar).sum(1)
        loss = (qayta + kl).mean()
        opt.zero_grad()
        loss.backward()
        opt.step()
    m.eval()
    return m


def main() -> None:
    torch.set_num_threads(1)
    korilgan = set(KOMBO) - KORILMAGAN
    X, T, Y = toplam(korilgan, 150, seed=0)
    Xa, _, Ya = toplam(set(KOMBO), 60, seed=2)
    baholovchi = orgat_atribut(Xa, Ya)
    re_, me, *_ = orgat_clip(X, T, seed=0)                  # hakam EMAS - generatsiya qismi
    gen = orgat_cvae(X, T, Y, "matn", seed=0)
    yozuvlar = [f"{o} {r} {s}" for r, o, s in KOMBO]
    print("=== 1. Quvur: matn -> shartli VAE (K ta nomzod) -> CLIP bahosi -> eng yaxshisi ===")
    print("  CLIP va VAE faqat ko'rilgan 14 kombinatsiyada o'rgatilgan; baholovchi - alohida")
    G, K = 12, 8                                            # har so'rovga 12 guruh x 8 nomzod

    def namunalar(seed):
        g = torch.Generator().manual_seed(seed)
        idx = torch.arange(len(KOMBO)).repeat_interleave(G * K)
        with torch.no_grad():
            c = gen.c([yozuvlar[i] for i in idx.tolist()], idx)
            s = gen.dekod(torch.randn((len(idx), gen.z), generator=g), c)
            ball = (re_(s) * me(yozuvlar)[idx]).sum(1)       # kosinus: rasm va o'z so'rovi
            nishon = atribut_nishon(idx)
            tog = torch.stack([o.argmax(1) == nishon[:, j] for j, o in enumerate(baholovchi(s))], 1).all(1)
        return idx.view(len(KOMBO), G, K), ball.view(len(KOMBO), G, K), tog.view(len(KOMBO), G, K)

    yangi = torch.tensor([k in KORILMAGAN for k in KOMBO])
    print("\n=== 2. Best-of-K: CLIP bo'yicha eng yuqori nomzod (3 urug', 'hammasi to'g'ri' ulushi) ===")
    print("    K    ko'rilgan   ko'rilmagan")
    natija = {}
    for seed in range(3):
        _, ball, tog = namunalar(50 + seed)
        for k in (1, 2, 4, 8):
            eng = ball[:, :, :k].argmax(2, keepdim=True)
            tanlangan = tog[:, :, :k].gather(2, eng)[:, :, 0].float().mean(1)       # (18,)
            natija.setdefault(k, []).append((tanlangan[~yangi].mean().item(), tanlangan[yangi].mean().item()))
    for k, v in natija.items():
        v = np.array(v)
        print(f"  {k:>3}    {v[:, 0].mean():.3f}       {v[:, 1].mean():.3f}")
    for j, nom in enumerate(("ko'rilgan", "ko'rilmagan")):
        f = np.array(natija[8])[:, j] - np.array(natija[1])[:, j]
        se = f.std(ddof=1) / math.sqrt(3)
        print(f"  {nom:<12} K = 8 - K = 1: {f.mean():+.3f} (SE {se:.3f}) -> "
              + ("sezilarli" if abs(f.mean()) > 2 * se else "sezilarli emas"))

    print("\n=== 3. CLIP bahosi to'g'rilikni qanchalik ajratadi (AUC, urug' 50) ===")
    idx, ball, tog = namunalar(50)
    for nom, m in (("ko'rilgan", ~yangi), ("ko'rilmagan", yangi)):
        b, t = ball[m].flatten().numpy(), tog[m].flatten().numpy()
        print(f"  {nom:<12} to'g'ri ulushi {t.mean():.3f}, AUC(CLIP bahosi -> hammasi to'g'ri) "
              f"{roc_auc_score(t, b):.3f}")
    print("  AUC 0.5 - tasodifiy, 1.0 - mukammal ajratish")

    print("\n=== 4. Narx va xulosa ===")
    print(f"  best-of-{K}: {K} barobar ko'p generatsiya + {K} ta CLIP baholash har so'rovga")
    k8 = np.array(natija[8]).mean(0)
    k1 = np.array(natija[1]).mean(0)
    print(f"  ko'rilmagan: {k1[1]:.3f} -> {k8[1]:.3f}; ko'rilgan: {k1[0]:.3f} -> {k8[0]:.3f}")
    if k8[1] - k1[1] < k8[0] - k1[0]:
        print("  qayta saralash ko'rilmagan kombinatsiyada kamroq yordam berdi: tanlovchi CLIP ham")
        print("  bu kombinatsiyalarni yomonroq taniydi (1-misol) - ko'r nuqtalari generator bilan umumiy")


if __name__ == "__main__":
    main()

=== 1. Quvur: matn -> shartli VAE (K ta nomzod) -> CLIP bahosi -> eng yaxshisi ===
  CLIP va VAE faqat ko'rilgan 14 kombinatsiyada o'rgatilgan; baholovchi - alohida

=== 2. Best-of-K: CLIP bo'yicha eng yuqori nomzod (3 urug', 'hammasi to'g'ri' ulushi) ===
    K    ko'rilgan   ko'rilmagan
    1    0.333       0.285
    2    0.361       0.333
    4    0.433       0.375
    8    0.460       0.375
  ko'rilgan    K = 8 - K = 1: +0.127 (SE 0.010) -> sezilarli
  ko'rilmagan  K = 8 - K = 1: +0.090 (SE 0.018) -> sezilarli

=== 3. CLIP bahosi to'g'rilikni qanchalik ajratadi (AUC, urug' 50) ===
  ko'rilgan    to'g'ri ulushi 0.337, AUC(CLIP bahosi -> hammasi to'g'ri) 0.896
  ko'rilmagan  to'g'ri ulushi 0.273, AUC(CLIP bahosi -> hammasi to'g'ri) 0.764
  AUC 0.5 - tasodifiy, 1.0 - mukammal ajratish

=== 4. Narx va xulosa ===
  best-of-8: 8 barobar ko'p generatsiya + 8 ta CLIP baholash har so'rovga
  ko'rilmagan: 0.285 -> 0.375; ko'rilgan: 0.333 -> 0.460
  qayta saralash ko'rilmagan kombinatsiyada kamroq yordam berdi: tanlovchi CLIP ham
  bu kombinatsiyalarni yomonroq taniydi (1-misol) - ko'r nuqtalari generator bilan umumiy

logit = zi @ zt.T                                     # uzunlik ham ta'sir qiladi # ⚠️
zi, zt = F.normalize(zi, dim=-1), F.normalize(zt, dim=-1)                     # ✅
logit = log_harorat.exp().clamp(max=100) * zi @ zt.T

loss = F.cross_entropy(logit, nishon)                 # faqat rasm -> matn    # ⚠️
loss = (F.cross_entropy(logit, nishon) + F.cross_entropy(logit.T, nishon)) / 2  # ✅

logit = log_harorat.exp() * zi @ zt.T                 # portlashi mumkin      # ⚠️
logit = log_harorat.exp().clamp(max=100) * zi @ zt.T                          # ✅

aniqlik = (bashorat == Y_test).float().mean()         # test = o'quv kombinatsiyalari # ⚠️
aniqlik_yangi = (bashorat[yangi] == Y_test[yangi]).float().mean()             # ✅

c = nn.Embedding(18, 32)(torch.tensor([yangi_kombo]))   # o'rgatilmagan vektor  # ⚠️
c = matn_shart(["katta ko'k uchburchak"])               # so'zlar orqali       # ✅

eng = nomzodlar[clip_ball.argmax()]; baho = clip_ball.max()                   # ⚠️
eng = nomzodlar[clip_ball.argmax()]; baho = atribut_hakam(eng)                # ✅

idx = [lugat.get(w, 0) for w in matn.split()]         # "emas" yo'qoladi      # ⚠️
nomalum = [w for w in matn.split() if w not in lugat]                         # ✅
if nomalum:
    print("ogohlantirish: noma'lum so'zlar", nomalum)

1.  # CLIP ning ikki encoderi va umumiy fazo nima uchun kerak?
2.  # InfoNCE da B = 128 bo'lsa tasodifiy boshlanishdagi loss taxminan?
3.  # nega bizning InfoNCE loss nolga tushmadi?
4.  # zero-shot da yangi sinf qo'shish uchun nima kerak?
5.  # 18 ta tavsifdan tasodifiy tanlashda aniqlik?
6.  # "qizil kichik kvadrat" nega "qizil kichik doira" deb tanildi?
7.  # R-precision ta'rifi (R = 40)?
8.  # so'zlar xaltasi encoderi uchun "katta qizil doira" va "qizil katta doira" kosinusi?
9.  # ko'rilmagan kombinatsiyada ID sharti nima beradi?
10. # cross-attention da Q, K, V qayerdan olinadi?
11. # best-of-8 ning narxi?
12. # nega tanlovchi CLIP bilan baholash noto'g'ri?

1.  zi, zt = rasm_enc(X), matn_enc(T)
    loss = F.cross_entropy(zi @ zt.T, torch.arange(len(X)))

2.  test_X, _, test_Y = toplam(korilgan, 40, seed=1)
    print("kompozitsion aniqlik:", zero_shot(test_X, test_Y))

3.  shart = nn.Embedding(18, 32)
    rasm = dekoder(z, shart(torch.tensor([KOMBO.index(("ko'k", "katta", "uchburchak"))])))

4.  nomzodlar = [generatsiya(sorov) for _ in range(8)]
    eng = max(nomzodlar, key=lambda r: clip_ball(r, sorov))
    print("sifat:", clip_ball(eng, sorov))

5.  top = (matn_enc(["qizil emas doira"]) @ galereya.T).argsort(descending=True)[:10]
    print("qizil bo'lmagan doiralar topildi")