26.9-dars: Generativ AI etikasi va xavfsizligi

XAVF                     NIMA BO'LADI                         HIMOYA QATLAMLARI
deepfake va              ishonarli soxta rasm/ovoz/video,     kelib chiqish (C2PA), watermark,
dezinformatsiya          real odam nomidan                    detektorlar, platforma siyosati
mualliflik huquqi        o'quv ma'lumotida himoyalangan       litsenziya auditi, opt-out,
                         asarlar; uslub va nusxa              dublikatlarni olib tashlash, filtr
yodlab olish va          o'quv namunasini aynan qaytarish     dedup, erta to'xtatish, DP-SGD,
maxfiylik                (shaxsiy ma'lumot, rasm, kod)        eng yaqin qo'shni auditi
tarafkashlik             nomutanosiblik saqlanadi yoki        guruh ulushini o'lchash,
                         KUCHAYADI                            shartli generatsiya, balans
zararli kontent          zo'ravonlik, firibgarlik matnlari,   kirish/chiqish filtrlari,
                         xavfli yo'riqnomalar                 red-teaming, foydalanish siyosati

UMUMIY TAMOYIL (25.13 bilan bir xil):
  bitta "sehrli" himoya yo'q - qatlamlar; har qatlam o'lchanadi
  (TPR, FPR, nusxa ulushi, guruh ulushi) va cheklovlari hujjatlanadi

MUAMMO:
  generatsiya sifati oshgan sari "ko'z bilan" ajratish qiyinlashadi
  xavf: real odam nomidan soxta bayonot, firibgarlik, obro'ga zarar,
        "hamma narsa soxta bo'lishi mumkin" degan umumiy ishonchsizlik

HIMOYA YO'NALISHLARI:
  1) FAOL belgilash (generatsiya paytida):
     watermark - chiqishga ko'rinmas signal (2.6, 3-misol)
     kelib chiqish metama'lumoti - C2PA 2.8-bob
  2) PASSIV aniqlash (keyin, belgisiz kontentda):
     detektor-klassifikator - artefaktlarni o'rganadi (2.7, 4-misol)
     yangi generatorda yiqilishi mumkin
  3) JARAYON:
     real odam tasvirini yaratishga rozilik talablari, platforma siyosati,
     shikoyat va olib tashlash jarayoni, media savodxonlik

ASIMMETRIYA:
  faol belgilash - model egasining hamkorligini talab qiladi
  passiv aniqlash - hamkorliksiz, lekin doim "quvlash" o'yini

SAVOLLAR (huquqiy javob mamlakat va holatga qarab farq qiladi):
  o'quv ma'lumotiga asarni kiritish mumkinmi? (litsenziya, ruxsat)
  modelning chiqishi kimga tegishli?
  chiqish o'quvdagi asarning nusxasi bo'lsa-chi?

MUHANDISLIK TOMONI (bizning qo'limizdagi):
  ma'lumot manbalari va litsenziyalar reyestri ("datasheet")
  opt-out: mualliflar o'z asarlarini chiqarib tashlashni so'ray oladi
  DUBLIKATLARNI olib tashlash - ko'p takrorlangan namuna ko'proq yodlanadi
  chiqishda o'quv to'plamiga yaqinlik tekshiruvi (1-misol usuli)
  uslub va nusxa farqi: "uslubda" chizish va aynan nusxa - boshqa-boshqa

YODLAB OLISH: model o'quv namunasini (deyarli) aynan qaytaradi
  xavf: shaxsiy rasm, tibbiy yozuv, telefon raqami, kalit, himoyalangan matn

O'LCHOVLAR (1-misol):
  nusxa ulushi      - generatsiyaning qancha qismi o'quv namunasiga AYNAN teng
  NN nisbati        - mean NN(G -> o'quv) / mean NN(G -> held-out)
                      held-out o'quv bilan TENG hajmda bo'lishi shart!
                      ~1 - umumlashma; << 1 - o'quvga yopishgan
  a'zolik hujumi    - log p(x) bo'yicha "bu namuna o'quvda bo'lganmi?"
  (MIA) AUC           0.5 - sizish yo'q; 1.0 - to'liq ajraladi

1-MISOL (MADE, 0/1 piksellar, 1000 namuna):
  n     qadam  nusxa   nisbat  MIA_AUC
  40      300   0.6%    0.73    0.991
  40     3000  85.9%    0.07    1.000     <- 40 ta rasmning 40 tasi ham qaytarildi
  200    3000  15.3%    0.65    0.979
  800     300   0.1%    0.98    0.582
  800    3000   2.4%    0.89    0.817

OMILLAR: kichik ma'lumot + uzoq o'rgatish = yodlash
  dublikat namunalar (ko'p takror -> ko'proq yodlanadi)

HIMOYA:
  ko'proq va DEDUPLIKATSIYALANGAN ma'lumot
  erta to'xtatish (val NLL bo'yicha): n=200 da nusxa 15.3% -> 0.1%
  regulyarizatsiya, kichikroq model
  differensial maxfiylik (DP-SGD): har namunaning gradientini kesish + shovqin
    -> bitta namunaning ta'siri matematik chegaralanadi (aniqlik narxiga)
  chiqish filtri: o'quv to'plamiga juda yaqin namunalarni rad etish

SAVOL: o'quvda guruhlar nisbati 70/30 bo'lsa, generatsiyada ham 70/30 mi?

O'LCHASH:
  alohida (generatorga ko'rsatilmagan) rasmlarda o'rgatilgan klassifikator
  avval ASBOBNI tekshirish: haqiqiy 70/30 aralashmani qanday o'lchaydi? 0.300-bob
  keyin generatsiyada ozchilik ulushi, 5 urug', 0.30 dan farq va SE

2-MISOL (1 va 7 raqamlari; ikkala yo'nalishda):
  sozlama        ozchilik 7      ozchilik 1
  MADE T=1.0       0.307           0.313      - saqlanadi (farq sezilarli emas)
  MADE T=0.7       0.232 *         0.255 *    - KUCHAYADI
  MADE T=0.5       0.184 *         0.169 *    - yanada kuchayadi
  GMM k=2          0.278 *         0.313 *    - kichik siljish, yo'nalishi har xil
  GMM k=10         0.291           0.300
  shartli T=0.5    0.300           0.300      - nisbat TASHQARIDAN beriladi

NEGA PAST HARORAT KO'PCHILIKNI KUCHAYTIRADI:
  T < 1 - taqsimotni "o'tkirlaydi": ehtimolli yo'llar yanada ehtimolli
  birinchi piksellarda ko'pchilik guruhiga xos qiymat ko'proq ehtimolli
  -> dastlabki qarorlar ko'pchilik tomonga og'adi, qolgan piksellar ergashadi
  xuddi shu mexanizm: truncation (GAN), yuqori guidance (diffusion, 26.6)

HIMOYA:
  guruh ulushini generatsiya SOZLAMASI bilan birga o'lchash
  shartli generatsiya: guruh nisbatini aniq belgilash
  o'quv ma'lumotini muvozanatlash; lekin "to'g'ri" nisbat - siyosat qarori

RASM (3-misol): kalitli pseudo-tasodifiy naqsh
  w = +-1 naqsh (16 x 16), torch.Generator(kalit) bilan
  joylash:   x' = clip(x + a * w, 0, 1)            a = 0.04 (4%)
  aniqlash:  r = yuqori_chastota(x')  (x - 3x3 o'rtacha)
             z = sqrt(N) * corr(r, yuqori_chastota(w))
             z > 4 -> "watermark bor"
  kalitni bilmasdan naqshni topish qiyin; kalit bilan tekshirish arzon

3-MISOL NATIJALARI:
  a      PSNR   TPR          FPR (toza, boshqa kalit, haqiqiy)
  0.01   40.4   47.2%        0.0%
  0.04   28.6   100.0%       0.0%
  chidamlilik (a = 0.04): shovqin 0.05 - 100%, JPEG 70 - 99.7%,
                          JPEG 50 - 93.2%, xiralash 3x3 - 0.0%,
                          1 piksel siljitish - 0.0% (qidiruv bilan 100%)

MATN ("green list" g'oyasi, nazariy):
  har qadamda: urug' = hash(oldingi token, kalit)
  lug'at tasodifiy ikkiga: "yashil" (ulush gamma) va "qizil"
  generatsiyada yashil tokenlar logitiga + delta
  aniqlash: T tokenda yashillar soni |s|_G
     z = (|s|_G - gamma * T) / sqrt(T * gamma * (1 - gamma))
  watermarksiz matnda yashil ulushi ~ gamma -> z ~ 0
  zaif joylar: parafraz (boshqa model bilan qayta yozish), qisqa matn,
               past entropiyali matn (kod, faktlar - tanlov kam)

DETEKTOR = klassifikator: haqiqiy (0) va sintetik (1)
  u "sintetiklik"ni emas, O'RGATILGAN GENERATORLAR ARTEFAKTINI o'rganadi

4-MISOL (AUC, 3 urug'; qatorda o'quv, ustunda test):
  o'quv / test     GMM     VAE    VAE+hist
  GMM             0.952   0.993    0.627
  VAE             0.975   0.999    0.645
  VAE+hist        0.758   0.838    0.839
  GMM+VAE         0.962   0.997    0.641

NIMA BO'LDI:
  GMM va VAE umumiy artefaktga ega: oraliq piksellar KO'P (0.566, 0.586;
  haqiqiyda 0.419), nol piksellar KAM (0.379, 0.376; haqiqiyda 0.491)
  -> bir-birida yaxshi umumlashadi
  VAE+hist - gistogramma haqiqiyga moslangan (0.488, 0.420)
  -> artefakt yo'q, detektor yiqiladi: tushish 0.33-0.36 AUC (sezilarli)
  FPR 5% da TPR: 0.83-0.99 -> 0.15-0.17

XULOSA:
  detektor bahosi faqat O'RGATILGAN generatorlar uchun to'g'ri
  yangi generator artefaktni tuzatsa - detektor ko'r
  -> detektorni doim "yangi generator" (hold-out generator) bilan baholang

KONTENT KELIB CHIQISHI (provenance):
  C2PA - kontentga kriptografik imzolangan "manifest" biriktirish standarti:
    kim yaratdi, qaysi vosita (masalan, generativ model), qanday tahrirlandi
  imzo buzilsa - aniqlanadi; lekin metama'lumotni OLIB TASHLASH mumkin
  -> watermark (kontentning o'zida) va manifest (yonida) bir-birini to'ldiradi

MODEL KARTASI (model card) - model bilan birga hujjat:
  maqsad va maqsad bo'lmagan qo'llanishlar
  o'quv ma'lumoti manbalari va litsenziyalari (datasheet)
  baholash: sifat + xavf o'lchovlari (nusxa ulushi, guruh ulushi, ...)
  ma'lum cheklovlar va xavflar; watermark / kelib chiqish usuli

TASHKILIY VA HUQUQIY CHORALAR (umumiy):
  foydalanish siyosati: taqiqlangan qo'llanishlar (real odam nomidan soxta)
  kirish/chiqish filtrlari va red-teaming 25.13-bob
  shikoyat va olib tashlash jarayoni; opt-out
  audit jurnali: kim, qachon, nimani generatsiya qildi
  xavfni baholash - chiqarishdan OLDIN; qonunchilik talablari
  mamlakatga qarab farq qiladi - yuristlar bilan birga

import numpy as np
import torch
from sklearn.metrics import roc_auc_score

# yodlash: teng hajmli held-out bilan eng yaqin qo'shni
d_oq = torch.cdist(G, X_oquv).min(1).values
d_ho = torch.cdist(G, X_heldout).min(1).values      # len(X_heldout) == len(X_oquv)
nusxa = (d_oq == 0).float().mean()                  # uzluksizda: d_oq < chegara
nisbat = d_oq.mean() / d_ho.mean()                  # ~1 yaxshi, << 1 yodlash

# a'zolik hujumi: log p(x) bo'yicha AUC
auc = roc_auc_score(np.r_[np.ones(n), np.zeros(n)],
                    np.r_[model.logp(X_oquv), model.logp(X_heldout)])

# guruh ulushi: alohida klassifikator, avval haqiqiy aralashmada tekshirilgan
ulush = np.mean(klf.predict(G) == ozchilik)

# watermark
w = (torch.randint(0, 2, (16, 16), generator=torch.Generator().manual_seed(kalit)) * 2 - 1)
x_w = np.clip(x + a * w.numpy(), 0, 1)
z = np.sqrt(N) * corr(yuqori_chastota(x_w), yuqori_chastota(w))   # z > 4

# detektor: o'quvda KO'RILMAGAN generatorda baholash
auc_yangi = roc_auc_score(y, det.predict_proba(xus(np.r_[X_real, G_yangi]))[:, 1])

xavflar: deepfake, mualliflik, yodlash, tarafkashlik, zararli kontent
yodlash: nusxa ulushi + NN nisbati (teng held-out) + a'zolik hujumi AUC
tarafkashlik: guruh ulushi har generatsiya sozlamasida; shartli nisbat
watermark: kalitli naqsh + z-test; TPR/FPR, empirik chegara, hujumlar
detektor: artefaktni o'rganadi; yangi generatorda baholash shart
kelib chiqish (C2PA) + model kartasi + jarayon

"""Yodlab olish: kichik ma'lumotda uzoq o'rgatilgan avtoregressiv model o'quv namunalarini qaytaradimi?"""

import copy

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

D = 64


class MADE(nn.Module):
    """Avtoregressiv model: p(x) = p(x_1) p(x_2 | x_1) ... ; niqobli bitta yashirin qatlam."""

    def __init__(self, h=256, seed=0):
        super().__init__()
        g = torch.Generator().manual_seed(seed)
        m = torch.randint(1, D, (h,), generator=g)              # yashirin birlik "darajasi"
        tartib = torch.arange(1, D + 1)
        self.register_buffer("m1", (m[:, None] >= tartib[None, :]).float())
        self.register_buffer("m2", (tartib[:, None] > m[None, :]).float())
        self.l1, self.l2 = nn.Linear(D, h), nn.Linear(h, D)

    def forward(self, x):
        h = F.relu(F.linear(x, self.l1.weight * self.m1, self.l1.bias))
        return F.linear(h, self.l2.weight * self.m2, self.l2.bias)

    def logp(self, x):
        return -F.binary_cross_entropy_with_logits(self(x), x, reduction="none").sum(1)

    @torch.no_grad()
    def namuna(self, n, g):
        x = torch.zeros(n, D)
        for i in range(D):                                      # piksel-piksel, 64 qadam
            p = torch.sigmoid(self(x)[:, i])
            x[:, i] = (torch.rand(n, generator=g) < p).float()
        return x


def orgat(X, qadamlar, seed, X_val=None):
    """X_val berilsa - har 100 qadamda val NLL; eng yaxshi holat qaytariladi (erta to'xtatish)."""
    torch.manual_seed(seed)
    model = MADE(seed=seed)
    opt = torch.optim.Adam(model.parameters(), lr=3e-3)
    g = torch.Generator().manual_seed(seed)
    B = min(len(X), 64)
    eng, eng_nll, eng_qadam = None, float("inf"), 0
    for q in range(1, qadamlar + 1):
        xb = X[torch.randint(0, len(X), (B,), generator=g)]
        loss = -model.logp(xb).mean()
        opt.zero_grad()
        loss.backward()
        opt.step()
        if X_val is not None and q % 100 == 0:
            with torch.no_grad():
                nll = -model.logp(X_val).mean().item()
            if nll < eng_nll:
                eng, eng_nll, eng_qadam = copy.deepcopy(model.state_dict()), nll, q
    if eng is not None:
        model.load_state_dict(eng)
    model.eval()
    return model, eng_qadam


def eng_yaqin(A, B):
    """A dagi har namuna uchun B gacha eng kichik Hamming masofasi va indeksi."""
    d = torch.cdist(A, B, p=1)
    return d.min(1).values, d.argmin(1)


def olchov(model, oq, ho, seed=1):
    G = model.namuna(1000, torch.Generator().manual_seed(seed))
    d_oq, j = eng_yaqin(G, oq)
    d_ho, _ = eng_yaqin(G, ho)
    with torch.no_grad():
        lp_oq, lp_ho = model.logp(oq), model.logp(ho)
    y = np.r_[np.ones(len(oq)), np.zeros(len(ho))]
    auc = roc_auc_score(y, np.r_[lp_oq.numpy(), lp_ho.numpy()])      # a'zolik hujumi
    return {"nusxa": (d_oq == 0).float().mean().item(), "nusxa_ho": (d_ho == 0).float().mean().item(),
            "d_oq": d_oq.mean().item(), "d_ho": d_ho.mean().item(),
            "nll_oq": -lp_oq.mean().item(), "nll_ho": -lp_ho.mean().item(), "auc": auc,
            "G": G, "j": j, "d": d_oq}


def chiz(x):
    return ["".join("##" if v else " ." for v in qator) for qator in x.reshape(8, 8).int().tolist()]


def main() -> None:
    torch.set_num_threads(1)
    X_hamma, _ = load_digits(return_X_y=True)
    X_hamma = torch.tensor((X_hamma > 7).astype(np.float32))       # 0/1 piksellar
    perm = np.random.default_rng(0).permutation(len(X_hamma))

    print("=== 1. O'quv to'plami hajmi x o'rgatish uzunligi (1000 ta namuna) ===")
    print("  held-out to'plam o'quv bilan TENG hajmda - NN masofalar adolatli")
    print("  n     qadam  nusxa   nusxa_ho  NN_oquv  NN_ho  nisbat  NLL_oquv  NLL_ho  MIA_AUC")
    natija = {}
    for n in (40, 200, 800):
        oq, ho = X_hamma[perm[:n]], X_hamma[perm[n:2 * n]]
        for qadam in (300, 3000):
            model, _ = orgat(oq, qadam, seed=0)
            r = olchov(model, oq, ho)
            natija[(n, qadam)] = r
            print(f"  {n:<5} {qadam:>5} {r['nusxa']:>6.1%} {r['nusxa_ho']:>9.1%} {r['d_oq']:>8.2f} "
                  f"{r['d_ho']:>6.2f} {r['d_oq'] / r['d_ho']:>7.2f} {r['nll_oq']:>9.1f} "
                  f"{r['nll_ho']:>7.1f} {r['auc']:>8.3f}")

    print("\n=== 2. Yodlangan namuna: generatsiya va o'quv to'plamidagi asli ===")
    r = natija[(40, 3000)]
    nusxa_i = torch.nonzero(r["d"] == 0)[:, 0]
    asl = r["j"][nusxa_i]
    print(f"  n=40, 3000 qadam: {len(nusxa_i)} ta nusxa, ular {len(torch.unique(asl))} ta "
          f"turli o'quv rasmidan (40 tadan)")
    sanoq = torch.bincount(asl, minlength=40)
    print(f"  eng ko'p qaytarilgan o'quv rasmi: {int(sanoq.max())} marta")
    i = int(nusxa_i[0])
    oq = X_hamma[perm[:40]]
    print("  generatsiya          o'quvdagi asli (Hamming 0)")
    for a, b in zip(chiz(r["G"][i]), chiz(oq[r["j"][i]])):
        print(f"  {a}     {b}")

    print("\n=== 3. Himoya: val NLL bo'yicha erta to'xtatish (n = 200) ===")
    oq, ho = X_hamma[perm[:200]], X_hamma[perm[200:400]]
    val = X_hamma[perm[400:600]]                                    # uchinchi, alohida to'plam
    model, q = orgat(oq, 3000, seed=0, X_val=val)
    e = olchov(model, oq, ho)
    u = natija[(200, 3000)]
    print(f"  tanlangan qadam: {q} (3000 dan)")
    print(f"  {'':<16} {'nusxa':>7} {'NLL_oquv':>9} {'NLL_ho':>7} {'MIA_AUC':>8}")
    print(f"  {'3000 qadam':<16} {u['nusxa']:>7.1%} {u['nll_oq']:>9.1f} {u['nll_ho']:>7.1f} {u['auc']:>8.3f}")
    print(f"  {'erta to`xtatish':<16} {e['nusxa']:>7.1%} {e['nll_oq']:>9.1f} {e['nll_ho']:>7.1f} "
          f"{e['auc']:>8.3f}".replace("`", "'"))
    if e["nusxa"] < u["nusxa"] and e["nll_ho"] < u["nll_ho"]:
        print("  erta to'xtatish nusxalarni kamaytirdi VA held-out NLL ni yaxshiladi")
    if e["auc"] > 0.6:
        print(f"  lekin a'zolik hujumi AUC {e['auc']:.3f} > 0.5 - sizish to'liq yo'qolmadi")


if __name__ == "__main__":
    main()

=== 1. O'quv to'plami hajmi x o'rgatish uzunligi (1000 ta namuna) ===
  held-out to'plam o'quv bilan TENG hajmda - NN masofalar adolatli
  n     qadam  nusxa   nusxa_ho  NN_oquv  NN_ho  nisbat  NLL_oquv  NLL_ho  MIA_AUC
  40      300   0.6%      0.0%     6.59   9.01    0.73      10.3    32.1    0.991
  40     3000  85.9%      0.0%     0.54   7.87    0.07       3.9    83.2    1.000
  200     300   0.1%      0.2%     6.90   7.41    0.93      16.6    21.5    0.787
  200    3000  15.3%      0.9%     3.79   5.80    0.65       7.8    36.5    0.979
  800     300   0.1%      0.1%     6.14   6.30    0.98      18.5    19.7    0.582
  800    3000   2.4%      1.1%     4.12   4.65    0.89      12.7    19.3    0.817

=== 2. Yodlangan namuna: generatsiya va o'quv to'plamidagi asli ===
  n=40, 3000 qadam: 859 ta nusxa, ular 40 ta turli o'quv rasmidan (40 tadan)
  eng ko'p qaytarilgan o'quv rasmi: 45 marta
  generatsiya          o'quvdagi asli (Hamming 0)
   . . .#### . . .      . . .#### . . .
   . . .#### . . .      . . .#### . . .
   . .#### . . . .      . .#### . . . .
   .#### . .## . .      .#### . .## . .
   . .######## . .      . .######## . .
   . . . .## . . .      . . . .## . . .
   . . . .## . . .      . . . .## . . .
   . . . .## . . .      . . . .## . . .

=== 3. Himoya: val NLL bo'yicha erta to'xtatish (n = 200) ===
  tanlangan qadam: 300 (3000 dan)
                     nusxa  NLL_oquv  NLL_ho  MIA_AUC
  3000 qadam         15.3%       7.8    36.5    0.979
  erta to'xtatish     0.1%      16.6    21.5    0.787
  erta to'xtatish nusxalarni kamaytirdi VA held-out NLL ni yaxshiladi
  lekin a'zolik hujumi AUC 0.787 > 0.5 - sizish to'liq yo'qolmadi

"""Tarafkashlik kuchayishi: 70/30 o'quv ma'lumotidan generatsiyada nisbat saqlanadimi?"""

import warnings

import numpy as np
import torch
import torch.nn as nn
import torch.nn.functional as F
from sklearn.datasets import load_digits
from sklearn.decomposition import PCA
from sklearn.linear_model import LogisticRegression
from sklearn.mixture import GaussianMixture

D = 64
URUGLAR = range(5)


class MADE(nn.Module):
    """Avtoregressiv model; shartli=True bo'lsa guruh (0/1) yashirin qatlamga beriladi."""

    def __init__(self, h=256, seed=0, shartli=False):
        super().__init__()
        g = torch.Generator().manual_seed(seed)
        m = torch.randint(1, D, (h,), generator=g)
        tartib = torch.arange(1, D + 1)
        self.register_buffer("m1", (m[:, None] >= tartib[None, :]).float())
        self.register_buffer("m2", (tartib[:, None] > m[None, :]).float())
        self.l1, self.l2 = nn.Linear(D, h), nn.Linear(h, D)
        self.shart = nn.Embedding(2, h) if shartli else None

    def forward(self, x, c=None):
        a = F.linear(x, self.l1.weight * self.m1, self.l1.bias)
        if self.shart is not None:
            a = a + self.shart(c)
        return F.linear(F.relu(a), self.l2.weight * self.m2, self.l2.bias)

    @torch.no_grad()
    def namuna(self, n, g, T=1.0, c=None):
        x = torch.zeros(n, D)
        for i in range(D):
            p = torch.sigmoid(self(x, c)[:, i] / T)
            x[:, i] = (torch.rand(n, generator=g) < p).float()
        return x


def orgat_made(X, c, seed, shartli=False, qadamlar=600):
    torch.manual_seed(seed)
    model = MADE(seed=seed, shartli=shartli)
    opt = torch.optim.Adam(model.parameters(), lr=3e-3)
    g = torch.Generator().manual_seed(seed)
    for _ in range(qadamlar):
        i = torch.randint(0, len(X), (64,), generator=g)
        xb = X[i]
        loss = F.binary_cross_entropy_with_logits(model(xb, c[i]), xb, reduction="none").sum(1).mean()
        opt.zero_grad()
        loss.backward()
        opt.step()
    return model.eval()


def toplam(pool, y, rng, n, kop, oz, ulush=0.3):
    i_oz = rng.choice(pool[y[pool] == oz], int(round(n * ulush)), replace=False)
    i_kop = rng.choice(pool[y[pool] == kop], n - len(i_oz), replace=False)
    return np.r_[i_kop, i_oz]


def tajriba(X, B, y, pool, klf, kop, oz):
    """Har urug'da: yangi 70/30 o'quv to'plami, modellar, 1000 namuna; ozchilik ulushi."""
    sozlama = ["MADE T=1.0", "MADE T=0.7", "MADE T=0.5", "GMM k=2", "GMM k=10", "shartli T=0.5"]
    res = {s: [] for s in sozlama}
    for seed in URUGLAR:
        oq = toplam(pool, y, np.random.default_rng(100 + seed), 150, kop, oz)
        Xt = torch.tensor(B[oq])
        c = torch.tensor((y[oq] == oz).astype(np.int64))
        model = orgat_made(Xt, c, seed)
        for T in (1.0, 0.7, 0.5):
            G = model.namuna(1000, torch.Generator().manual_seed(seed), T).numpy()
            res[f"MADE T={T}"].append(np.mean(klf.predict(G) == oz))
        pca = PCA(16, random_state=seed).fit(X[oq])
        for k in (2, 10):
            with warnings.catch_warnings():
                warnings.simplefilter("ignore")
                gmm = GaussianMixture(k, random_state=seed).fit(pca.transform(X[oq]))
            Z, _ = gmm.sample(1000)
            G = (pca.inverse_transform(Z) > 7).astype(np.float32)
            res[f"GMM k={k}"].append(np.mean(klf.predict(G) == oz))
        sh = orgat_made(Xt, c, seed, shartli=True)
        cn = torch.tensor(np.r_[np.zeros(700), np.ones(300)].astype(np.int64))  # nisbat ANIQ
        G = sh.namuna(1000, torch.Generator().manual_seed(seed), 0.5, cn).numpy()
        res["shartli T=0.5"].append(np.mean(klf.predict(G) == oz))
    return {s: np.array(v) for s, v in res.items()}


def main() -> None:
    torch.set_num_threads(1)
    X, y = load_digits(return_X_y=True)
    B = (X > 7).astype(np.float32)
    ikki = np.flatnonzero((y == 1) | (y == 7))
    rng = np.random.default_rng(0)
    rng.shuffle(ikki)
    baho_i, pool = ikki[:120], ikki[120:]            # klassifikator faqat baho_i da
    klf = LogisticRegression(max_iter=2000).fit(B[baho_i], y[baho_i])

    print("=== 1. O'lchov asbobi ===")
    print(f"  guruhlar: raqam 1 va raqam 7; klassifikator {len(baho_i)} ta alohida rasmda")
    print(f"  generator uchun qolgan pool: {len(pool)} rasm (1: {np.sum(y[pool] == 1)}, "
          f"7: {np.sum(y[pool] == 7)})")
    acc = np.mean(klf.predict(B[pool]) == y[pool])
    print(f"  klassifikator aniqligi pool da: {acc:.3f}")
    for kop, oz in ((1, 7), (7, 1)):
        r = np.random.default_rng(5)
        haq = toplam(pool, y, r, 150, kop, oz)
        print(f"  haqiqiy 70/30 aralashma (ozchilik {oz}): o'lchangan ulush "
              f"{np.mean(klf.predict(B[haq]) == oz):.3f}")

    barcha = []
    for bolim, (kop, oz) in enumerate(((1, 7), (7, 1)), 2):
        print(f"\n=== {bolim}. Ko'pchilik {kop}, ozchilik {oz} (o'quvda 30%), {len(URUGLAR)} urug' ===")
        res = tajriba(X, B, y, pool, klf, kop, oz)
        print("  sozlama        ozchilik ulushi (urug'lar)            o'rtacha  0.30 dan farq (SE)")
        xulosa = {}
        for s, v in res.items():
            f = v - 0.3
            se = f.std(ddof=1) / np.sqrt(len(f))
            xulosa[s] = f.mean() if abs(f.mean()) > max(2 * se, 1e-9) else 0.0
            print(f"  {s:<14} {', '.join(f'{x:.3f}' for x in v)}  {v.mean():>8.3f}  "
                  f"{f.mean():+.3f} ({se:.3f})" + (" *" if xulosa[s] else ""))
        kuch = [s for s, f in xulosa.items() if f < 0]
        print(f"  ozchilik sezilarli KAMAYGAN (* - 2*SE dan katta): {', '.join(kuch) or 'yo`q'}"
              .replace("`", "'"))
        barcha.append(set(kuch))
    ikkala = sorted(barcha[0] & barcha[1])
    print(f"\n  ikkala yo'nalishda ham ozchilik kamaygan: {', '.join(ikkala) or 'hech biri'}")
    print("  ⭐ Ulushni o'lchang: generatsiya sozlamasi (harorat) nisbatni o'zgartirishi mumkin")

if __name__ == "__main__":
    main()

=== 1. O'lchov asbobi ===
  guruhlar: raqam 1 va raqam 7; klassifikator 120 ta alohida rasmda
  generator uchun qolgan pool: 241 rasm (1: 119, 7: 122)
  klassifikator aniqligi pool da: 1.000
  haqiqiy 70/30 aralashma (ozchilik 7): o'lchangan ulush 0.300
  haqiqiy 70/30 aralashma (ozchilik 1): o'lchangan ulush 0.300

=== 2. Ko'pchilik 1, ozchilik 7 (o'quvda 30%), 5 urug' ===
  sozlama        ozchilik ulushi (urug'lar)            o'rtacha  0.30 dan farq (SE)
  MADE T=1.0     0.325, 0.285, 0.316, 0.309, 0.301     0.307  +0.007 0.007-bob
  MADE T=0.7     0.263, 0.199, 0.245, 0.243, 0.210     0.232  -0.068 0.012-bob *
  MADE T=0.5     0.266, 0.135, 0.164, 0.201, 0.156     0.184  -0.116 0.023-bob *
  GMM k=2        0.288, 0.273, 0.287, 0.268, 0.273     0.278  -0.022 0.004-bob *
  GMM k=10       0.287, 0.306, 0.304, 0.265, 0.291     0.291  -0.009 0.007-bob
  shartli T=0.5  0.300, 0.300, 0.300, 0.300, 0.300     0.300  +0.000 0.000-bob
  ozchilik sezilarli KAMAYGAN (* - 2*SE dan katta): MADE T=0.7, MADE T=0.5, GMM k=2

=== 3. Ko'pchilik 7, ozchilik 1 (o'quvda 30%), 5 urug' ===
  sozlama        ozchilik ulushi (urug'lar)            o'rtacha  0.30 dan farq (SE)
  MADE T=1.0     0.312, 0.358, 0.326, 0.268, 0.301     0.313  +0.013 0.015-bob
  MADE T=0.7     0.249, 0.317, 0.246, 0.234, 0.229     0.255  -0.045 0.016-bob *
  MADE T=0.5     0.144, 0.213, 0.163, 0.172, 0.154     0.169  -0.131 0.012-bob *
  GMM k=2        0.306, 0.302, 0.319, 0.306, 0.334     0.313  +0.013 0.006-bob *
  GMM k=10       0.278, 0.295, 0.296, 0.321, 0.311     0.300  +0.000 0.007-bob
  shartli T=0.5  0.300, 0.300, 0.300, 0.300, 0.300     0.300  +0.000 0.000-bob
  ozchilik sezilarli KAMAYGAN (* - 2*SE dan katta): MADE T=0.7, MADE T=0.5

  ikkala yo'nalishda ham ozchilik kamaygan: MADE T=0.5, MADE T=0.7
  ⭐ Ulushni o'lchang: generatsiya sozlamasi (harorat) nisbatni o'zgartirishi mumkin

"""Ko'rinmas watermark: kalitli pseudo-tasodifiy naqsh, korrelyatsiya testi va chidamlilik."""

import io
import warnings

import numpy as np
import torch
from PIL import Image
from scipy.ndimage import uniform_filter
from sklearn.datasets import load_digits
from sklearn.decomposition import PCA
from sklearn.mixture import GaussianMixture

R = 16
CHEGARA = 4.0          # z > 4 -> "watermark bor" (N(0,1) da P ~ 3e-5)


def generator_rasmlar(n, seed):
    """Kichik generativ model (PCA + GMM) dan 8x8 raqamlar -> 16x16, [0, 1] oralig'ida."""
    X, _ = load_digits(return_X_y=True)
    pca = PCA(20, random_state=0).fit(X)
    with warnings.catch_warnings():
        warnings.simplefilter("ignore")
        gmm = GaussianMixture(20, random_state=0).fit(pca.transform(X))
        gmm.random_state = seed
        Z, _ = gmm.sample(n)
    x8 = np.clip(pca.inverse_transform(Z), 0, 16).reshape(n, 8, 8) / 16
    x16 = np.kron(x8, np.ones((1, 2, 2)))
    return np.clip(uniform_filter(x16, size=(1, 3, 3)), 0, 1)


def naqsh(kalit):
    g = torch.Generator().manual_seed(kalit)
    return (torch.randint(0, 2, (R, R), generator=g) * 2 - 1).numpy().astype(float)


def joyla(x, kalit, a):
    return np.clip(x + a * naqsh(kalit), 0, 1)


def yuqori_chastota(x):
    return x - uniform_filter(x, size=(1, 3, 3), mode="nearest")


def z_ball(x, kalit):
    """Normallangan korrelyatsiya: z = sqrt(N) * corr(qoldiq, naqsh); watermark yo'q -> ~N(0, 1)."""
    r = yuqori_chastota(x).reshape(len(x), -1)
    w = yuqori_chastota(naqsh(kalit)[None]).reshape(-1)
    r = r - r.mean(1, keepdims=True)
    w = w - w.mean()
    corr = (r @ w) / (np.linalg.norm(r, axis=1) * np.linalg.norm(w) + 1e-12)
    return np.sqrt(r.shape[1]) * corr


def jpeg(x, sifat):
    chiq = []
    for rasm in x:
        buf = io.BytesIO()
        Image.fromarray((rasm * 255).round().astype(np.uint8)).save(buf, "JPEG", quality=sifat)
        chiq.append(np.asarray(Image.open(io.BytesIO(buf.getvalue())), dtype=float) / 255)
    return np.array(chiq)


def psnr(a, b):
    return 10 * np.log10(1.0 / np.mean((a - b) ** 2))


def main() -> None:
    KALIT = 2026
    x = generator_rasmlar(1000, seed=1)
    toza = generator_rasmlar(1000, seed=2)             # watermarksiz generatsiya
    rng = np.random.default_rng(0)

    print("=== 1. Kuch va ko'rinmaslik (1000 rasm, z > 4 chegara) ===")
    print("  a      PSNR dB   TPR     z o'rtacha")
    for a in (0.01, 0.02, 0.04, 0.08):
        xw = joyla(x, KALIT, a)
        z = z_ball(xw, KALIT)
        print(f"  {a:<6} {psnr(x, xw):>7.1f} {np.mean(z > CHEGARA):>7.1%} {z.mean():>9.2f}")
    A = 0.04

    print(f"\n=== 2. Yolg'on musbat: watermark yo'q yoki boshqa kalit (a = {A}) ===")
    z0 = z_ball(toza, KALIT)
    z1 = z_ball(joyla(toza, 7, A), KALIT)
    print(f"  toza generatsiya:     FPR {np.mean(z0 > CHEGARA):.1%}, z o'rtacha {z0.mean():+.2f}, "
          f"std {z0.std():.2f}, max {z0.max():.2f}")
    print(f"  boshqa kalit (7):     FPR {np.mean(z1 > CHEGARA):.1%}, max {z1.max():.2f}")
    X, _ = load_digits(return_X_y=True)
    hq = np.clip(uniform_filter(np.kron(X.reshape(-1, 8, 8) / 16, np.ones((1, 2, 2))),
                                size=(1, 3, 3)), 0, 1)
    zh = z_ball(hq, KALIT)
    print(f"  haqiqiy raqamlar:     FPR {np.mean(zh > CHEGARA):.1%} ({len(hq)} ta), max {zh.max():.2f}")
    ortalar = np.array([z_ball(toza, kalit).mean() for kalit in range(100, 120)])
    print(f"  20 ta boshqa kalit, toza rasmlarda z o'rtachasi: {ortalar.min():+.2f} .. "
          f"{ortalar.max():+.2f}")
    if z0.std() < 0.9 or np.abs(ortalar).max() > 0.5:
        print("  -> toza z nazariy N(0, 1) emas: chegarani toza ma'lumotda empirik tekshiring")

    print(f"\n=== 3. Chidamlilik (a = {A}): TPR z > 4 da ===")
    xw = joyla(x, KALIT, A)
    hujumlar = [
        ("hech narsa", xw),
        ("shovqin sigma 0.02", np.clip(xw + rng.normal(0, 0.02, xw.shape), 0, 1)),
        ("shovqin sigma 0.05", np.clip(xw + rng.normal(0, 0.05, xw.shape), 0, 1)),
        ("shovqin sigma 0.10", np.clip(xw + rng.normal(0, 0.10, xw.shape), 0, 1)),
        ("JPEG sifat 90", jpeg(xw, 90)),
        ("JPEG sifat 70", jpeg(xw, 70)),
        ("JPEG sifat 50", jpeg(xw, 50)),
        ("xiralash 3x3", uniform_filter(xw, size=(1, 3, 3))),
        ("1 piksel siljitish", np.roll(xw, 1, axis=2)),
    ]
    for nom, h in hujumlar:
        z = z_ball(h, KALIT)
        print(f"  {nom:<20} TPR {np.mean(z > CHEGARA):>6.1%}  z o'rtacha {z.mean():>6.2f}")

    print("\n=== 4. Siljitishga qarshi: 5x5 siljishlarni qidirish va uning narxi ===")
    def qidir(h):
        return np.max([z_ball(np.roll(h, (dy, dx), axis=(1, 2)), KALIT)
                       for dy in range(-2, 3) for dx in range(-2, 3)], axis=0)
    zs = qidir(np.roll(xw, 1, axis=2))
    z0s = qidir(toza)
    print(f"  siljitilgan watermark: TPR {np.mean(zs > CHEGARA):.1%}")
    print(f"  toza rasmlar: FPR {np.mean(z0s > CHEGARA):.1%}, max z {z0s.max():.2f} "
          f"(25 ta test -> max kattaroq)")


if __name__ == "__main__":
    main()

=== 1. Kuch va ko'rinmaslik (1000 rasm, z > 4 chegara) ===
  a      PSNR dB   TPR     z o'rtacha
  0.01      40.4   47.2%      4.01
  0.02      34.5  100.0%      6.53
  0.04      28.6  100.0%     10.04
  0.08      22.8  100.0%     13.17

=== 2. Yolg'on musbat: watermark yo'q yoki boshqa kalit (a = 0.04) ===
  toza generatsiya:     FPR 0.0%, z o'rtacha +1.05, std 0.60, max 2.80
  boshqa kalit (7):     FPR 0.0%, max 1.92
  haqiqiy raqamlar:     FPR 0.0% (1797 ta), max 2.70
  20 ta boshqa kalit, toza rasmlarda z o'rtachasi: -1.72 .. +0.47
  -> toza z nazariy N(0, 1) emas: chegarani toza ma'lumotda empirik tekshiring

=== 3. Chidamlilik (a = 0.04): TPR z > 4 da ===
  hech narsa           TPR 100.0%  z o'rtacha  10.04
  shovqin sigma 0.02   TPR 100.0%  z o'rtacha   9.38
  shovqin sigma 0.05   TPR 100.0%  z o'rtacha   7.62
  shovqin sigma 0.10   TPR  89.2%  z o'rtacha   5.20
  JPEG sifat 90        TPR 100.0%  z o'rtacha   9.44
  JPEG sifat 70        TPR  99.7%  z o'rtacha   5.82
  JPEG sifat 50        TPR  93.2%  z o'rtacha   5.04
  xiralash 3x3         TPR   0.0%  z o'rtacha  -0.86
  1 piksel siljitish   TPR   0.0%  z o'rtacha  -2.79

=== 4. Siljitishga qarshi: 5x5 siljishlarni qidirish va uning narxi ===
  siljitilgan watermark: TPR 100.0%
  toza rasmlar: FPR 0.0%, max z 2.87 (25 ta test -> max kattaroq)

"""Sintetik va haqiqiy detektori: bitta generatorda o'rgatilgan detektor boshqasida umumlashadimi?"""

import warnings

import numpy as np
import torch
import torch.nn as nn
import torch.nn.functional as F
from sklearn.datasets import load_digits
from sklearn.decomposition import PCA
from sklearn.linear_model import LogisticRegression
from sklearn.metrics import roc_auc_score
from sklearn.mixture import GaussianMixture
from sklearn.pipeline import make_pipeline
from sklearn.preprocessing import StandardScaler


class VAE(nn.Module):
    def __init__(self, z=8, h=128):
        super().__init__()
        self.enc = nn.Sequential(nn.Linear(64, h), nn.ReLU(), nn.Linear(h, 2 * z))
        self.dec = nn.Sequential(nn.Linear(z, h), nn.ReLU(), nn.Linear(h, 64))
        self.z = z

    def forward(self, x):
        mu, logv = self.enc(x).chunk(2, 1)
        zz = mu + torch.randn_like(mu) * (0.5 * logv).exp()
        return self.dec(zz), mu, logv


def gen_gmm(Xg, n, seed):
    pca = PCA(20, random_state=seed).fit(Xg)
    with warnings.catch_warnings():
        warnings.simplefilter("ignore")
        gmm = GaussianMixture(10, random_state=seed).fit(pca.transform(Xg))
    Z, _ = gmm.sample(n)
    return pca.inverse_transform(Z)


def gen_vae(Xg, n, seed, qadamlar=1500):
    torch.manual_seed(seed)
    m = VAE()
    opt = torch.optim.Adam(m.parameters(), lr=2e-3)
    X = torch.tensor(Xg / 16, dtype=torch.float32)
    g = torch.Generator().manual_seed(seed)
    for _ in range(qadamlar):
        xb = X[torch.randint(0, len(X), (128,), generator=g)]
        r, mu, logv = m(xb)
        loss = F.mse_loss(r, xb, reduction="sum") / len(xb) * 20 + \
            (-0.5 * (1 + logv - mu ** 2 - logv.exp()).sum(1)).mean()
        opt.zero_grad()
        loss.backward()
        opt.step()
    with torch.no_grad():
        z = torch.randn(n, m.z, generator=torch.Generator().manual_seed(seed + 1))
        return m.dec(z).numpy() * 16


def kvant(x):
    """Haqiqiy digits 0..16 butun sonlar - generatsiyani ham shunday formatga keltiramiz."""
    return np.clip(np.round(x), 0, 16)


def histmos(g, real):
    """Piksel qiymatlari taqsimotini haqiqiyga moslash (kvantil xaritasi)."""
    q = np.linspace(0, 1, 201)
    return np.interp(g, np.quantile(g, q), np.quantile(real, q))


XUS_NOMLARI = ["nol ulushi", "16 ulushi", "oraliq ulushi", "o'rtacha", "gradient x", "gradient y"]


def xus(x):
    """64 piksel + 6 ta global statistika (qiymatlar gistogrammasi va silliqlik)."""
    im = x.reshape(-1, 8, 8)
    gx = np.abs(np.diff(im, axis=2)).mean((1, 2))
    gy = np.abs(np.diff(im, axis=1)).mean((1, 2))
    return np.c_[x, (x == 0).mean(1), (x == 16).mean(1), ((x > 0) & (x < 16)).mean(1), x.mean(1), gx, gy]


def tpr_fpr5(s_real, s_gen):
    """Chegara haqiqiy rasmlarning 95-foizligida (FPR 5%) - sintetiklarning qancha qismi ushlanadi."""
    return float(np.mean(s_gen > np.quantile(s_real, 0.95)))


def main() -> None:
    torch.set_num_threads(1)
    X, _ = load_digits(return_X_y=True)
    perm = np.random.default_rng(0).permutation(len(X))
    Xg, Xd_tr, Xd_te = X[perm[:800]], X[perm[800:1300]], X[perm[1300:]]
    print("=== 1. Bo'linish va generatorlar ===")
    print(f"  generatorlar uchun {len(Xg)}, detektor o'quvi {len(Xd_tr)}, detektor testi {len(Xd_te)}")
    print("  GMM (PCA 20), VAE (z = 8), VAE+hist (piksel gistogrammasi haqiqiyga moslangan)")
    print("  hammasi 0..16 butun songa yaxlitlangan - haqiqiy format bilan bir xil")

    manbalar = ["GMM", "VAE", "VAE+hist"]
    auc, tpr, vazn = {}, {}, []
    for seed in range(3):
        v = gen_vae(Xg, 1000, seed)
        G = {"GMM": kvant(gen_gmm(Xg, 1000, seed)), "VAE": kvant(v), "VAE+hist": kvant(histmos(v, Xg))}
        for manba in manbalar + ["GMM+VAE"]:
            Gtr = np.r_[G["GMM"][:250], G["VAE"][:250]] if manba == "GMM+VAE" else G[manba][:500]
            det = make_pipeline(StandardScaler(), LogisticRegression(C=1.0, max_iter=3000))
            det.fit(xus(np.r_[Xd_tr, Gtr]), np.r_[np.zeros(len(Xd_tr)), np.ones(len(Gtr))])
            if manba == "GMM" and seed == 0:
                vazn, G0 = det[-1].coef_[0][64:], G
            s_real = det.predict_proba(xus(Xd_te))[:, 1]
            for maqsad in manbalar:
                s_gen = det.predict_proba(xus(G[maqsad][500:]))[:, 1]
                y = np.r_[np.zeros(len(s_real)), np.ones(len(s_gen))]
                auc.setdefault((manba, maqsad), []).append(roc_auc_score(y, np.r_[s_real, s_gen]))
                tpr.setdefault((manba, maqsad), []).append(tpr_fpr5(s_real, s_gen))

    print("\n=== 2. AUC: qatorda o'quv manbasi, ustunda test generatori (3 urug' o'rtachasi) ===")
    print("  o'quv / test " + "".join(f"{m:>10}" for m in manbalar))
    for manba in manbalar + ["GMM+VAE"]:
        print(f"  {manba:<12} " + "".join(f"{np.mean(auc[(manba, m)]):>10.3f}" for m in manbalar))
    print("  TPR (FPR 5% da):")
    for manba in manbalar + ["GMM+VAE"]:
        print(f"  {manba:<12} " + "".join(f"{np.mean(tpr[(manba, m)]):>10.3f}" for m in manbalar))

    print("\n=== 3. Yangi generatorda yiqilish (juftlashgan, urug'lar bo'yicha) ===")
    for manba in ("GMM", "VAE", "GMM+VAE"):
        uz = np.array(auc[(manba, "GMM" if manba == "GMM" else "VAE")])
        yangi = np.array(auc[(manba, "VAE+hist")])
        d = uz - yangi
        se = d.std(ddof=1) / np.sqrt(len(d))
        print(f"  {manba:<8}: o'z generatori {uz.mean():.3f} -> VAE+hist {yangi.mean():.3f}, "
              f"tushish {d.mean():.3f} (SE {se:.3f}) "
              f"{'sezilarli' if d.mean() > 2 * se else 'sezilarli emas'}")

    print("\n=== 4. GMM detektori nimaga tayanadi (global xususiyatlar vazni, seed 0) ===")
    for nom, w in sorted(zip(XUS_NOMLARI, vazn), key=lambda p: -abs(p[1]))[:3]:
        print(f"  {nom:<14} {w:+.2f}")
    print("  manba      nol ulushi  oraliq (1..15) ulushi")
    for nom, A in [("haqiqiy", Xd_te)] + [(m, G0[m]) for m in manbalar]:
        print(f"  {nom:<10} {(A == 0).mean():>10.3f} {((A > 0) & (A < 16)).mean():>12.3f}")


if __name__ == "__main__":
    main()

=== 1. Bo'linish va generatorlar ===
  generatorlar uchun 800, detektor o'quvi 500, detektor testi 497
  GMM (PCA 20), VAE (z = 8), VAE+hist (piksel gistogrammasi haqiqiyga moslangan)
  hammasi 0..16 butun songa yaxlitlangan - haqiqiy format bilan bir xil

=== 2. AUC: qatorda o'quv manbasi, ustunda test generatori (3 urug' o'rtachasi) ===
  o'quv / test        GMM       VAE  VAE+hist
  GMM               0.952     0.993     0.627
  VAE               0.975     0.999     0.645
  VAE+hist          0.758     0.838     0.839
  GMM+VAE           0.962     0.997     0.641
  TPR (FPR 5% da):
  GMM               0.825     0.973     0.148
  VAE               0.915     0.992     0.168
  VAE+hist          0.177     0.391     0.274
  GMM+VAE           0.861     0.985     0.173

=== 3. Yangi generatorda yiqilish (juftlashgan, urug'lar bo'yicha) ===
  GMM     : o'z generatori 0.952 -> VAE+hist 0.627, tushish 0.325 (SE 0.024) sezilarli
  VAE     : o'z generatori 0.999 -> VAE+hist 0.645, tushish 0.353 (SE 0.009) sezilarli
  GMM+VAE : o'z generatori 0.997 -> VAE+hist 0.641, tushish 0.356 (SE 0.019) sezilarli

=== 4. GMM detektori nimaga tayanadi (global xususiyatlar vazni, seed 0) ===
  nol ulushi     -3.40
  oraliq ulushi  +2.24
  gradient y     -1.95
  manba      nol ulushi  oraliq (1..15) ulushi
  haqiqiy         0.491        0.419
  GMM             0.379        0.566
  VAE             0.376        0.586
  VAE+hist        0.488        0.420

nisbat = eng_yaqin(G, X_oquv).mean() / eng_yaqin(G, X_val_kichik).mean()   # ⚠️ hajm farqi
nisbat = eng_yaqin(G, X_oquv).mean() / eng_yaqin(G, X_ho_teng).mean()      # ✅ len teng

print(f"nusxa {(d_oq == 0).float().mean():.1%}")                             # ⚠️ 2.4% - ko'pmi?
print(f"nusxa {(d_oq == 0).float().mean():.1%} / held-out {(d_ho == 0).float().mean():.1%}")  # ✅

maxfiy = nusxa_ulushi < 0.01                                                 # ⚠️
maxfiy = nusxa_ulushi < 0.01 and abs(mia_auc - 0.5) < 0.05                  # ✅ + a'zolik hujumi

ulush = np.mean(klf.predict(model.namuna(1000, g, T=1.0)) == oz)             # ⚠️
for T in (1.0, 0.7, 0.5):                                                    # ✅ ishlatiladigan
    ulush[T] = np.mean(klf.predict(model.namuna(1000, g, T)) == oz)          #    har sozlamada

klf.fit(B[oquv], y[oquv]); generator.fit(B[oquv])                            # ⚠️ bir xil rasmlar
klf.fit(B[baho_i], y[baho_i]); generator.fit(B[pool_i])                      # ✅ alohida + tekshiruv

bor = z > 4                                   # "N(0,1) da FPR 3e-5"         # ⚠️
chegara = max(4.0, np.quantile(z_toza, 0.999)); bor = z > chegara            # ✅ empirik

auc = roc_auc_score(y, det.predict_proba(xus(np.r_[X_te, G_gmm_te]))[:, 1])  # ⚠️
auc_yangi = roc_auc_score(y, det.predict_proba(xus(np.r_[X_te, G_yangi]))[:, 1])  # ✅

1.  # nega yodlashni o'lchashda held-out o'quv bilan teng hajmda bo'lishi kerak?
2.  # NN nisbati 0.07 nimani bildiradi?
3.  # nusxa ulushi 0.1%, MIA AUC 0.79 - maxfiylik bormi?
4.  # T = 0.5 da ozchilik ulushi qaysi tomonga siljiydi va nega?
5.  # shartli modelda guruh nisbati qayerdan keladi?
6.  # watermark kuchi a ni oshirsak TPR va PSNR qanday o'zgaradi?
7.  # nega 3x3 xiralash yuqori chastotali watermarkni o'chiradi?
8.  # 25 ta siljishni qidirish FPR ga qanday ta'sir qiladi?
9.  # green list da gamma = 0.25, T = 200 token, 80 ta yashil - z?
10. # detektor nega yangi generatorda yiqilishi mumkin?
11. # C2PA manifesti va watermarkning asosiy farqi?
12. # watermark kaliti paketda saqlanishi kerakmi?

1.  sub = X[perm[:40]]; ho = X[perm[40:400]]
    nisbat = eng_yaqin(G, sub)[0].mean() / eng_yaqin(G, ho)[0].mean()

2.  klf = LogisticRegression().fit(B[oq], y[oq])
    ulush = np.mean(klf.predict(G) == oz)

3.  if nusxa_ulushi == 0:
        print("sintetik ma'lumot maxfiy - tarqatish mumkin")

4.  paket = {"holat": model.state_dict(), "watermark_kalit": 2026}

5.  det.fit(np.r_[X_tr, G_gmm], y)
    print("detektor AUC", roc_auc_score(y_te, det.predict_proba(np.r_[X_te, G_gmm_te])[:, 1]))