25.9-dars: RAG — retrieval sifati va baholash

RAG ZANJIRI:
  savol -> [RETRIEVAL: top-k chunk] -> [LLM: kontekst + savol -> javob]

JAVOB NOTO'G'RI BO'LSA, IKKI XIL SABAB:
  1. kerakli chunk top-k ga tushmagan        - retrieval xatosi
  2. chunk bor, lekin model uni ishlatmagan  - generatsiya xatosi
  birinchisini LLM tuzata olmaydi: kontekstda yo'q narsani faqat to'qiydi

NEGA ALOHIDA:
  retrieval metrikalari arzon va deterministik - LLM chaqiruvi kerak emas
  har o'zgarishni (chunk hajmi, embedding, k, reranker) sekundlarda o'lchash mumkin
  yakuniy javob sifati (LLM ni baholash darsi) - qimmatroq va shovqinliroq

TARTIB:
  avval retrieval: "to'g'ri chunk top-k da bormi?" (recall@k)
  keyin generatsiya: "chunk bo'lsa, javob to'g'rimi?"

BELGILAR: tartib - tizim qaytargan chunklar ro'yxati; rel - relevant chunklar to'plami

RECALL@k    = |top-k ∩ rel| / |rel|        - relevantlarning qanchasi top-k da
PRECISION@k = |top-k ∩ rel| / k            - top-k ning qancha qismi relevant
RR          = 1 / (birinchi relevant o'rni) ; MRR - savollar bo'yicha o'rtacha
DCG@k       = sum (2^rel_i - 1) / log2(i + 1),  i = 1..k
nDCG@k      = DCG@k / IDCG@k               - IDCG: ideal tartibdagi DCG

1-MISOL, QO'LDA (tartib d3 d7 d1 d9 d4; relevant d1 (daraja 2), d4 (daraja 1)):
  recall@3 = 1/2 = 0.50,  precision@3 = 1/3 = 0.33,  RR = 1/3
  DCG@5  = 3/log2(4) + 1/log2(6) = 1.887
  IDCG@5 = 3/log2(2) + 1/log2(3) = 3.631   ->  nDCG@5 = 0.520
  d1 1-o'ringa chiqsa: RR 1.000, nDCG 0.933, recall@5 o'zgarmaydi 1.00-bob

QAYSI BIRI QACHON:
  recall@k  - RAG uchun asosiy: LLM ga k ta chunk beriladi, tartib ichida kamroq muhim
  MRR       - bitta to'g'ri javob bo'lsa, "qanchalik tepada" ni o'lchaydi
  nDCG      - bir necha darajali relevantlik (aynan shu / qisman foydali)
  precision@k - bitta relevant bo'lsa recall@k / k ga teng - kam ma'lumot beradi

TARKIB: (savol, oltin chunk id(lar)i, savol turi, [javob satri])

QAYERDAN OLINADI:
  foydalanuvchi loglari       - eng haqiqiy; belgilash qo'lda
  mutaxassis yozgan savollar  - sifatli, lekin qimmat
  sintetik: chunkdan savol    - LLM "shu chunkka savol yoz" (arzon, lekin
                                 hujjat so'zlarini takrorlashga moyil -> juda oson)
  ATAYLAB: parafraz, kod/raqam, bir necha chunk talab qiladigan savollar

TURLAR BO'YICHA BELGILASH (bizning to'plam, 288 savol):
  parafraz - so'zlashuv atamalari:  "Moliya bo'limida ishchi dam olishga necha kunga chiqadi?"
  kod      - aniq identifikator:    "AK-7564 bo'yicha qoida nima?"
  raqam    - aniq qiymat bilan:     "Qaysi bo'limda yiliga 19 kunlik ta'til beriladi?"

TEKSHIRUVLAR (1-misol):
  javob satri oltin chunkda bormi (100%), takror savollar (0), turlar muvozanati

QOIDALAR:
  dev (sozlash) va test (yakuniy) ajratilsin
  to'plam versiyalansin: o'zgarganda eski natijalar bilan solishtirib bo'lmaydi
  (LLM ni baholash darsida batafsil)

BM25(q, d) = sum_{w in q} IDF(w) * tf(w, d) * (k1 + 1) / (tf(w, d) + k1 * (1 - b + b * |d| / avgdl))
IDF(w)     = log(1 + (N - df(w) + 0.5) / (df(w) + 0.5))

  tf      - so'z hujjatda necha marta; to'yinadi (k1 = 1.5): 10 marta != 10 barobar
  |d|/avgdl - uzun hujjat jazolanadi (b = 0.75)
  IDF     - kam uchraydigan so'z (kod, raqam) katta vazn oladi

KUCHLI TOMONLARI:
  aniq atama, kod, raqam, nom - "AK-7564" bitta hujjatda -> IDF 4.2 atrofida
  o'rgatish kerak emas, tushuntirish oson, tez

ZAIF TOMONI:
  sinonim va parafrazni ko'rmaydi: "dam olish" != "ta'til"
  1-misol: parafrazda recall@1 0.083, kod va raqamda 1.000

O'ZBEK TILI:
  qo'shimchalar: "bo'limi", "bo'limida", "bo'limda" - turli token
  eng oddiy yechim - o'zak kesish (bizda: so'zning birinchi 6 harfi)
  yaxshiroq - morfologik tahlil yoki subword (23.3-dars)

DENSE (25.7-dars): savol va chunk -> vektor; o'xshashlik = kosinus
  bizda embedding o'rnida LSA: TF-IDF + TruncatedSVD(12)

SINONIMNI QAYERDAN BILADI:
  faqat o'zi ko'rgan matnlardan - "ta'til" va "dam olish" bir xil kontekstda uchrasa
  2-misol, cos("dam olish", "ta'til"):
    faqat 96 chunkda o'rgatilgan LSA    0.00  - so'z lug'atda ham yo'q
    + 360 belgisiz fon matn bilan       1.00
  fon = haqiqiy embedding modelning pretraining korpusi o'rnida

ZAIF TOMONI:
  kod va raqam: "AK-7564" bitta hujjatda - 12 o'lchovga siqilganda yo'qoladi
  2-misol, LSA (fon bilan): kodda recall@1 0.28, parafrazda 0.22, MRR 0.404

HAQIQIY TIZIMDA:
  tayyor embedding modeli 25.7-bob - katta korpusda o'rgatilgan, sinonimni biladi
  lekin domen atamalari, ichki kodlar, yangi mahsulot nomlari - baribir zaif

RRF (Reciprocal Rank Fusion):
  ball(d) = sum_{retriever r} 1 / (60 + o'rin_r(d))
  faqat O'RINLAR ishlatiladi - ballarning shkalasi muhim emas (BM25 0..20, kosinus -1..1)
  har retrieverdan top-n nomzod (bizda 30); ball = 0 bo'lgan hujjat hissa qo'shmaydi

VAZNLI BIRLASHTIRISH:
  ball(d) = alfa * minmax(BM25) + (1 - alfa) * minmax(kosinus)
  ballar kattaligini saqlaydi: BM25 "aniq moslik" da qanchalik ishonchli ekanini

2-MISOL NATIJASI (MRR):
  usul         parafraz   kod     raqam
  BM25          0.209    1.000    1.000
  LSA (fon)     0.404    0.478    0.491
  RRF           0.771    1.000    0.741
  vaznli 0.5    0.910    1.000    1.000

  RRF - BM25: parafraz +0.562 (SE 0.037), raqam -0.259 (SE 0.031) - ikkalasi sezilarli
  nega RRF raqamda yutqazdi: BM25 oltin chunkni 1-o'ringa qo'yadi, lekin boshqa 7 bo'lim
  hujjati ham yaqin o'rinlarda; LSA raqamni ko'rmaydi va ulardan birini 1-o'ringa
  qo'yadi -> o'rinlar yig'indisida oltin chunk yutqazadi. Vaznli usulda BM25 ning
  katta ball farqi saqlanadi

TANLASH:
  alfa va RRF doimiysi - dev savollarda (test da emas!)
  savol turi bo'yicha tekshirish shart: umumiy MRR RRF 0.838, vaznli 0.970

1-BOSQICH (tez, keng):   BM25 / dense / gibrid -> top-N nomzod (N = 20..100)
2-BOSQICH (sekin, aniq): har (savol, nomzod) juftligini alohida baholash -> qayta tartib

NEGA IKKI BOSQICH:
  aniq model (cross-encoder, LLM) qimmat - butun korpusga qo'llab bo'lmaydi
  1-bosqich faqat "to'g'ri chunkni N ichiga tushirishi" kerak (recall@N)
  2-bosqich 1-o'rinni tuzatadi (recall@1, MRR)

HAQIQIY TIZIMLARDA 2-BOSQICH:
  cross-encoder - savol va chunkni BIRGA o'qiydigan transformer (24.8, BERT)
  LLM-reranker  - "qaysi chunk savolga javob beradi" deb so'rash
  bizda: juftlik xususiyatlari + LogisticRegression (3-misol)

3-MISOL XUSUSIYATLARI:
  bm25, lsa (kosinus), rrf_orin, bolim_mos, raqam_mos, kod_mos, soz_ulushi
  o'rgatish: GroupKFold - oltin chunk bo'yicha (bir chunkning savollari bir foldda)

3-MISOL NATIJASI:
  recall@1: RRF 0.747 -> +reranker 0.948;  MRR 0.838 -> 0.974 (+0.136, SE 0.015)
  1-o'rin: 58 savol tuzaldi, 0 ta buzildi

CHEGARA:
  1-bosqich yo'qotgan chunkni reranker qaytara olmaydi: shift = recall@N
  RRF: N=1 0.747, N=3 0.906, N=5 0.948, N=10 1.000

k OSHSA:
  + recall@k o'sadi (kerakli chunk kontekstga tushish ehtimoli)
  - shovqin: keraksiz chunklar ulushi 1 - recall@k / k
  - xarajat: kirish tokenlari ~ k ga proporsional (25.2-dars)
  - chalg'itish: o'xshash, lekin noto'g'ri chunk (boshqa bo'limning xuddi shunday
    qoidasi) modelni adashtirishi mumkin; uzun kontekst o'rtasidagi ma'lumot
    yomonroq ishlatilishi mumkin ("lost in the middle")

4-MISOL (RRF, FARAZIY narx):
  k    oltin kontekstda   shovqin   token/so'rov
  1        0.750           0.25          28
  3        0.906           0.70          84
  5        0.948           0.81         140
  10       1.000           0.90         280

TANLASH QOIDASI:
  maqsad metrika (yakuniy javob aniqligi) bo'yicha eng yaxshisidan sezilarli
  yomon bo'lmagan ENG KICHIK k - arzonroq va shovqinsizroq
  4-misol, oddiy o'quvchi: eng yaxshi k = 8 0.885-bob, tanlov k = 5 (0.882)

ANSWER-IN-CONTEXT: kontekstda javob bormi?
  qat'iy: oltin chunk top-k da (belgilangan to'plam kerak)
  satr bo'yicha: javob satri ("28 kunlik") kontekstdagi biror chunkda
  bo'sh tekshiruv ("28" raqami bormi) - soxta "topildi" beradi:
    4-misol: hatto bu toza korpusda ham k=1 va k=8 da 2 tadan soxta holat

KONTEKSTDA BOR != JAVOB TO'G'RI:
  4-misol, k = 10: oltin chunk hamma savolda kontekstda 1.000-bob,
  lekin oddiy o'quvchi 0.885 aniqlik berdi; parafrazda 33 savolda chalg'idi

XATOLAR TAHLILI (4-misol, oltin top-3 da yo'q, 27 / 288):
  12  parafraz: 1-o'rinda boshqa bo'lim, boshqa mavzu - "ish haqi", "ish kiyimi" dagi
      umumiy "ish" so'zi va "uydan" noto'g'ri mavzuga tortdi; 1-o'rinda deyarli
      doim Marketing bo'limining ikki chunki ("markaz" chunklar - hubness)
   8  raqam: mavzu to'g'ri, bo'lim xato (LSA raqamni ko'rmaydi, RRF o'rinlarni aralashtiradi)
   7  parafraz: bo'lim to'g'ri, mavzu xato (namuna: "ish haqi" -> o'sha bo'limning
      masofaviy ish qoidasi)
  har toifa o'z yechimiga ega: vaznli birlashtirish, reranker, fon korpus, o'zak kesish

import math
import numpy as np

# metrikalar
recall_k = len(set(tartib[:k]) & rel) / len(rel)
precision_k = len(set(tartib[:k]) & rel) / k
rr = next((1 / (i + 1) for i, d in enumerate(tartib) if d in rel), 0.0)
dcg = sum((2 ** daraja.get(d, 0) - 1) / math.log2(i + 2) for i, d in enumerate(tartib[:k]))

# tenglikda optimizmsiz o'rin
orin = int((ball >= ball[oltin]).sum())

# BM25 (bitta so'z hissasi)
idf = math.log(1 + (N - df + 0.5) / (df + 0.5))
hissa = idf * tf * (k1 + 1) / (tf + k1 * (1 - b + b * dl / avgdl))

# RRF va vaznli birlashtirish
rrf_ball[tartib[:n]] += 1 / (60 + np.arange(1, n + 1))
vaznli = alfa * minmax(bm25_ball) + (1 - alfa) * minmax(kosinus)

# juftlashgan taqqoslash (har savol bo'yicha RR farqi)
d = 1 / orin_a - 1 / orin_b
se = d.std(ddof=1) / math.sqrt(len(d))
sezilarli = abs(d.mean()) > 2 * se

RAG = retrieval + generatsiya; avval retrievalni alohida o'lchang
recall@k - asosiy; MRR, nDCG - tartib sifati
baholash to'plami: savol, oltin chunk, savol TURI; dev/test
BM25 - kod/raqam; dense - parafraz; gibrid - ikkalasi (turi bo'yicha tekshiring)
reranker - 2-bosqich; shift = 1-bosqich recall@N
k - eng yaxshisidan sezilarli yomon bo'lmagan eng kichik qiymat

"""Retrieval metrikalari noldan: recall@k, precision@k, MRR, nDCG va baholash to'plami."""

import math
import re

import numpy as np

BOLIMLAR = ["moliya", "marketing", "kadrlar", "axborot", "logistika", "savdo",
            "yuridik", "omborxona"]
# (rasmiy atama - hujjatlarda, so'zlashuv atamasi - foydalanuvchi savollarida)
SINONIM = {
    "tatil": ("ta'til", "dam olish"), "xodim": ("xodim", "ishchi"),
    "ariza": ("ariza", "so'rovnoma"), "rahbar": ("rahbar", "boshliq"),
    "maosh": ("maosh", "ish haqi"), "masofa": ("masofaviy", "uydan"),
    "safar": ("xizmat safari", "komandirovka"),
    "kasal": ("kasallik varaqasi", "bemorlik ma'lumotnomasi"),
    "parol": ("parol", "maxfiy kod"), "noutbuk": ("noutbuk", "kompyuter"),
    "malaka": ("malaka oshirish", "o'qish kursi"), "tushlik": ("tushlik", "ovqat"),
    "avtobus": ("xizmat avtobusi", "transport"), "sugurta": ("sug'urta", "polis"),
    "forma": ("forma", "ish kiyimi"), "ruxsat": ("ruxsat", "izn"),
}
# (hujjat shabloni, javob, raqamli savol, parafraz savol)
MAVZULAR = [
    ("{b} bo'limi {xodim}lari uchun yillik {tatil} tartibi. Har bir {xodim}ga yiliga {n} kunlik {tatil} beriladi. {ariza} {rahbar}ga ikki hafta oldin topshiriladi.",
     "{n} kunlik", "Qaysi bo'limda yiliga {n} kunlik {tatil} beriladi?",
     "{b} bo'limida {xodim} {tatil}ga necha kunga chiqadi?"),
    ("{b} bo'limida {maosh} har oyning {n}-kunida kartaga o'tkaziladi. {maosh} kechiksa {xodim} {rahbar}ga yozma murojaat qiladi.",
     "{n}-kunida", "Qaysi bo'limda {maosh} oyning {n}-kunida o'tkaziladi?",
     "{b} bo'limida {maosh} qachon tushadi?"),
    ("{b} bo'limi {xodim}lari haftada {n} soat {masofa} ishlashi mumkin. {masofa} ish uchun {rahbar} {ruxsat}i talab qilinadi.",
     "{n} soat", "Qaysi bo'limda haftada {n} soat {masofa} ishlash mumkin?",
     "{b} bo'limida qancha vaqt {masofa} faoliyat yuritsa bo'ladi?"),
    ("{b} bo'limi {xodim}lari {safar}ga chiqqanda kunlik xarajat {n} ming so'm qilib belgilangan. {safar} hisoboti uch kunda topshiriladi.",
     "{n} ming so'm", "Qaysi bo'limda {safar}da kunlik xarajat {n} ming so'm?",
     "{b} bo'limida {safar} paytida sutkalik pul qancha?"),
    ("{b} bo'limida {kasal} {n} kun ichida kadrlar xizmatiga topshirilishi shart. {kasal} bo'lmasa kun ishsiz hisoblanadi.",
     "{n} kun ichida", "Qaysi bo'limda {kasal} {n} kun ichida topshiriladi?",
     "{b} bo'limida {kasal}ni qachongacha olib kelish kerak?"),
    ("{b} bo'limi tizimlarida {parol} kamida {n} belgidan iborat bo'ladi. {parol} har uch oyda yangilanadi.",
     "{n} belgidan", "Qaysi bo'limda {parol} kamida {n} belgidan iborat?",
     "{b} bo'limida {parol} uzunligi qanday bo'lishi lozim?"),
    ("{b} bo'limi {xodim}lariga berilgan {noutbuk} har {n} yilda almashtiriladi. Buzilgan {noutbuk} haqida {rahbar}ga xabar beriladi.",
     "{n} yilda", "Qaysi bo'limda {noutbuk} har {n} yilda almashtiriladi?",
     "{b} bo'limida {noutbuk} qachon yangisiga o'zgartiriladi?"),
    ("{b} bo'limi {xodim}lari yiliga kamida {n} soat {malaka}dan o'tadi. {malaka} xarajatini kompaniya to'laydi.",
     "{n} soat", "Qaysi bo'limda yiliga {n} soat {malaka} talab qilinadi?",
     "{b} bo'limida {malaka} davomiyligi qancha?"),
    ("{b} bo'limida {tushlik} uchun har kuni {n} ming so'm kompensatsiya beriladi. {tushlik} tanaffusi bir soat davom etadi.",
     "{n} ming so'm", "Qaysi bo'limda {tushlik} uchun {n} ming so'm beriladi?",
     "{b} bo'limida {tushlik} pulining qancha qismi qoplanadi?"),
    ("{b} bo'limi {xodim}lari uchun {avtobus} ertalab {n} daqiqa oralig'ida qatnaydi. {avtobus}dan foydalanish bepul.",
     "{n} daqiqa", "Qaysi bo'limda {avtobus} {n} daqiqa oralig'ida qatnaydi?",
     "{b} bo'limida {avtobus} qanchalik tez-tez keladi?"),
    ("{b} bo'limi {xodim}lari tibbiy {sugurta} bilan ta'minlanadi. {sugurta} qoplamasi {n} million so'mgacha.",
     "{n} million", "Qaysi bo'limda {sugurta} qoplamasi {n} million so'mgacha?",
     "{b} bo'limida {sugurta} davolanishni qancha summagacha yopadi?"),
    ("{b} bo'limida {forma} har {n} oyda bir marta beriladi. {forma}ni yo'qotgan {xodim} uni o'zi qoplaydi.",
     "{n} oyda", "Qaysi bo'limda {forma} har {n} oyda beriladi?",
     "{b} bo'limida yangi {forma} qanchalik tez-tez tarqatiladi?"),
]


def bosh_harf(matn):
    return re.sub(r"(^|\. )([a-z])", lambda m: m.group(1) + m.group(2).upper(), matn)


def korpus(seed=0, n_fon=30):
    """96 chunk (12 mavzu x 8 bo'lim), 288 savol (3 tur) va belgisiz fon matnlar."""
    rng = np.random.default_rng(seed)
    rasmiy = {k: v[0] for k, v in SINONIM.items()}
    ogzaki = {k: v[1] for k, v in SINONIM.items()}
    chunklar, savollar, fon = [], [], []
    for m, (shablon, javob, raqam, parafraz) in enumerate(MAVZULAR):
        sonlar = rng.choice(np.arange(3, 29), len(BOLIMLAR), replace=False)
        for j, b in enumerate(BOLIMLAR):
            n = int(sonlar[j])
            kod = f"{'ABCDEFGHKLMN'[m]}{'KLMNPRST'[j]}-{int(rng.integers(1000, 9999))}"
            i = len(chunklar)
            chunklar.append({"id": i, "mavzu": m, "bolim": b, "javob": javob.format(n=n),
                             "matn": bosh_harf(f"Hujjat {kod}. "
                                               + shablon.format(b=b.capitalize(), n=n, **rasmiy))})
            savollar.append({"q": bosh_harf(parafraz.format(b=b.capitalize(), **ogzaki)),
                             "tur": "parafraz", "gold": i})
            savollar.append({"q": f"{kod} bo'yicha qoida nima?", "tur": "kod", "gold": i})
            savollar.append({"q": bosh_harf(raqam.format(n=n, **rasmiy)), "tur": "raqam", "gold": i})
        for _ in range(n_fon):            # fon: har eslatmada atama varianti tasodifiy
            f = re.sub(r"\{(\w+)\}", lambda mm: SINONIM[mm.group(1)][int(rng.integers(0, 2))]
                       if mm.group(1) in SINONIM else "{" + mm.group(1) + "}", shablon)
            fon.append(f.format(b="kompaniya", n=int(rng.integers(3, 29))))
    return chunklar, savollar, fon


def tokenlar(matn):
    """Kichik harf, so'z/kod tokenlari; so'zlar 6 belgigacha kesiladi (oddiy o'zak)."""
    t = re.findall(r"[a-z0-9'\-]+", matn.lower())
    return [w if re.search(r"\d", w) else w[:6] for w in t if w.strip("-'")]


class BM25:
    def __init__(self, hujjatlar, k1=1.5, b=0.75):
        self.docs = [tokenlar(h) for h in hujjatlar]
        self.N, self.k1, self.b = len(self.docs), k1, b
        self.avgdl = np.mean([len(d) for d in self.docs])
        df = {}
        for d in self.docs:
            for w in set(d):
                df[w] = df.get(w, 0) + 1
        self.idf = {w: math.log(1 + (self.N - c + 0.5) / (c + 0.5)) for w, c in df.items()}
        self.tf = [{w: d.count(w) for w in set(d)} for d in self.docs]

    def ball(self, savol):
        s = np.zeros(self.N)
        for w in tokenlar(savol):
            for i, (tf, d) in enumerate(zip(self.tf, self.docs)):
                if w in tf:
                    norm = self.k1 * (1 - self.b + self.b * len(d) / self.avgdl)
                    s[i] += self.idf[w] * tf[w] * (self.k1 + 1) / (tf[w] + norm)
        return s

def recall_k(tartib, rel, k):
    return len(set(tartib[:k]) & set(rel)) / len(rel)


def precision_k(tartib, rel, k):
    return len(set(tartib[:k]) & set(rel)) / k


def rr(tartib, rel):
    for i, d in enumerate(tartib):
        if d in rel:
            return 1.0 / (i + 1)
    return 0.0


def ndcg_k(tartib, daraja, k):
    """daraja: {hujjat: relevantlik darajasi}; DCG = sum (2^rel - 1) / log2(o'rin + 1)."""
    dcg = sum((2 ** daraja.get(d, 0) - 1) / math.log2(i + 2) for i, d in enumerate(tartib[:k]))
    ideal = sorted(daraja.values(), reverse=True)[:k]
    idcg = sum((2 ** r - 1) / math.log2(i + 2) for i, r in enumerate(ideal))
    return dcg / idcg if idcg > 0 else 0.0


def main() -> None:
    print("=== 1. Metrikalar qo'lda: bitta savol ===")
    tartib = ["d3", "d7", "d1", "d9", "d4"]
    rel = {"d1", "d4"}
    daraja = {"d1": 2, "d4": 1}
    print(f"  tizim tartibi {tartib}, relevant {sorted(rel)}")
    for k in (1, 3, 5):
        print(f"  k={k}: recall@k {recall_k(tartib, rel, k):.2f}, precision@k "
              f"{precision_k(tartib, rel, k):.2f}")
    print(f"  RR = 1/3 = {rr(tartib, rel):.3f} (birinchi relevant 3-o'rinda)")
    dcg = 3 / math.log2(4) + 1 / math.log2(6)
    idcg = 3 / math.log2(2) + 1 / math.log2(3)
    print(f"  nDCG@5 (d1 = 2, d4 = 1): DCG {dcg:.3f} / IDCG {idcg:.3f} = "
          f"{ndcg_k(tartib, daraja, 5):.3f}")
    tartib2 = ["d1", "d3", "d7", "d9", "d4"]
    print(f"  d1 birinchi o'ringa chiqsa: RR {rr(tartib2, rel):.3f}, "
          f"nDCG@5 {ndcg_k(tartib2, daraja, 5):.3f}, recall@5 o'zgarmaydi "
          f"{recall_k(tartib2, rel, 5):.2f}")

    print("\n=== 2. Baholash to'plami: savol -> to'g'ri chunk ===")
    chunklar, savollar, _ = korpus()
    print(f"  chunklar {len(chunklar)}, savollar {len(savollar)}")
    for tur in ("parafraz", "kod", "raqam"):
        s = next(x for x in savollar if x["tur"] == tur)
        print(f"  [{tur}] {s['q']}")
    print(f"  oltin chunk: {chunklar[0]['matn']}")
    javob_bor = np.mean([chunklar[s["gold"]]["javob"] in chunklar[s["gold"]]["matn"]
                         for s in savollar])
    takror = len(savollar) - len({s["q"] for s in savollar})
    print(f"  tekshiruv: javob oltin chunkda {javob_bor:.0%}, takror savollar {takror}")
    turlar = {t: sum(s["tur"] == t for s in savollar) for t in ("parafraz", "kod", "raqam")}
    print(f"  turlar: {turlar}")

    print("\n=== 3. BM25 ni baholash (288 savol) ===")
    bm = BM25([c["matn"] for c in chunklar])
    natija = {k: [] for k in ("r1", "r3", "r10", "p3", "rr", "nd", "ndg")}
    for s in savollar:
        b = bm.ball(s["q"])     # tenglikda oltin chunk oxiriga (optimizmsiz baho)
        tartib = sorted(range(len(b)), key=lambda i: (-b[i], i == s["gold"]))
        g = [s["gold"]]
        m = chunklar[s["gold"]]["mavzu"]
        daraja = {c["id"]: 1 for c in chunklar if c["mavzu"] == m}   # shu mavzu - qisman
        daraja[s["gold"]] = 2                                        # aynan shu chunk
        natija["r1"].append(recall_k(tartib, g, 1))
        natija["r3"].append(recall_k(tartib, g, 3))
        natija["r10"].append(recall_k(tartib, g, 10))
        natija["p3"].append(precision_k(tartib, g, 3))
        natija["rr"].append(rr(tartib, g))
        natija["nd"].append(ndcg_k(tartib, {s["gold"]: 1}, 10))
        natija["ndg"].append(ndcg_k(tartib, daraja, 10))
    for nom, kalit in [("recall@1", "r1"), ("recall@3", "r3"), ("recall@10", "r10"),
                       ("precision@3", "p3"), ("MRR", "rr"), ("nDCG@10 (ikkilik)", "nd"),
                       ("nDCG@10 (darajali)", "ndg")]:
        v = np.array(natija[kalit])
        print(f"  {nom:<19} {v.mean():.3f}  (SE {v.std(ddof=1) / math.sqrt(len(v)):.3f})")
    print(f"  bitta relevant bo'lsa precision@3 = recall@3 / 3: "
          f"{np.mean(natija['r3']) / 3:.3f}")

    print("\n=== 4. O'rtacha nimani yashiradi: savol turi bo'yicha ===")
    print("  tur        recall@1  recall@10    MRR")
    turlar_arr = np.array([s["tur"] for s in savollar])
    mrr_tur = {}
    for tur in ("parafraz", "kod", "raqam"):
        m = turlar_arr == tur
        mrr_tur[tur] = np.array(natija["rr"])[m].mean()
        print(f"  {tur:<9} {np.array(natija['r1'])[m].mean():>9.3f} "
              f"{np.array(natija['r10'])[m].mean():>10.3f} {mrr_tur[tur]:>6.3f}")
    eng_yomon = min(mrr_tur, key=mrr_tur.get)
    print(f"  eng zaif tur: {eng_yomon} (MRR {mrr_tur[eng_yomon]:.3f}) - umumiy MRR "
          f"{np.mean(natija['rr']):.3f} buni yashiradi")
    print("  ⭐ Baholash to'plamini savol turlari bilan belgilang va har turni alohida o'lchang")


if __name__ == "__main__":
    main()

=== 1. Metrikalar qo'lda: bitta savol ===
  tizim tartibi ['d3', 'd7', 'd1', 'd9', 'd4'], relevant ['d1', 'd4']
  k=1: recall@k 0.00, precision@k 0.00
  k=3: recall@k 0.50, precision@k 0.33
  k=5: recall@k 1.00, precision@k 0.40
  RR = 1/3 = 0.333 (birinchi relevant 3-o'rinda)
  nDCG@5 (d1 = 2, d4 = 1): DCG 1.887 / IDCG 3.631 = 0.520
  d1 birinchi o'ringa chiqsa: RR 1.000, nDCG@5 0.933, recall@5 o'zgarmaydi 1.00

=== 2. Baholash to'plami: savol -> to'g'ri chunk ===
  chunklar 96, savollar 288
  [parafraz] Moliya bo'limida ishchi dam olishga necha kunga chiqadi?
  [kod] AK-7564 bo'yicha qoida nima?
  [raqam] Qaysi bo'limda yiliga 19 kunlik ta'til beriladi?
  oltin chunk: Hujjat AK-7564. Moliya bo'limi xodimlari uchun yillik ta'til tartibi. Har bir xodimga yiliga 19 kunlik ta'til beriladi. Ariza rahbarga ikki hafta oldin topshiriladi.
  tekshiruv: javob oltin chunkda 100%, takror savollar 0
  turlar: {'parafraz': 96, 'kod': 96, 'raqam': 96}

=== 3. BM25 ni baholash (288 savol) ===
  recall@1            0.694  (SE 0.027)
  recall@3            0.726  (SE 0.026)
  recall@10           0.858  (SE 0.021)
  precision@3         0.242  (SE 0.009)
  MRR                 0.736  (SE 0.024)
  nDCG@10 (ikkilik)   0.755  (SE 0.023)
  nDCG@10 (darajali)  0.561  (SE 0.022)
  bitta relevant bo'lsa precision@3 = recall@3 / 3: 0.242

=== 4. O'rtacha nimani yashiradi: savol turi bo'yicha ===
  tur        recall@1  recall@10    MRR
  parafraz      0.083      0.573  0.209
  kod           1.000      1.000  1.000
  raqam         1.000      1.000  1.000
  eng zaif tur: parafraz (MRR 0.209) - umumiy MRR 0.736 buni yashiradi
  ⭐ Baholash to'plamini savol turlari bilan belgilang va har turni alohida o'lchang

"""BM25, dense (LSA) va gibrid (RRF): savol turlari bo'yicha juftlashgan taqqoslash."""

import math
import re

import numpy as np
from sklearn.decomposition import TruncatedSVD
from sklearn.feature_extraction.text import TfidfVectorizer

BOLIMLAR = ["moliya", "marketing", "kadrlar", "axborot", "logistika", "savdo",
            "yuridik", "omborxona"]
# (rasmiy atama - hujjatlarda, so'zlashuv atamasi - foydalanuvchi savollarida)
SINONIM = {
    "tatil": ("ta'til", "dam olish"), "xodim": ("xodim", "ishchi"),
    "ariza": ("ariza", "so'rovnoma"), "rahbar": ("rahbar", "boshliq"),
    "maosh": ("maosh", "ish haqi"), "masofa": ("masofaviy", "uydan"),
    "safar": ("xizmat safari", "komandirovka"),
    "kasal": ("kasallik varaqasi", "bemorlik ma'lumotnomasi"),
    "parol": ("parol", "maxfiy kod"), "noutbuk": ("noutbuk", "kompyuter"),
    "malaka": ("malaka oshirish", "o'qish kursi"), "tushlik": ("tushlik", "ovqat"),
    "avtobus": ("xizmat avtobusi", "transport"), "sugurta": ("sug'urta", "polis"),
    "forma": ("forma", "ish kiyimi"), "ruxsat": ("ruxsat", "izn"),
}
# (hujjat shabloni, javob, raqamli savol, parafraz savol)
MAVZULAR = [
    ("{b} bo'limi {xodim}lari uchun yillik {tatil} tartibi. Har bir {xodim}ga yiliga {n} kunlik {tatil} beriladi. {ariza} {rahbar}ga ikki hafta oldin topshiriladi.",
     "{n} kunlik", "Qaysi bo'limda yiliga {n} kunlik {tatil} beriladi?",
     "{b} bo'limida {xodim} {tatil}ga necha kunga chiqadi?"),
    ("{b} bo'limida {maosh} har oyning {n}-kunida kartaga o'tkaziladi. {maosh} kechiksa {xodim} {rahbar}ga yozma murojaat qiladi.",
     "{n}-kunida", "Qaysi bo'limda {maosh} oyning {n}-kunida o'tkaziladi?",
     "{b} bo'limida {maosh} qachon tushadi?"),
    ("{b} bo'limi {xodim}lari haftada {n} soat {masofa} ishlashi mumkin. {masofa} ish uchun {rahbar} {ruxsat}i talab qilinadi.",
     "{n} soat", "Qaysi bo'limda haftada {n} soat {masofa} ishlash mumkin?",
     "{b} bo'limida qancha vaqt {masofa} faoliyat yuritsa bo'ladi?"),
    ("{b} bo'limi {xodim}lari {safar}ga chiqqanda kunlik xarajat {n} ming so'm qilib belgilangan. {safar} hisoboti uch kunda topshiriladi.",
     "{n} ming so'm", "Qaysi bo'limda {safar}da kunlik xarajat {n} ming so'm?",
     "{b} bo'limida {safar} paytida sutkalik pul qancha?"),
    ("{b} bo'limida {kasal} {n} kun ichida kadrlar xizmatiga topshirilishi shart. {kasal} bo'lmasa kun ishsiz hisoblanadi.",
     "{n} kun ichida", "Qaysi bo'limda {kasal} {n} kun ichida topshiriladi?",
     "{b} bo'limida {kasal}ni qachongacha olib kelish kerak?"),
    ("{b} bo'limi tizimlarida {parol} kamida {n} belgidan iborat bo'ladi. {parol} har uch oyda yangilanadi.",
     "{n} belgidan", "Qaysi bo'limda {parol} kamida {n} belgidan iborat?",
     "{b} bo'limida {parol} uzunligi qanday bo'lishi lozim?"),
    ("{b} bo'limi {xodim}lariga berilgan {noutbuk} har {n} yilda almashtiriladi. Buzilgan {noutbuk} haqida {rahbar}ga xabar beriladi.",
     "{n} yilda", "Qaysi bo'limda {noutbuk} har {n} yilda almashtiriladi?",
     "{b} bo'limida {noutbuk} qachon yangisiga o'zgartiriladi?"),
    ("{b} bo'limi {xodim}lari yiliga kamida {n} soat {malaka}dan o'tadi. {malaka} xarajatini kompaniya to'laydi.",
     "{n} soat", "Qaysi bo'limda yiliga {n} soat {malaka} talab qilinadi?",
     "{b} bo'limida {malaka} davomiyligi qancha?"),
    ("{b} bo'limida {tushlik} uchun har kuni {n} ming so'm kompensatsiya beriladi. {tushlik} tanaffusi bir soat davom etadi.",
     "{n} ming so'm", "Qaysi bo'limda {tushlik} uchun {n} ming so'm beriladi?",
     "{b} bo'limida {tushlik} pulining qancha qismi qoplanadi?"),
    ("{b} bo'limi {xodim}lari uchun {avtobus} ertalab {n} daqiqa oralig'ida qatnaydi. {avtobus}dan foydalanish bepul.",
     "{n} daqiqa", "Qaysi bo'limda {avtobus} {n} daqiqa oralig'ida qatnaydi?",
     "{b} bo'limida {avtobus} qanchalik tez-tez keladi?"),
    ("{b} bo'limi {xodim}lari tibbiy {sugurta} bilan ta'minlanadi. {sugurta} qoplamasi {n} million so'mgacha.",
     "{n} million", "Qaysi bo'limda {sugurta} qoplamasi {n} million so'mgacha?",
     "{b} bo'limida {sugurta} davolanishni qancha summagacha yopadi?"),
    ("{b} bo'limida {forma} har {n} oyda bir marta beriladi. {forma}ni yo'qotgan {xodim} uni o'zi qoplaydi.",
     "{n} oyda", "Qaysi bo'limda {forma} har {n} oyda beriladi?",
     "{b} bo'limida yangi {forma} qanchalik tez-tez tarqatiladi?"),
]


def bosh_harf(matn):
    return re.sub(r"(^|\. )([a-z])", lambda m: m.group(1) + m.group(2).upper(), matn)


def korpus(seed=0, n_fon=30):
    """96 chunk (12 mavzu x 8 bo'lim), 288 savol (3 tur) va belgisiz fon matnlar."""
    rng = np.random.default_rng(seed)
    rasmiy = {k: v[0] for k, v in SINONIM.items()}
    ogzaki = {k: v[1] for k, v in SINONIM.items()}
    chunklar, savollar, fon = [], [], []
    for m, (shablon, javob, raqam, parafraz) in enumerate(MAVZULAR):
        sonlar = rng.choice(np.arange(3, 29), len(BOLIMLAR), replace=False)
        for j, b in enumerate(BOLIMLAR):
            n = int(sonlar[j])
            kod = f"{'ABCDEFGHKLMN'[m]}{'KLMNPRST'[j]}-{int(rng.integers(1000, 9999))}"
            i = len(chunklar)
            chunklar.append({"id": i, "mavzu": m, "bolim": b, "javob": javob.format(n=n),
                             "matn": bosh_harf(f"Hujjat {kod}. "
                                               + shablon.format(b=b.capitalize(), n=n, **rasmiy))})
            savollar.append({"q": bosh_harf(parafraz.format(b=b.capitalize(), **ogzaki)),
                             "tur": "parafraz", "gold": i})
            savollar.append({"q": f"{kod} bo'yicha qoida nima?", "tur": "kod", "gold": i})
            savollar.append({"q": bosh_harf(raqam.format(n=n, **rasmiy)), "tur": "raqam", "gold": i})
        for _ in range(n_fon):            # fon: har eslatmada atama varianti tasodifiy
            f = re.sub(r"\{(\w+)\}", lambda mm: SINONIM[mm.group(1)][int(rng.integers(0, 2))]
                       if mm.group(1) in SINONIM else "{" + mm.group(1) + "}", shablon)
            fon.append(f.format(b="kompaniya", n=int(rng.integers(3, 29))))
    return chunklar, savollar, fon


def tokenlar(matn):
    """Kichik harf, so'z/kod tokenlari; so'zlar 6 belgigacha kesiladi (oddiy o'zak)."""
    t = re.findall(r"[a-z0-9'\-]+", matn.lower())
    return [w if re.search(r"\d", w) else w[:6] for w in t if w.strip("-'")]


class BM25:
    def __init__(self, hujjatlar, k1=1.5, b=0.75):
        self.docs = [tokenlar(h) for h in hujjatlar]
        self.N, self.k1, self.b = len(self.docs), k1, b
        self.avgdl = np.mean([len(d) for d in self.docs])
        df = {}
        for d in self.docs:
            for w in set(d):
                df[w] = df.get(w, 0) + 1
        self.idf = {w: math.log(1 + (self.N - c + 0.5) / (c + 0.5)) for w, c in df.items()}
        self.tf = [{w: d.count(w) for w in set(d)} for d in self.docs]

    def ball(self, savol):
        s = np.zeros(self.N)
        for w in tokenlar(savol):
            for i, (tf, d) in enumerate(zip(self.tf, self.docs)):
                if w in tf:
                    norm = self.k1 * (1 - self.b + self.b * len(d) / self.avgdl)
                    s[i] += self.idf[w] * tf[w] * (self.k1 + 1) / (tf[w] + norm)
        return s


class LSA:
    """TF-IDF + TruncatedSVD; fon matnlar faqat 'embedding' ni o'rgatishga ketadi."""

    def __init__(self, hujjatlar, fon=(), k=12, seed=0):
        self.vek = TfidfVectorizer(analyzer=tokenlar, sublinear_tf=True)
        X = self.vek.fit_transform(list(fon) + list(hujjatlar))
        self.svd = TruncatedSVD(k, random_state=seed).fit(X)
        Z = self.svd.transform(self.vek.transform(hujjatlar))
        self.Z = Z / np.linalg.norm(Z, axis=1, keepdims=True)

    def ball(self, savol):
        z = self.svd.transform(self.vek.transform([savol]))[0]
        return self.Z @ (z / (np.linalg.norm(z) + 1e-12))


def rrf(*balllar, k=60, n=30):
    """Reciprocal Rank Fusion: har ro'yxatdan top-n nomzod (ball > 0)."""
    s = np.zeros(len(balllar[0]))
    for r in balllar:
        tartib = np.argsort(-r, kind="stable")[:n]
        tartib = tartib[r[tartib] > 0]
        s[tartib] += 1.0 / (k + np.arange(1, len(tartib) + 1))
    return s

def minmax(x):
    return (x - x.min()) / (x.max() - x.min() + 1e-12)


def orin(ball, gold):
    """Oltin chunkning o'rni (1 dan); tenglikda - eng yomon o'rin (optimizmsiz)."""
    return int((ball >= ball[gold]).sum())


def main() -> None:
    chunklar, savollar, fon = korpus()
    matnlar = [c["matn"] for c in chunklar]
    bm = BM25(matnlar)
    lsa0 = LSA(matnlar, fon=(), k=12)
    lsa = LSA(matnlar, fon=fon, k=12)

    print("=== 1. Retrieverlar ===")
    print(f"  BM25: noldan, k1 = 1.5, b = 0.75; lug'at {len(bm.idf)} token")
    print(f"  LSA: TF-IDF + SVD(12); fonsiz - faqat {len(matnlar)} chunk, "
          f"fon bilan - yana {len(fon)} belgisiz matn")
    print("  RRF: 1 / (60 + o'rin), har ro'yxatdan top-30; vaznli: 0.5 minmax(BM25) + 0.5 minmax(LSA)")
    for nom, model in (("fonsiz", lsa0), ("fon bilan", lsa)):
        qator = []
        for a, b in (("dam olish", "ta'til"), ("komandirovka", "xizmat safari"),
                     ("dam olish", "xizmat safari")):
            za, zb = (model.svd.transform(model.vek.transform([x]))[0] for x in (a, b))
            cos = za @ zb / (np.linalg.norm(za) * np.linalg.norm(zb) + 1e-12)
            qator.append(f"{a} ~ {b}: {cos:.2f}")
        print(f"  LSA {nom:<9} cos: " + "; ".join(qator))

    usullar = {
        "BM25": bm.ball,
        "LSA fonsiz": lsa0.ball,
        "LSA fon": lsa.ball,
        "RRF": lambda q: rrf(bm.ball(q), lsa.ball(q)),
        "vaznli": lambda q: 0.5 * minmax(bm.ball(q)) + 0.5 * minmax(lsa.ball(q)),
    }
    orinlar = {n: np.array([orin(f(s["q"]), s["gold"]) for s in savollar])
               for n, f in usullar.items()}
    tur = np.array([s["tur"] for s in savollar])

    print("\n=== 2. Savol turi bo'yicha: recall@1 / recall@5 / MRR ===")
    print("  usul          parafraz            kod                 raqam")
    for n, o in orinlar.items():
        qator = []
        for t in ("parafraz", "kod", "raqam"):
            m = tur == t
            qator.append(f"{(o[m] <= 1).mean():.2f}/{(o[m] <= 5).mean():.2f}/{(1 / o[m]).mean():.3f}")
        print(f"  {n:<12} " + "  ".join(f"{q:<18}" for q in qator))

    print("\n=== 3. Juftlashgan farq (RR, har savol), SE va xulosa ===")
    for a, b in (("RRF", "BM25"), ("RRF", "LSA fon"), ("vaznli", "RRF")):
        for t in ("parafraz", "kod", "raqam"):
            m = tur == t
            d = 1 / orinlar[a][m] - 1 / orinlar[b][m]
            se = d.std(ddof=1) / math.sqrt(m.sum())
            x = ("sezilarli yaxshi" if d.mean() > 2 * se else
                 "sezilarli yomon" if d.mean() < -2 * se else "sezilarli farq yo'q")
            print(f"  {a:<6} - {b:<7} [{t:<8}] {d.mean():+.3f} (SE {se:.3f}) -> {x}")

    print("\n=== 4. Qaror: har turda eng yaxshisidan sezilarli yomon bo'lmaganlar ===")
    for t in ("parafraz", "kod", "raqam"):
        m = tur == t
        rrm = {n: 1 / o[m] for n, o in orinlar.items()}
        eng = max(rrm, key=lambda n: rrm[n].mean())
        yaxshi = []
        for n in usullar:
            d = rrm[eng] - rrm[n]
            se = d.std(ddof=1) / math.sqrt(m.sum())
            if n == eng or d.mean() <= 2 * se:
                yaxshi.append(n)
        print(f"  {t:<9} eng yaxshi {eng} (MRR {rrm[eng].mean():.3f}); teng kuchlilar: {yaxshi}")
    umumiy = {n: (1 / o).mean() for n, o in orinlar.items()}
    print("  umumiy MRR: " + ", ".join(f"{n} {v:.3f}" for n, v in umumiy.items()))
    print("  ⭐ Gibrid - leksik va semantik signalni birlashtiradi; turi bo'yicha tekshiring")


if __name__ == "__main__":
    main()

=== 1. Retrieverlar ===
  BM25: noldan, k1 = 1.5, b = 0.75; lug'at 241 token
  LSA: TF-IDF + SVD(12); fonsiz - faqat 96 chunk, fon bilan - yana 360 belgisiz matn
  RRF: 1 / (60 + o'rin), har ro'yxatdan top-30; vaznli: 0.5 minmax(BM25) + 0.5 minmax(LSA)
  LSA fonsiz    cos: dam olish ~ ta'til: 0.00; komandirovka ~ xizmat safari: 0.00; dam olish ~ xizmat safari: 0.00
  LSA fon bilan cos: dam olish ~ ta'til: 1.00; komandirovka ~ xizmat safari: 0.90; dam olish ~ xizmat safari: -0.11

=== 2. Savol turi bo'yicha: recall@1 / recall@5 / MRR ===
  usul          parafraz            kod                 raqam
  BM25         0.08/0.18/0.209     1.00/1.00/1.000     1.00/1.00/1.000
  LSA fonsiz   0.01/0.03/0.053     0.29/0.82/0.507     0.48/0.94/0.642
  LSA fon      0.22/0.66/0.404     0.28/0.81/0.478     0.28/0.80/0.491
  RRF          0.69/0.85/0.771     1.00/1.00/1.000     0.55/0.99/0.741
  vaznli       0.89/0.92/0.910     1.00/1.00/1.000     1.00/1.00/1.000

=== 3. Juftlashgan farq (RR, har savol), SE va xulosa ===
  RRF    - BM25    [parafraz] +0.562 (SE 0.037) -> sezilarli yaxshi
  RRF    - BM25    [kod     ] +0.000 (SE 0.000) -> sezilarli farq yo'q
  RRF    - BM25    [raqam   ] -0.259 (SE 0.031) -> sezilarli yomon
  RRF    - LSA fon [parafraz] +0.367 (SE 0.042) -> sezilarli yaxshi
  RRF    - LSA fon [kod     ] +0.522 (SE 0.035) -> sezilarli yaxshi
  RRF    - LSA fon [raqam   ] +0.250 (SE 0.026) -> sezilarli yaxshi
  vaznli - RRF     [parafraz] +0.139 (SE 0.030) -> sezilarli yaxshi
  vaznli - RRF     [kod     ] +0.000 (SE 0.000) -> sezilarli farq yo'q
  vaznli - RRF     [raqam   ] +0.259 (SE 0.031) -> sezilarli yaxshi

=== 4. Qaror: har turda eng yaxshisidan sezilarli yomon bo'lmaganlar ===
  parafraz  eng yaxshi vaznli (MRR 0.910); teng kuchlilar: ['vaznli']
  kod       eng yaxshi BM25 (MRR 1.000); teng kuchlilar: ['BM25', 'RRF', 'vaznli']
  raqam     eng yaxshi BM25 (MRR 1.000); teng kuchlilar: ['BM25', 'vaznli']
  umumiy MRR: BM25 0.736, LSA fonsiz 0.401, LSA fon 0.458, RRF 0.838, vaznli 0.970
  ⭐ Gibrid - leksik va semantik signalni birlashtiradi; turi bo'yicha tekshiring

"""Ikki bosqichli qidiruv: RRF top-20 -> LogReg reranker (savol-chunk xususiyatlari)."""

import math
import re
import warnings

import numpy as np
from sklearn.decomposition import TruncatedSVD
from sklearn.feature_extraction.text import TfidfVectorizer
from sklearn.linear_model import LogisticRegression
from sklearn.model_selection import GroupKFold

BOLIMLAR = ["moliya", "marketing", "kadrlar", "axborot", "logistika", "savdo",
            "yuridik", "omborxona"]
# (rasmiy atama - hujjatlarda, so'zlashuv atamasi - foydalanuvchi savollarida)
SINONIM = {
    "tatil": ("ta'til", "dam olish"), "xodim": ("xodim", "ishchi"),
    "ariza": ("ariza", "so'rovnoma"), "rahbar": ("rahbar", "boshliq"),
    "maosh": ("maosh", "ish haqi"), "masofa": ("masofaviy", "uydan"),
    "safar": ("xizmat safari", "komandirovka"),
    "kasal": ("kasallik varaqasi", "bemorlik ma'lumotnomasi"),
    "parol": ("parol", "maxfiy kod"), "noutbuk": ("noutbuk", "kompyuter"),
    "malaka": ("malaka oshirish", "o'qish kursi"), "tushlik": ("tushlik", "ovqat"),
    "avtobus": ("xizmat avtobusi", "transport"), "sugurta": ("sug'urta", "polis"),
    "forma": ("forma", "ish kiyimi"), "ruxsat": ("ruxsat", "izn"),
}
# (hujjat shabloni, javob, raqamli savol, parafraz savol)
MAVZULAR = [
    ("{b} bo'limi {xodim}lari uchun yillik {tatil} tartibi. Har bir {xodim}ga yiliga {n} kunlik {tatil} beriladi. {ariza} {rahbar}ga ikki hafta oldin topshiriladi.",
     "{n} kunlik", "Qaysi bo'limda yiliga {n} kunlik {tatil} beriladi?",
     "{b} bo'limida {xodim} {tatil}ga necha kunga chiqadi?"),
    ("{b} bo'limida {maosh} har oyning {n}-kunida kartaga o'tkaziladi. {maosh} kechiksa {xodim} {rahbar}ga yozma murojaat qiladi.",
     "{n}-kunida", "Qaysi bo'limda {maosh} oyning {n}-kunida o'tkaziladi?",
     "{b} bo'limida {maosh} qachon tushadi?"),
    ("{b} bo'limi {xodim}lari haftada {n} soat {masofa} ishlashi mumkin. {masofa} ish uchun {rahbar} {ruxsat}i talab qilinadi.",
     "{n} soat", "Qaysi bo'limda haftada {n} soat {masofa} ishlash mumkin?",
     "{b} bo'limida qancha vaqt {masofa} faoliyat yuritsa bo'ladi?"),
    ("{b} bo'limi {xodim}lari {safar}ga chiqqanda kunlik xarajat {n} ming so'm qilib belgilangan. {safar} hisoboti uch kunda topshiriladi.",
     "{n} ming so'm", "Qaysi bo'limda {safar}da kunlik xarajat {n} ming so'm?",
     "{b} bo'limida {safar} paytida sutkalik pul qancha?"),
    ("{b} bo'limida {kasal} {n} kun ichida kadrlar xizmatiga topshirilishi shart. {kasal} bo'lmasa kun ishsiz hisoblanadi.",
     "{n} kun ichida", "Qaysi bo'limda {kasal} {n} kun ichida topshiriladi?",
     "{b} bo'limida {kasal}ni qachongacha olib kelish kerak?"),
    ("{b} bo'limi tizimlarida {parol} kamida {n} belgidan iborat bo'ladi. {parol} har uch oyda yangilanadi.",
     "{n} belgidan", "Qaysi bo'limda {parol} kamida {n} belgidan iborat?",
     "{b} bo'limida {parol} uzunligi qanday bo'lishi lozim?"),
    ("{b} bo'limi {xodim}lariga berilgan {noutbuk} har {n} yilda almashtiriladi. Buzilgan {noutbuk} haqida {rahbar}ga xabar beriladi.",
     "{n} yilda", "Qaysi bo'limda {noutbuk} har {n} yilda almashtiriladi?",
     "{b} bo'limida {noutbuk} qachon yangisiga o'zgartiriladi?"),
    ("{b} bo'limi {xodim}lari yiliga kamida {n} soat {malaka}dan o'tadi. {malaka} xarajatini kompaniya to'laydi.",
     "{n} soat", "Qaysi bo'limda yiliga {n} soat {malaka} talab qilinadi?",
     "{b} bo'limida {malaka} davomiyligi qancha?"),
    ("{b} bo'limida {tushlik} uchun har kuni {n} ming so'm kompensatsiya beriladi. {tushlik} tanaffusi bir soat davom etadi.",
     "{n} ming so'm", "Qaysi bo'limda {tushlik} uchun {n} ming so'm beriladi?",
     "{b} bo'limida {tushlik} pulining qancha qismi qoplanadi?"),
    ("{b} bo'limi {xodim}lari uchun {avtobus} ertalab {n} daqiqa oralig'ida qatnaydi. {avtobus}dan foydalanish bepul.",
     "{n} daqiqa", "Qaysi bo'limda {avtobus} {n} daqiqa oralig'ida qatnaydi?",
     "{b} bo'limida {avtobus} qanchalik tez-tez keladi?"),
    ("{b} bo'limi {xodim}lari tibbiy {sugurta} bilan ta'minlanadi. {sugurta} qoplamasi {n} million so'mgacha.",
     "{n} million", "Qaysi bo'limda {sugurta} qoplamasi {n} million so'mgacha?",
     "{b} bo'limida {sugurta} davolanishni qancha summagacha yopadi?"),
    ("{b} bo'limida {forma} har {n} oyda bir marta beriladi. {forma}ni yo'qotgan {xodim} uni o'zi qoplaydi.",
     "{n} oyda", "Qaysi bo'limda {forma} har {n} oyda beriladi?",
     "{b} bo'limida yangi {forma} qanchalik tez-tez tarqatiladi?"),
]


def bosh_harf(matn):
    return re.sub(r"(^|\. )([a-z])", lambda m: m.group(1) + m.group(2).upper(), matn)


def korpus(seed=0, n_fon=30):
    """96 chunk (12 mavzu x 8 bo'lim), 288 savol (3 tur) va belgisiz fon matnlar."""
    rng = np.random.default_rng(seed)
    rasmiy = {k: v[0] for k, v in SINONIM.items()}
    ogzaki = {k: v[1] for k, v in SINONIM.items()}
    chunklar, savollar, fon = [], [], []
    for m, (shablon, javob, raqam, parafraz) in enumerate(MAVZULAR):
        sonlar = rng.choice(np.arange(3, 29), len(BOLIMLAR), replace=False)
        for j, b in enumerate(BOLIMLAR):
            n = int(sonlar[j])
            kod = f"{'ABCDEFGHKLMN'[m]}{'KLMNPRST'[j]}-{int(rng.integers(1000, 9999))}"
            i = len(chunklar)
            chunklar.append({"id": i, "mavzu": m, "bolim": b, "javob": javob.format(n=n),
                             "matn": bosh_harf(f"Hujjat {kod}. "
                                               + shablon.format(b=b.capitalize(), n=n, **rasmiy))})
            savollar.append({"q": bosh_harf(parafraz.format(b=b.capitalize(), **ogzaki)),
                             "tur": "parafraz", "gold": i})
            savollar.append({"q": f"{kod} bo'yicha qoida nima?", "tur": "kod", "gold": i})
            savollar.append({"q": bosh_harf(raqam.format(n=n, **rasmiy)), "tur": "raqam", "gold": i})
        for _ in range(n_fon):            # fon: har eslatmada atama varianti tasodifiy
            f = re.sub(r"\{(\w+)\}", lambda mm: SINONIM[mm.group(1)][int(rng.integers(0, 2))]
                       if mm.group(1) in SINONIM else "{" + mm.group(1) + "}", shablon)
            fon.append(f.format(b="kompaniya", n=int(rng.integers(3, 29))))
    return chunklar, savollar, fon


def tokenlar(matn):
    """Kichik harf, so'z/kod tokenlari; so'zlar 6 belgigacha kesiladi (oddiy o'zak)."""
    t = re.findall(r"[a-z0-9'\-]+", matn.lower())
    return [w if re.search(r"\d", w) else w[:6] for w in t if w.strip("-'")]


class BM25:
    def __init__(self, hujjatlar, k1=1.5, b=0.75):
        self.docs = [tokenlar(h) for h in hujjatlar]
        self.N, self.k1, self.b = len(self.docs), k1, b
        self.avgdl = np.mean([len(d) for d in self.docs])
        df = {}
        for d in self.docs:
            for w in set(d):
                df[w] = df.get(w, 0) + 1
        self.idf = {w: math.log(1 + (self.N - c + 0.5) / (c + 0.5)) for w, c in df.items()}
        self.tf = [{w: d.count(w) for w in set(d)} for d in self.docs]

    def ball(self, savol):
        s = np.zeros(self.N)
        for w in tokenlar(savol):
            for i, (tf, d) in enumerate(zip(self.tf, self.docs)):
                if w in tf:
                    norm = self.k1 * (1 - self.b + self.b * len(d) / self.avgdl)
                    s[i] += self.idf[w] * tf[w] * (self.k1 + 1) / (tf[w] + norm)
        return s


class LSA:
    """TF-IDF + TruncatedSVD; fon matnlar faqat 'embedding' ni o'rgatishga ketadi."""

    def __init__(self, hujjatlar, fon=(), k=12, seed=0):
        self.vek = TfidfVectorizer(analyzer=tokenlar, sublinear_tf=True)
        X = self.vek.fit_transform(list(fon) + list(hujjatlar))
        self.svd = TruncatedSVD(k, random_state=seed).fit(X)
        Z = self.svd.transform(self.vek.transform(hujjatlar))
        self.Z = Z / np.linalg.norm(Z, axis=1, keepdims=True)

    def ball(self, savol):
        z = self.svd.transform(self.vek.transform([savol]))[0]
        return self.Z @ (z / (np.linalg.norm(z) + 1e-12))


def rrf(*balllar, k=60, n=30):
    """Reciprocal Rank Fusion: har ro'yxatdan top-n nomzod (ball > 0)."""
    s = np.zeros(len(balllar[0]))
    for r in balllar:
        tartib = np.argsort(-r, kind="stable")[:n]
        tartib = tartib[r[tartib] > 0]
        s[tartib] += 1.0 / (k + np.arange(1, len(tartib) + 1))
    return s

NOMZOD = 20
XUSUSIYATLAR = ["bm25", "lsa", "rrf_orin", "bolim_mos", "raqam_mos", "kod_mos", "soz_ulushi"]


def xususiyatlar(savol, cid, bm_b, lsa_b, orin, chunk_tok):
    q = tokenlar(savol)
    c = chunk_tok[cid]
    raqamlar = [w for w in q if re.fullmatch(r"\d+(-\w+)?", w)]
    kodlar = [w for w in q if re.fullmatch(r"[a-z]{2}-\d{4}", w)]
    bolim = [w for w in q if w in {b[:6] for b in BOLIMLAR}]
    return [bm_b, lsa_b, 1.0 / orin,
            float(any(w in c for w in bolim)),
            float(any(w in c for w in raqamlar)),
            float(any(w in c for w in kodlar)),
            np.mean([w in c for w in q])]


def main() -> None:
    chunklar, savollar, fon = korpus()
    matnlar = [c["matn"] for c in chunklar]
    chunk_tok = [set(tokenlar(m)) for m in matnlar]
    bm, lsa = BM25(matnlar), LSA(matnlar, fon=fon, k=12)

    print(f"=== 1. 1-bosqich: RRF, har savolga top-{NOMZOD} nomzod ===")
    X, y, guruh, sav_id, nomzodlar, rrf_orin = [], [], [], [], [], []
    for si, s in enumerate(savollar):
        b1, b2 = bm.ball(s["q"]), lsa.ball(s["q"])
        f = rrf(b1, b2)
        tartib = np.argsort(-f, kind="stable")
        rrf_orin.append(int((f >= f[s["gold"]]).sum()))       # tenglikda - eng yomon o'rin
        top = tartib[:NOMZOD]
        nomzodlar.append(top)
        b1n = b1[top] / (b1[top].max() + 1e-12)
        for o, cid in enumerate(top, 1):
            X.append(xususiyatlar(s["q"], cid, b1n[o - 1], b2[cid], o, chunk_tok))
            y.append(int(cid == s["gold"]))
            guruh.append(s["gold"])
            sav_id.append(si)
    X, y, guruh, sav_id = map(np.array, (X, y, guruh, sav_id))
    rrf_orin = np.array(rrf_orin)
    print(f"  juftliklar {len(y)} (musbat {y.sum()}), oltin top-{NOMZOD} ichida: "
          f"{(rrf_orin <= NOMZOD).mean():.3f} - bu reranker uchun shift")

    print("\n=== 2. 2-bosqich: LogReg, GroupKFold (oltin chunk bo'yicha, 4 fold) ===")
    ehtimol = np.zeros(len(y))
    koef = []
    for oq, ts in GroupKFold(4).split(X, y, guruh):
        with warnings.catch_warnings():
            warnings.simplefilter("ignore")
            m = LogisticRegression(C=1.0, max_iter=2000).fit(X[oq], y[oq])
        ehtimol[ts] = m.predict_proba(X[ts])[:, 1]
        koef.append(m.coef_[0])
    koef = np.mean(koef, axis=0)
    for n, k in sorted(zip(XUSUSIYATLAR, koef), key=lambda t: -abs(t[1])):
        print(f"  {n:<11} {k:+.2f}")
    print("  har savol faqat o'z chunki ko'rilmagan foldning modeli bilan baholandi")

    rerank_orin = []
    for si, s in enumerate(savollar):
        m = sav_id == si
        oltin = nomzodlar[si] == s["gold"]
        rerank_orin.append(int((ehtimol[m] >= ehtimol[m][oltin][0]).sum()) if oltin.any() else 10 ** 6)
    rerank_orin = np.array(rerank_orin)

    print("\n=== 3. Natija: RRF va RRF + reranker ===")
    tur = np.array([s["tur"] for s in savollar])
    print("  tur        RRF r@1  +rerank r@1   RRF MRR  +rerank MRR   farq MRR (SE)")
    for t in ("parafraz", "kod", "raqam", "hammasi"):
        m = tur == t if t != "hammasi" else np.ones(len(tur), bool)
        a, b = 1 / rrf_orin[m], 1 / rerank_orin[m]
        d = b - a
        se = d.std(ddof=1) / math.sqrt(m.sum())
        belgi = "*" if abs(d.mean()) > 2 * se else " "
        print(f"  {t:<9} {(rrf_orin[m] == 1).mean():>8.3f} {(rerank_orin[m] == 1).mean():>12.3f} "
              f"{a.mean():>9.3f} {b.mean():>12.3f}   {d.mean():+.3f} ({se:.3f}){belgi}")
    print("  * - farq 2*SE dan katta")

    print("\n=== 4. Narx va chegaralar ===")
    print(f"  reranker har savolga {NOMZOD} ta juftlikni ko'radi (butun korpus - {len(chunklar)})")
    print("  1-bosqich shifti (oltin top-N ichida): " + ", ".join(
        f"N={n}: {(rrf_orin <= n).mean():.3f}" for n in (1, 3, 5, 10, 20)))
    print("  N kichik - arzon, lekin 1-bosqich yo'qotgan chunkni reranker qaytara olmaydi")
    yomonlashgan = int(((rerank_orin > 1) & (rrf_orin == 1)).sum())
    tuzalgan = int(((rerank_orin == 1) & (rrf_orin > 1)).sum())
    print(f"  1-o'rin: tuzalgan {tuzalgan}, buzilgan {yomonlashgan}")
    print("  ⭐ Tez retrieval keng to'r tashlaydi, aniqroq model faqat nomzodlarni tartiblaydi")


if __name__ == "__main__":
    main()

=== 1. 1-bosqich: RRF, har savolga top-20 nomzod ===
  juftliklar 5760 (musbat 288), oltin top-20 ichida: 1.000 - bu reranker uchun shift

=== 2. 2-bosqich: LogReg, GroupKFold (oltin chunk bo'yicha, 4 fold) ===
  lsa         +5.55
  raqam_mos   +5.29
  kod_mos     +4.38
  bolim_mos   +4.20
  rrf_orin    +2.82
  bm25        +1.40
  soz_ulushi  -0.32
  har savol faqat o'z chunki ko'rilmagan foldning modeli bilan baholandi

=== 3. Natija: RRF va RRF + reranker ===
  tur        RRF r@1  +rerank r@1   RRF MRR  +rerank MRR   farq MRR (SE)
  parafraz     0.688        0.844     0.771        0.922   +0.151 0.027-bob*
  kod          1.000        1.000     1.000        1.000   +0.000 0.000-bob
  raqam        0.552        1.000     0.741        1.000   +0.259 0.031-bob*
  hammasi      0.747        0.948     0.838        0.974   +0.136 0.015-bob*
  * - farq 2*SE dan katta

=== 4. Narx va chegaralar ===
  reranker har savolga 20 ta juftlikni ko'radi (butun korpus - 96)
  1-bosqich shifti (oltin top-N ichida): N=1: 0.747, N=3: 0.906, N=5: 0.948, N=10: 1.000, N=20: 1.000
  N kichik - arzon, lekin 1-bosqich yo'qotgan chunkni reranker qaytara olmaydi
  1-o'rin: tuzalgan 58, buzilgan 0
  ⭐ Tez retrieval keng to'r tashlaydi, aniqroq model faqat nomzodlarni tartiblaydi

"""k ni tanlash: answer-in-context, shovqin, xarajat, oddiy o'quvchi va xatolar tahlili."""

import math
import re

import numpy as np
from sklearn.decomposition import TruncatedSVD
from sklearn.feature_extraction.text import TfidfVectorizer

BOLIMLAR = ["moliya", "marketing", "kadrlar", "axborot", "logistika", "savdo",
            "yuridik", "omborxona"]
# (rasmiy atama - hujjatlarda, so'zlashuv atamasi - foydalanuvchi savollarida)
SINONIM = {
    "tatil": ("ta'til", "dam olish"), "xodim": ("xodim", "ishchi"),
    "ariza": ("ariza", "so'rovnoma"), "rahbar": ("rahbar", "boshliq"),
    "maosh": ("maosh", "ish haqi"), "masofa": ("masofaviy", "uydan"),
    "safar": ("xizmat safari", "komandirovka"),
    "kasal": ("kasallik varaqasi", "bemorlik ma'lumotnomasi"),
    "parol": ("parol", "maxfiy kod"), "noutbuk": ("noutbuk", "kompyuter"),
    "malaka": ("malaka oshirish", "o'qish kursi"), "tushlik": ("tushlik", "ovqat"),
    "avtobus": ("xizmat avtobusi", "transport"), "sugurta": ("sug'urta", "polis"),
    "forma": ("forma", "ish kiyimi"), "ruxsat": ("ruxsat", "izn"),
}
# (hujjat shabloni, javob, raqamli savol, parafraz savol)
MAVZULAR = [
    ("{b} bo'limi {xodim}lari uchun yillik {tatil} tartibi. Har bir {xodim}ga yiliga {n} kunlik {tatil} beriladi. {ariza} {rahbar}ga ikki hafta oldin topshiriladi.",
     "{n} kunlik", "Qaysi bo'limda yiliga {n} kunlik {tatil} beriladi?",
     "{b} bo'limida {xodim} {tatil}ga necha kunga chiqadi?"),
    ("{b} bo'limida {maosh} har oyning {n}-kunida kartaga o'tkaziladi. {maosh} kechiksa {xodim} {rahbar}ga yozma murojaat qiladi.",
     "{n}-kunida", "Qaysi bo'limda {maosh} oyning {n}-kunida o'tkaziladi?",
     "{b} bo'limida {maosh} qachon tushadi?"),
    ("{b} bo'limi {xodim}lari haftada {n} soat {masofa} ishlashi mumkin. {masofa} ish uchun {rahbar} {ruxsat}i talab qilinadi.",
     "{n} soat", "Qaysi bo'limda haftada {n} soat {masofa} ishlash mumkin?",
     "{b} bo'limida qancha vaqt {masofa} faoliyat yuritsa bo'ladi?"),
    ("{b} bo'limi {xodim}lari {safar}ga chiqqanda kunlik xarajat {n} ming so'm qilib belgilangan. {safar} hisoboti uch kunda topshiriladi.",
     "{n} ming so'm", "Qaysi bo'limda {safar}da kunlik xarajat {n} ming so'm?",
     "{b} bo'limida {safar} paytida sutkalik pul qancha?"),
    ("{b} bo'limida {kasal} {n} kun ichida kadrlar xizmatiga topshirilishi shart. {kasal} bo'lmasa kun ishsiz hisoblanadi.",
     "{n} kun ichida", "Qaysi bo'limda {kasal} {n} kun ichida topshiriladi?",
     "{b} bo'limida {kasal}ni qachongacha olib kelish kerak?"),
    ("{b} bo'limi tizimlarida {parol} kamida {n} belgidan iborat bo'ladi. {parol} har uch oyda yangilanadi.",
     "{n} belgidan", "Qaysi bo'limda {parol} kamida {n} belgidan iborat?",
     "{b} bo'limida {parol} uzunligi qanday bo'lishi lozim?"),
    ("{b} bo'limi {xodim}lariga berilgan {noutbuk} har {n} yilda almashtiriladi. Buzilgan {noutbuk} haqida {rahbar}ga xabar beriladi.",
     "{n} yilda", "Qaysi bo'limda {noutbuk} har {n} yilda almashtiriladi?",
     "{b} bo'limida {noutbuk} qachon yangisiga o'zgartiriladi?"),
    ("{b} bo'limi {xodim}lari yiliga kamida {n} soat {malaka}dan o'tadi. {malaka} xarajatini kompaniya to'laydi.",
     "{n} soat", "Qaysi bo'limda yiliga {n} soat {malaka} talab qilinadi?",
     "{b} bo'limida {malaka} davomiyligi qancha?"),
    ("{b} bo'limida {tushlik} uchun har kuni {n} ming so'm kompensatsiya beriladi. {tushlik} tanaffusi bir soat davom etadi.",
     "{n} ming so'm", "Qaysi bo'limda {tushlik} uchun {n} ming so'm beriladi?",
     "{b} bo'limida {tushlik} pulining qancha qismi qoplanadi?"),
    ("{b} bo'limi {xodim}lari uchun {avtobus} ertalab {n} daqiqa oralig'ida qatnaydi. {avtobus}dan foydalanish bepul.",
     "{n} daqiqa", "Qaysi bo'limda {avtobus} {n} daqiqa oralig'ida qatnaydi?",
     "{b} bo'limida {avtobus} qanchalik tez-tez keladi?"),
    ("{b} bo'limi {xodim}lari tibbiy {sugurta} bilan ta'minlanadi. {sugurta} qoplamasi {n} million so'mgacha.",
     "{n} million", "Qaysi bo'limda {sugurta} qoplamasi {n} million so'mgacha?",
     "{b} bo'limida {sugurta} davolanishni qancha summagacha yopadi?"),
    ("{b} bo'limida {forma} har {n} oyda bir marta beriladi. {forma}ni yo'qotgan {xodim} uni o'zi qoplaydi.",
     "{n} oyda", "Qaysi bo'limda {forma} har {n} oyda beriladi?",
     "{b} bo'limida yangi {forma} qanchalik tez-tez tarqatiladi?"),
]


def bosh_harf(matn):
    return re.sub(r"(^|\. )([a-z])", lambda m: m.group(1) + m.group(2).upper(), matn)


def korpus(seed=0, n_fon=30):
    """96 chunk (12 mavzu x 8 bo'lim), 288 savol (3 tur) va belgisiz fon matnlar."""
    rng = np.random.default_rng(seed)
    rasmiy = {k: v[0] for k, v in SINONIM.items()}
    ogzaki = {k: v[1] for k, v in SINONIM.items()}
    chunklar, savollar, fon = [], [], []
    for m, (shablon, javob, raqam, parafraz) in enumerate(MAVZULAR):
        sonlar = rng.choice(np.arange(3, 29), len(BOLIMLAR), replace=False)
        for j, b in enumerate(BOLIMLAR):
            n = int(sonlar[j])
            kod = f"{'ABCDEFGHKLMN'[m]}{'KLMNPRST'[j]}-{int(rng.integers(1000, 9999))}"
            i = len(chunklar)
            chunklar.append({"id": i, "mavzu": m, "bolim": b, "javob": javob.format(n=n),
                             "matn": bosh_harf(f"Hujjat {kod}. "
                                               + shablon.format(b=b.capitalize(), n=n, **rasmiy))})
            savollar.append({"q": bosh_harf(parafraz.format(b=b.capitalize(), **ogzaki)),
                             "tur": "parafraz", "gold": i})
            savollar.append({"q": f"{kod} bo'yicha qoida nima?", "tur": "kod", "gold": i})
            savollar.append({"q": bosh_harf(raqam.format(n=n, **rasmiy)), "tur": "raqam", "gold": i})
        for _ in range(n_fon):            # fon: har eslatmada atama varianti tasodifiy
            f = re.sub(r"\{(\w+)\}", lambda mm: SINONIM[mm.group(1)][int(rng.integers(0, 2))]
                       if mm.group(1) in SINONIM else "{" + mm.group(1) + "}", shablon)
            fon.append(f.format(b="kompaniya", n=int(rng.integers(3, 29))))
    return chunklar, savollar, fon


def tokenlar(matn):
    """Kichik harf, so'z/kod tokenlari; so'zlar 6 belgigacha kesiladi (oddiy o'zak)."""
    t = re.findall(r"[a-z0-9'\-]+", matn.lower())
    return [w if re.search(r"\d", w) else w[:6] for w in t if w.strip("-'")]


class BM25:
    def __init__(self, hujjatlar, k1=1.5, b=0.75):
        self.docs = [tokenlar(h) for h in hujjatlar]
        self.N, self.k1, self.b = len(self.docs), k1, b
        self.avgdl = np.mean([len(d) for d in self.docs])
        df = {}
        for d in self.docs:
            for w in set(d):
                df[w] = df.get(w, 0) + 1
        self.idf = {w: math.log(1 + (self.N - c + 0.5) / (c + 0.5)) for w, c in df.items()}
        self.tf = [{w: d.count(w) for w in set(d)} for d in self.docs]

    def ball(self, savol):
        s = np.zeros(self.N)
        for w in tokenlar(savol):
            for i, (tf, d) in enumerate(zip(self.tf, self.docs)):
                if w in tf:
                    norm = self.k1 * (1 - self.b + self.b * len(d) / self.avgdl)
                    s[i] += self.idf[w] * tf[w] * (self.k1 + 1) / (tf[w] + norm)
        return s


class LSA:
    """TF-IDF + TruncatedSVD; fon matnlar faqat 'embedding' ni o'rgatishga ketadi."""

    def __init__(self, hujjatlar, fon=(), k=12, seed=0):
        self.vek = TfidfVectorizer(analyzer=tokenlar, sublinear_tf=True)
        X = self.vek.fit_transform(list(fon) + list(hujjatlar))
        self.svd = TruncatedSVD(k, random_state=seed).fit(X)
        Z = self.svd.transform(self.vek.transform(hujjatlar))
        self.Z = Z / np.linalg.norm(Z, axis=1, keepdims=True)

    def ball(self, savol):
        z = self.svd.transform(self.vek.transform([savol]))[0]
        return self.Z @ (z / (np.linalg.norm(z) + 1e-12))


def rrf(*balllar, k=60, n=30):
    """Reciprocal Rank Fusion: har ro'yxatdan top-n nomzod (ball > 0)."""
    s = np.zeros(len(balllar[0]))
    for r in balllar:
        tartib = np.argsort(-r, kind="stable")[:n]
        tartib = tartib[r[tartib] > 0]
        s[tartib] += 1.0 / (k + np.arange(1, len(tartib) + 1))
    return s

NARX_1K_TOKEN = 0.003    # FARAZIY narx (1000 kirish tokeni uchun) - haqiqiy narx emas
TOKEN_SOZ = 1.6          # FARAZIY: o'zbekcha so'zga o'rtacha token (25.2-darsdagidek o'lchang)


def oquvchi(savol, kontekst, matnlar):
    """Oddiy ekstraktiv o'quvchi (LLM EMAS): so'z mosligi eng ko'p chunkdan javob oladi."""
    q = set(tokenlar(savol))
    ball = [len(q & set(tokenlar(matnlar[c]))) for c in kontekst]
    return kontekst[int(np.argmax(ball))]       # tenglikda - retrieval tartibi


def main() -> None:
    chunklar, savollar, fon = korpus()
    matnlar = [c["matn"] for c in chunklar]
    bm, lsa = BM25(matnlar), LSA(matnlar, fon=fon, k=12)
    tartiblar = [np.argsort(-rrf(bm.ball(s["q"]), lsa.ball(s["q"])), kind="stable")
                 for s in savollar]
    tur = np.array([s["tur"] for s in savollar])
    uzunlik = np.array([len(m.split()) for m in matnlar])
    K = (1, 2, 3, 5, 8, 10)

    print("=== 1. k bo'yicha: kontekstda javob bormi va u qanchaga tushadi (RRF) ===")
    print("   k  oltin_kontekstda  javob_satri  faqat_raqam  shovqin  token/so'rov  narx/1000")
    oltin, raqam = {}, {}
    for k in K:
        o, satr, r, tok = [], [], [], []
        for s, t in zip(savollar, tartiblar):
            top = t[:k]
            o.append(s["gold"] in top)
            satr.append(any(chunklar[s["gold"]]["javob"] in matnlar[c] for c in top))
            son = re.match(r"\d+", chunklar[s["gold"]]["javob"]).group()
            r.append(any(son in re.findall(r"\d+", matnlar[c]) for c in top))
            tok.append(uzunlik[top].sum() * TOKEN_SOZ)
        oltin[k], raqam[k] = np.array(o), np.array(r)
        shovqin = 1 - oltin[k].mean() / k
        narx = np.mean(tok) * NARX_1K_TOKEN        # 1000 so'rov: tok * 1000 / 1000 * narx
        print(f"  {k:>2} {oltin[k].mean():>17.3f} {np.mean(satr):>12.3f} {raqam[k].mean():>12.3f} "
              f"{shovqin:>8.2f} {np.mean(tok):>13.0f} {narx:>10.2f}")
    for k in (1, 8):
        print(f"  k={k:<2}: faqat raqamni qidirish {int((raqam[k] & ~oltin[k]).sum())} ta soxta "
              f"'topildi' beradi (oltin chunk kontekstda yo'q)")
    print("  shovqin = kontekstdagi keraksiz chunklar ulushi; narx - FARAZIY birlikda")

    print("\n=== 2. Ko'proq kontekst - ko'proq chalg'ituvchi: oddiy o'quvchi ===")
    print("   k   o'quvchi aniqligi   parafraz      kod    raqam")
    aniq = {}
    for k in K:
        aniq[k] = np.array([chunklar[oquvchi(s["q"], list(t[:k]), matnlar)]["javob"]
                            == chunklar[s["gold"]]["javob"] for s, t in zip(savollar, tartiblar)])
        print(f"  {k:>2} {aniq[k].mean():>19.3f} " + " ".join(
            f"{aniq[k][tur == x].mean():>8.3f}" for x in ("parafraz", "kod", "raqam")))
    eng_k = max(K, key=lambda k: aniq[k].mean())
    for k in K:
        d = aniq[eng_k].astype(float) - aniq[k].astype(float)
        se = d.std(ddof=1) / math.sqrt(len(d))
        if d.mean() <= 2 * se:
            print(f"  eng yaxshi k = {eng_k} ({aniq[eng_k].mean():.3f}); undan sezilarli "
                  f"yomon bo'lmagan eng kichik k = {k} ({aniq[k].mean():.3f})")
            break
    m = tur == "parafraz"
    d = aniq[10][m].astype(float) - aniq[1][m].astype(float)
    se = d.std(ddof=1) / math.sqrt(m.sum())
    chalg = int((oltin[10][m] & ~aniq[10][m]).sum())
    print(f"  parafraz: k=10 - k=1 = {d.mean():+.3f} (SE {se:.3f}); k=10 da oltin kontekstda, "
          f"lekin o'quvchi chalg'idi: {chalg} savol")

    print("\n=== 3. Xatolar tahlili: oltin chunk top-3 da yo'q ===")
    xato = [(s, t) for s, t in zip(savollar, tartiblar) if s["gold"] not in t[:3]]
    print(f"  xatolar: {len(xato)} / {len(savollar)}")
    toifa = {}
    for s, t in xato:
        g, b = chunklar[s["gold"]], chunklar[int(t[0])]
        if g["mavzu"] == b["mavzu"]:
            nom = "mavzu to'g'ri, bo'lim xato"
        elif g["bolim"] == b["bolim"]:
            nom = "bo'lim to'g'ri, mavzu xato"
        else:
            nom = "ikkalasi xato"
        joy = "4-10" if int(np.where(t == s["gold"])[0][0]) < 10 else ">10"
        toifa[(s["tur"], nom, joy)] = toifa.get((s["tur"], nom, joy), 0) + 1
    for (t_, nom, joy), n in sorted(toifa.items(), key=lambda x: (-x[1], x[0])):
        print(f"  {n:>3}  [{t_}] 1-o'rinda: {nom}; oltin o'rni {joy}")
    for tanlov in ("parafraz", "raqam"):
        s, t = next((s, t) for s, t in xato if s["tur"] == tanlov)
        print(f"  namuna [{tanlov}]: {s['q']}")
        print(f"    1-o'rin: {matnlar[int(t[0])][16:95]}...")
        print(f"    oltin  : {matnlar[s['gold']][16:95]}...")
    print("  ⭐ k - sifat, shovqin va narx orasidagi murosa; uni o'lchab tanlang")


if __name__ == "__main__":
    main()

=== 1. k bo'yicha: kontekstda javob bormi va u qanchaga tushadi (RRF) ===
   k  oltin_kontekstda  javob_satri  faqat_raqam  shovqin  token/so'rov  narx/1000
   1             0.750        0.750        0.757     0.25            28       0.09
   2             0.882        0.882        0.889     0.56            56       0.17
   3             0.906        0.906        0.906     0.70            84       0.25
   5             0.948        0.948        0.951     0.81           140       0.42
   8             0.972        0.972        0.979     0.88           223       0.67
  10             1.000        1.000        1.000     0.90           280       0.84
  k=1 : faqat raqamni qidirish 2 ta soxta 'topildi' beradi (oltin chunk kontekstda yo'q)
  k=8 : faqat raqamni qidirish 2 ta soxta 'topildi' beradi (oltin chunk kontekstda yo'q)
  shovqin = kontekstdagi keraksiz chunklar ulushi; narx - FARAZIY birlikda

=== 2. Ko'proq kontekst - ko'proq chalg'ituvchi: oddiy o'quvchi ===
   k   o'quvchi aniqligi   parafraz      kod    raqam
   1               0.750    0.688    1.000    0.562
   2               0.844    0.667    1.000    0.865
   3               0.858    0.656    1.000    0.917
   5               0.882    0.656    1.000    0.990
   8               0.885    0.656    1.000    1.000
  10               0.885    0.656    1.000    1.000
  eng yaxshi k = 8 0.885-bob; undan sezilarli yomon bo'lmagan eng kichik k = 5 0.882-bob
  parafraz: k=10 - k=1 = -0.031 (SE 0.018); k=10 da oltin kontekstda, lekin o'quvchi chalg'idi: 33 savol

=== 3. Xatolar tahlili: oltin chunk top-3 da yo'q ===
  xatolar: 27 / 288
   12  [parafraz] 1-o'rinda: ikkalasi xato; oltin o'rni 4-10
    8  [raqam] 1-o'rinda: mavzu to'g'ri, bo'lim xato; oltin o'rni 4-10
    7  [parafraz] 1-o'rinda: bo'lim to'g'ri, mavzu xato; oltin o'rni 4-10
  namuna [parafraz]: Marketing bo'limida ish haqi qachon tushadi?
    1-o'rin: Marketing bo'limi xodimlari haftada 25 soat masofaviy ishlashi mumkin. Masofavi...
    oltin  : Marketing bo'limida maosh har oyning 27-kunida kartaga o'tkaziladi. Maosh kechi...
  namuna [raqam]: Qaysi bo'limda yiliga 28 kunlik ta'til beriladi?
    1-o'rin: Axborot bo'limi xodimlari uchun yillik ta'til tartibi. Har bir xodimga yiliga 1...
    oltin  : Kadrlar bo'limi xodimlari uchun yillik ta'til tartibi. Har bir xodimga yiliga 2...
  ⭐ k - sifat, shovqin va narx orasidagi murosa; uni o'lchab tanlang

orin = int((ball > ball[oltin]).sum()) + 1                          # ⚠️ tenglar oldinda
orin = int((ball >= ball[oltin]).sum())                             # ✅ eng yomon holat

print("MRR", np.mean(rr))                                           # ⚠️
for t in turlar: print(t, np.mean(rr[tur == t]))                    # ✅

tartib = np.argsort(-ball)                                          # ⚠️ 0 lar ham "reyting"da
tartib = np.argsort(-ball)[:n]; tartib = tartib[ball[tartib] > 0]   # ✅

LogisticRegression().fit(X, y); ehtimol = model.predict_proba(X)    # ⚠️ oqib ketish
for oq, ts in GroupKFold(4).split(X, y, oltin_chunk): ...           # ✅

alfa = max(alfalar, key=lambda a: mrr(test, a))                      # ⚠️
alfa = max(alfalar, key=lambda a: mrr(dev, a)); mrr(test, alfa)       # ✅

topildi = "28" in kontekst                                          # ⚠️ soxta moslik
topildi = oltin_id in top_k or javob_satri in kontekst              # ✅

se = math.sqrt(a.var() / n + b.var() / n)                          # ⚠️ savollar bir xil
d = a - b; se = d.std(ddof=1) / math.sqrt(n)                        # ✅ juftlashgan

1.  # tartib [d5, d2, d8], relevant {d2}: recall@1, recall@3, RR?
2.  # bitta relevant chunkda precision@5 va recall@5 qanday bog'langan?
3.  # nDCG qachon MRR dan ko'proq ma'lumot beradi?
4.  # nega BM25 "AK-7564" ni ajoyib topadi, LSA(12) esa yo'q?
5.  # LSA "dam olish" ni "ta'til" ga yaqin deb bilishi uchun nima kerak?
6.  # RRF formulasi?
7.  # nega RRF raqamli savollarda BM25 dan yomon bo'lishi mumkin?
8.  # reranker ning sifat chegarasi nima?
9.  # k 3 dan 10 ga oshsa, qaysi uch narsa o'zgaradi?
10. # "kontekstda '28' raqami bor" tekshiruvining xavfi?
11. # reranker ni baholashda nega GroupKFold?
12. # tenglikda oltin chunkning o'rni qanday hisoblanadi?

1.  orin = list(np.argsort(-ball)).index(oltin) + 1        # ball ko'p 0 ga teng

2.  mrr = np.mean([1 / orin(bm25, s) for s in savollar])
    print("BM25 yaxshi" if mrr > 0.7 else "yomon")

3.  model = LogisticRegression().fit(X, y)
    print(recall_at_1(model.predict_proba(X)))

4.  for k in range(1, 11):
        natija[k] = recall_k(test, k)
    k_tanlov = max(natija, key=natija.get)

5.  topildi = any(str(son) in kontekst for son in savol_raqamlari)