29.7-dars: Portfolio yaratish

KO'RIB CHIQISH ZANJIRI (umumiy manzara, har kompaniyada boshqacha)
  rezyume -> GitHub / portfolio havolasi -> 1-2 ta repo -> README ning boshi
  har bosqichda vaqt kam; keyingi bosqichga faqat qiziqish uyg'onsa o'tiladi

BIRINCHI DAQIQADA IZLANADIGAN SAVOLLAR
  1. Bu loyiha qanday SAVOLga javob beradi? (texnika emas - muammo)
  2. Natija qanday? Raqam bormi? Nima bilan taqqoslangan?
  3. Bu odam ma'lumotni o'zi topdi/tozaladimi yoki tayyor CSV oldimi?
  4. Baholash halolmi? (bazaviy, test to'plami, noaniqlik)
  5. Kod o'qiladimi? Ishga tushirsa bo'ladimi?
  6. Cheklovlarni biladimi? ("model hamma joyda ishlaydi" - xavf belgisi)

PORTFOLIO NIMANI ISBOTLAYDI
  texnik ko'nikma    - kod, modellar, baholash
  mustaqillik        - savol qo'yish, ma'lumot topish, tugatish
  muloqot            - README, grafiklar, yozuv 29.4-bob
  muhandislik        - repo tuzilishi, testlar, deploy (29.6, 27-qism)

MEZON                      NIMA KERAK                               VAZN (namuna)
1. Real savol              kim uchun, qanday qaror? ("do'kon          15
                           zaxirani qancha buyurtma qilsin")
2. Ma'lumot manbasi        o'zingiz yig'gan yoki qiziq ochiq manba;    10
                           manba, davr, litsenziya yozilgan
3. Oxiridan oxirigacha     yig'ish -> tozalash -> model -> baholash    15
                           -> natija (ideal: demo yoki xizmat)
4. Halol baholash          bazaviy model, to'g'ri bo'lish (vaqt,       20
                           guruh), noaniqlik (CI, SE), juftlashgan
                           taqqoslash (18-qism)
5. Natija va cheklovlar    raqam + ma'nosi; qayerda ishlamaydi         15
6. Qayta ishga tushirish   buyruqlar, qadalgan versiyalar, urug'lar    15
7. Birinchi ekran          README boshida xulosa va raqam              10

PORTFOLIO UCHUN ZAIF LOYIHALAR (va ularni qanday kuchaytirish)
  Titanic, Iris, MNIST          - hamma qilgan; savol yo'q
    -> o'quv mashqi sifatida qoldiring, portfolio ning markazida emas
  "20 modelni sinadim"          - savolsiz model zoo
    -> bitta savol, bazaviy va 2-3 asosli nomzod, juftlashgan taqqoslash
  faqat notebook, README siz    - o'qib bo'lmaydi
    -> 29.6 dagi tuzilish
  "Accuracy 99%"                - nomutanosib sinflarda ma'nosiz 14.9-bob
    -> to'g'ri metrika va bazaviy bilan

TAVSIYA ETILADIGAN TO'PLAM (DS generalist uchun)
  1. TABULAR + biznes savol     - klassifikatsiya/regressiya, belgilar,
                                  halol baholash (12-19-qismlar)
  2. MATN yoki RASM             - NLP (23-25) yoki CV (22); transfer learning
  3. VAQT QATORI yoki A/B       - bashorat + backtest (28.1-28.3) yoki
                                  tajriba tahlili (11-qism, 27.13)
  4. DEPLOY QILINGAN XIZMAT     - API yoki demo, monitoring g'oyasi (27-qism)
  5. (ixtiyoriy) YIG'ILGAN MA'LUMOT - scraping/API dan o'z ma'lumotingiz (7-qism)

YO'NALISHGA QARAB MOSLASH
  tahlilchi (analyst)   - SQL, A/B, EDA hisobot, dashboard ko'proq
  ML muhandis           - deploy, testlar, MLOps, samaradorlik ko'proq
  NLP/LLM               - matn loyihalari, RAG, baholash (25.9-25.10)

# Toshkent kvartira narxlari: e'lon narxi adolatlimi?

**Natija:** HistGB modeli e'lon narxini MAE 38.2 mln so'm bilan bashorat qiladi
(bazaviy - tuman medianasi - 61.5 mln; 95% CI [35.9, 40.6]). Demo: `/narx` API.
*(Barcha raqamlar - namuna.)*

![Bashorat va haqiqiy narx](reports/figures/bashorat.png)

## Savol
Xaridor e'londagi narx bozor darajasidan qanchalik farq qilishini bilmaydi.
Model "o'xshash kvartiralar qancha turadi?" degan savolga javob beradi.

## Ma'lumot
Ochiq e'lonlar sahifalaridan 2026-yil 3 oy davomida yig'ildi (sayt shartlari va
robots.txt tekshirildi); shaxsiy ma'lumot (telefon, ism) saqlanmagan.
Xom ma'lumot repo da yo'q - `src/kvartira/yigish.py` yig'ish skripti.

## Yondashuv
1. Tozalash: takrorlar, narx xatolari (so'm/dollar), ekstremal qiymatlar
2. Belgilar: tuman, maydon, qavat, qurilgan yil, matndan belgilar
3. Modellar: tuman medianasi (bazaviy) -> Ridge -> HistGB
4. Baholash: vaqt bo'yicha bo'lish (oxirgi oy - test), juftlashgan bootstrap

## Natijalar
| model         | MAE, mln so'm | 95% CI        |
|---------------|---------------|---------------|
| tuman medianasi | 61.5        | [58.8, 64.3]  |
| Ridge         | 45.0          | [42.6, 47.5]  |
| HistGB        | 38.2          | [35.9, 40.6]  |

## Cheklovlar
- E'lon narxi - sotuv narxi emas
- Faqat Toshkent; boshqa shaharlarda qayta o'qitish kerak
- Ta'mir sifati belgisi matndan olingan - shovqinli

## Ishga tushirish
    pip install -e .
    python -m kvartira.train --config configs/asos.yaml
    uvicorn kvartira.xizmat:app

## Mening hissam
Yig'ish, tozalash, modellar va API - to'liq o'zim. Baholash sxemasi 18-qism asosida.

QO'LDA KO'CHIRISH XATOLARI
  raqamlar o'rni almashadi: 0.723 -> 0.732
  eski natija qoladi: model qayta o'qitildi, README - yo'q
  yaxlitlash nomuvofiq: jadvalda 0.847, matnda 0.85, grafikda 0.8471
  nisbiy va mutlaq: "+17%" - nisbiymi yoki foiz punktmi?

YECHIM
  natija fayli -> README ni shablondan yaratish, YOKI
  README raqamlarini natija fayli bilan avtomatik solishtirish (2-misol)
  va buni CI ga qo'shish

BLOG YOZUVI TUZILISHI (800-1500 so'z)
  1. Ilgak: qiziq savol yoki kutilmagan topilma (1 abzas)
  2. Nega muhim: kim uchun, qanday qaror
  3. Ma'lumot: qayerdan, qanday muammolar bor edi
  4. Asosiy topilma(lar): 1-2 grafik, raqamlar
  5. Nima ishlamadi (bu - eng qiziq qism, 29.5 writeup)
  6. Cheklovlar va keyingi qadam
  7. Havola: repo, demo
QAYERDA: shaxsiy sayt, GitHub Pages, umumiy blog platformalari;
  o'zbek tilida yozish - mahalliy hamjamiyat uchun qo'shimcha qiymat

# app.py - streamlit demo (ishga tushirish: streamlit run app.py)
import joblib
import pandas as pd
import streamlit as st

model = joblib.load("models/histgb.joblib")
st.title("Kvartira narxi bahosi")
tuman = st.selectbox("Tuman", ["Chilonzor", "Yunusobod", "Mirzo Ulug'bek"])
maydon = st.number_input("Maydon, m^2", 20.0, 300.0, 60.0)
qavat = st.slider("Qavat", 1, 25, 4)
if st.button("Baholash"):
    x = pd.DataFrame([{"tuman": tuman, "maydon": maydon, "qavat": qavat}])
    st.metric("Taxminiy narx, mln so'm", f"{model.predict(x)[0]:.0f}")
    st.caption("Model cheklovlari: faqat Toshkent, e'lon narxlari asosida")

DEMO QOIDALARI
  model fayli repo da emas 29.6-bob - ishga tushishda yuklanadi
  kirishni tekshirish 27.8-bob: noto'g'ri qiymat - tushunarli xabar
  cheklovlarni demoning o'zida yozing
  bepul xosting "uxlab qolishi" mumkin - README da skrinshot/GIF ham bo'lsin

MANBA TURLARI
  davlat ochiq ma'lumotlar portallari va statistika nashrlari - aholi,
    narxlar indekslari, hududiy ko'rsatkichlar (formati va yangilanishini tekshiring)
  e'lon saytlari (ko'chmas mulk, avtomobil) - faqat ruxsat etilgan doirada,
    shaxsiy ma'lumotsiz (7-qism, 29.11)
  o'zbek tilidagi ochiq matnlar - yangiliklar, sharhlar (litsenziya!)
  o'zingiz yig'gan ma'lumot - so'rovnoma, sensor (havo sifati, harorat),
    shaxsiy xarajatlar (anonimlashtirilgan)

G'OYALAR
  hududlar bo'yicha narx dinamikasi va bashorati
  o'zbekcha matn: yangilik toifasi, sharh tonalligi, lotin-kirill transliteratsiya
    sifatini baholash
  shahar havo sifati: vaqt qatori bashorati va anomaliyalar
  jamoat transporti yoki yo'l harakati: vaqt bo'yicha naqshlar
  qishloq xo'jaligi: hosildorlik va ob-havo bog'liqligi (sababiylik ehtiyotkorligi, 28.11)

GitHub profili: profil README (qisqa "men kimman" + 3-4 asosiy loyiha havolasi),
  "pinned" repolar - eng yaxshi 4-6 ta
shaxsiy sayt (ixtiyoriy): loyiha sahifalari + blog
Kaggle: notebooklar va musobaqa writeup lari 29.5-bob
rezyume: har loyiha - bir qator, natija raqami bilan, havola (29.8)

import json
import re

# README raqamini natija fayli bilan solishtirish (yaxlitlashni hisobga olib)
natija = json.load(open("reports/metrics.json", encoding="utf-8"))
m = re.search(r"Test AUC (\d+[.,]\d+)", readme)
qiymat = float(m.group(1).replace(",", "."))
xona = len(m.group(1).replace(",", ".").split(".")[1])
mos = abs(qiymat - round(natija["auc"], xona)) < 1e-9

# ko'nikmalar qamrovi (loyiha x ko'nikma 0/1 matritsa)
bor = M.max(axis=0)
vaznli_qamrov = (talab * bor).sum() / talab.sum()

# README ning birinchi N qatorida natija bormi
bosh = "\n".join(readme.splitlines()[:10])
natija_tepada = re.search(r"(AUC|MAE|F1|RMSE)\s*\d", bosh) is not None

3-5 ta tugallangan loyiha > 12 ta yarim tayyor notebook
har loyiha: real savol, manba, bazaviy, noaniqlik, cheklovlar, buyruqlar
README boshida: nima + natija raqami + bazaviy
xilma-xillik: tabular + matn/rasm + vaqt qatori/A-B + deploy
raqamlar - natija faylidan; mahalliy ma'lumot - ruxsat va etika bilan

"""Portfolio ruberikasi: loyiha README larini mezonlar bo'yicha baholash."""

import re

import numpy as np

MEZONLAR = {  # nom: (vazn, tekshiruvchi regexlar - README matnida)
    "real savol": (15, [r"(?im)^#+\s*(muammo|savol)", r"(?i)(bo'lim|bank|do'kon|"
                        r"kompaniya|shifoxona|hokimiyat|foydalanuvchi)\w*\s"]),
    "ma'lumot manbasi": (10, [r"(?im)^#+\s*ma'lumot", r"(?i)(manba|yig'ildi|litsenziya)"]),
    "oxiridan oxirigacha": (15, [r"(?i)(tozalash|quvur)", r"(?i)(api|fastapi|streamlit|"
                                 r"dashboard|deploy|xizmat)"]),
    "halol baholash": (20, [r"(?i)bazaviy", r"(?i)(95% ?ci|ishonch oralig'i|se \d|"
                            r"juftlashgan|backtest)"]),
    "natija va cheklovlar": (15, [r"(?im)^#+\s*natija", r"(?im)^#+\s*cheklov"]),
    "qayta ishga tushirish": (15, [r"(?m)^\s{4}(python|make|pip|docker)\s",
                                   r"(?i)(urug'|seed|versiya|lock)"]),
    "birinchi ekran": (10, [r"\d+[.,]\d+|\d+%"]),   # birinchi 5 qatorda raqamli natija
}

LOYIHALAR = {
    "Titanic": """# Titanic
Kaggle dagi mashhur ma'lumot bilan ishladim. Ko'p narsa o'rgandim.
Random forest ishlatdim.
## Model
Accuracy 0.82 chiqdi.
## Ma'lumot
Manba: Kaggle o'quv musobaqasi.
""",
    "Kvartira narxi": """# Toshkent kvartira narxlari: narx bashorati va baholash xizmati
MAE 38.2 mln so'm (bazaviy - tuman medianasi - 61.5 mln); 95% CI [35.9, 40.6].
## Muammo
Xaridor e'londagi narx bozor narxidan yuqorimi - buni foydalanuvchi bilmaydi.
## Ma'lumot
E'lonlar sayti ochiq sahifalaridan yig'ildi (robots.txt va shartlar tekshirildi),
tozalash quvuri src/ da; manba havolasi va litsenziya izohi README oxirida.
## Natija
Juftlashgan bootstrap: HistGB bazaviydan sezilarli yaxshi.
## Foydalanish
    pip install -e .
    python -m kvartira.train --config configs/asos.yaml
FastAPI xizmati: /narx endpointi; urug' va versiyalar qadalgan.
## Cheklovlar
Faqat Toshkent; e'lon narxi - sotuv narxi emas.
""",
    "Sharh tonalligi": """# O'zbekcha mahsulot sharhlari tonalligi
Makro-F1 0.78 (bazaviy TF-IDF + logreg 0.71).
## Muammo
Do'kon sharhlarni qo'lda o'qiy olmaydi.
## Ma'lumot
3 000 ta sharh qo'lda belgilandi; manba - ochiq sharhlar.
## Natija
Xatolar tahlili: kinoya va aralash til.
## Cheklovlar
Kichik test to'plami - 95% CI keng.
""",
    "Elektr iste'moli": """# Elektr iste'moli bashorati
Bu loyihada vaqt qatorlari bilan ishladim va juda ko'p model sinab ko'rdim,
ARIMA, ETS, gradient boosting va LSTM. Natijalar pastda.
Loyiha menga juda yoqdi.
Kodni ishga tushirish uchun notebookni oching.
## Natija
Rolling backtest da MAPE 6.1% (bazaviy mavsumiy naiv 8.4%).
""",
    "MNIST": """# MNIST 99.3%
CNN bilan 99.3% aniqlik.
""",
}


def baholash(matn):
    ball = {}
    for nom, (_, regexlar) in MEZONLAR.items():
        if nom == "birinchi ekran":
            bosh = "\n".join(matn.splitlines()[:5])
            ball[nom] = 1.0 if re.search(regexlar[0], bosh) else 0.0
        else:
            ball[nom] = sum(bool(re.search(r, matn)) for r in regexlar) / len(regexlar)
    return ball


def jami(ball, vazn):
    return sum(vazn[k] * ball[k] for k in vazn)


def main() -> None:
    vazn = {k: v[0] for k, v in MEZONLAR.items()}
    ballar = {n: baholash(m) for n, m in LOYIHALAR.items()}

    print("=== 1. Ruberika: mezon ballari (0-1) va jami (100 dan) ===")
    qisqa = ["savol", "manba", "e2e", "baho", "natija", "qayta", "ekran"]
    print(f"  {'loyiha':<18}" + "".join(f"{q:>7}" for q in qisqa) + f"{'JAMI':>7}")
    for n, b in ballar.items():
        print(f"  {n:<18}" + "".join(f"{b[k]:>7.1f}" for k in MEZONLAR)
              + f"{jami(b, vazn):>7.1f}")

    print("\n=== 2. Eng katta yo'qotishlar (vazn x yetishmagan ulush) ===")
    for n, b in ballar.items():
        yoq = sorted(((vazn[k] * (1 - b[k]), k) for k in MEZONLAR), reverse=True)[:2]
        yoq = [f"{k} (-{v:.1f})" for v, k in yoq if v > 0]
        print(f"  {n:<18} {', '.join(yoq) if yoq else 'yo_q'}")

    print("\n=== 3. Vaznlarga sezgirlik: 2000 ta tasodifiy vazn (Dirichlet) ===")
    rng = np.random.default_rng(0)
    nomlar = list(LOYIHALAR)
    B = np.array([[ballar[n][k] for k in MEZONLAR] for n in nomlar])
    alfa = np.array([vazn[k] for k in MEZONLAR], dtype=float) / 5
    W = rng.dirichlet(alfa, size=2000) * 100
    J = W @ B.T                                    # (2000, loyihalar)
    orin = (-J).argsort(axis=1).argsort(axis=1) + 1
    asosiy = np.array([jami(ballar[n], vazn) for n in nomlar])
    asosiy_orin = (-asosiy).argsort().argsort() + 1
    print(f"  {'loyiha':<18} {'asosiy o_rin':>13} {'1-o_rin ulushi':>15} "
          f"{'o_rin 90% oralig_i':>19}")
    for i, n in enumerate(nomlar):
        lo, hi = np.percentile(orin[:, i], [5, 95])
        print(f"  {n:<18} {asosiy_orin[i]:>13} {np.mean(orin[:, i] == 1):>15.3f} "
              f"{f'{lo:.0f}-{hi:.0f}':>19}")
    tartib_saqlandi = np.mean(np.all(orin == asosiy_orin, axis=1))
    print(f"  to'liq tartib saqlangan ulush: {tartib_saqlandi:.3f}")
    eng = nomlar[int(np.argmax(asosiy))]
    if np.mean(orin[:, nomlar.index(eng)] == 1) > 0.9:
        print(f"  xulosa: '{eng}' vaznlar qanday bo'lmasin deyarli har doim birinchi")


if __name__ == "__main__":
    main()

=== 1. Ruberika: mezon ballari (0-1) va jami (100 dan) ===
  loyiha              savol  manba    e2e   baho natija  qayta  ekran   JAMI
  Titanic               0.0    1.0    0.0    0.0    0.0    0.0    1.0   20.0
  Kvartira narxi        1.0    1.0    1.0    1.0    1.0    1.0    1.0  100.0
  Sharh tonalligi       1.0    1.0    0.0    1.0    1.0    0.0    1.0   70.0
  Elektr iste'moli      0.0    0.0    0.0    1.0    0.5    0.0    0.0   27.5
  MNIST                 0.0    0.0    0.0    0.0    0.0    0.0    1.0   10.0

=== 2. Eng katta yo'qotishlar (vazn x yetishmagan ulush) ===
  Titanic            halol baholash (-20.0), real savol (-15.0)
  Kvartira narxi     yo_q
  Sharh tonalligi    qayta ishga tushirish (-15.0), oxiridan oxirigacha (-15.0)
  Elektr iste'moli   real savol (-15.0), qayta ishga tushirish (-15.0)
  MNIST              halol baholash (-20.0), real savol (-15.0)

=== 3. Vaznlarga sezgirlik: 2000 ta tasodifiy vazn (Dirichlet) ===
  loyiha              asosiy o_rin  1-o_rin ulushi  o_rin 90% oralig_i
  Titanic                        4           0.000                 3-4
  Kvartira narxi                 1           1.000                 1-1
  Sharh tonalligi                2           0.000                 2-2
  Elektr iste'moli               3           0.000                 3-5
  MNIST                          5           0.000                 4-5
  to'liq tartib saqlangan ulush: 0.690
  xulosa: 'Kvartira narxi' vaznlar qanday bo'lmasin deyarli har doim birinchi

"""README dagi raqamlarni natija fayli bilan avtomatik solishtirish."""

import json
import re
import tempfile
from pathlib import Path

README = """# Mijoz ketishini bashorat qilish
Test AUC 0.847 (bazaviy logistik regressiya 0.732), ya'ni +17% nisbiy yaxshilanish.
Top-10% xavfli mijozlar ketuvchilarning 34% ini qamraydi.

## Natija
| model    | AUC   | F1   |
|----------|-------|------|
| bazaviy  | 0.723 | 0.58 |
| HistGB   | 0.847 | 0.71 |

Test to'plami: 12 345 mijoz, ketish ulushi 18,2%.
"""

# README qaysi raqamni qayerdan olishini aytuvchi xarita: (nom, regex, kalit)
QOIDALAR = [
    ("xulosa: AUC", r"Test AUC (\d+[.,]\d+)", "auc"),
    ("xulosa: bazaviy AUC", r"bazaviy logistik regressiya (\d+[.,]\d+)", "bazaviy_auc"),
    ("xulosa: nisbiy o'sish %", r"\+(\d+)% nisbiy", "nisbiy_osish_foiz"),
    ("xulosa: top-10% qamrov %", r"ketuvchilarning (\d+)%", "top10_qamrov_foiz"),
    ("jadval: bazaviy AUC", r"\| bazaviy\s+\| (\d+[.,]\d+)", "bazaviy_auc"),
    ("jadval: bazaviy F1", r"\| bazaviy\s+\| [\d.]+\s+\| (\d+[.,]\d+)", "bazaviy_f1"),
    ("jadval: HistGB AUC", r"\| HistGB\s+\| (\d+[.,]\d+)", "auc"),
    ("jadval: HistGB F1", r"\| HistGB\s+\| [\d.]+\s+\| (\d+[.,]\d+)", "f1"),
    ("test hajmi", r"Test to'plami: ([\d\s]+) mijoz", "n_test"),
    ("ketish ulushi %", r"ketish ulushi (\d+[.,]\d+)%", "ketish_foiz"),
]


def son(matn):
    """'12 345' -> 12345, '18,2' -> 18.2; o'nlik xonalar sonini ham qaytaradi."""
    s = matn.replace(" ", "").replace(" ", "").replace(",", ".")
    return float(s), (len(s.split(".")[1]) if "." in s else 0)


def natijalar_yarat(auc, bazaviy_auc, f1, bazaviy_f1, top10, n_test, ketish):
    return {"auc": auc, "bazaviy_auc": bazaviy_auc, "f1": f1, "bazaviy_f1": bazaviy_f1,
            "nisbiy_osish_foiz": 100 * (auc - bazaviy_auc) / bazaviy_auc,
            "top10_qamrov_foiz": 100 * top10, "n_test": n_test, "ketish_foiz": 100 * ketish}


def tekshir(readme, natija):
    """Har raqam: README dagi yaxlitlangan qiymat natijaning yaxlitlanganiga tengmi?"""
    xatolar, qatorlar = 0, []
    for nom, regex, kalit in QOIDALAR:
        m = re.search(regex, readme)
        if not m:
            qatorlar.append((nom, "topilmadi", "", "YO'Q"))
            xatolar += 1
            continue
        qiymat, xona = son(m.group(1))
        haqiqiy = natija[kalit]
        ok = abs(qiymat - round(haqiqiy, xona)) < 1e-9
        xatolar += not ok
        qatorlar.append((nom, f"{qiymat:g}", f"{haqiqiy:.4f}", "OK" if ok else "FARQ"))
    return xatolar, qatorlar


def chop(qatorlar):
    print(f"  {'raqam':<26} {'README':>8} {'natija':>11}  holat")
    for nom, r, h, holat in qatorlar:
        print(f"  {nom:<26} {r:>8} {h:>11}  {holat}")


def main() -> None:
    with tempfile.TemporaryDirectory() as tmp:
        tmp = Path(tmp)
        v1 = natijalar_yarat(0.8471, 0.7234, 0.7093, 0.5812, 0.3408, 12345, 0.1821)
        (tmp / "metrics.json").write_text(json.dumps(v1, indent=1, sort_keys=True),
                                          encoding="utf-8")
        (tmp / "README.md").write_text(README, encoding="utf-8")

        print("=== 1. README va metrics.json (1-versiya) ===")
        natija = json.loads((tmp / "metrics.json").read_text(encoding="utf-8"))
        xatolar, qatorlar = tekshir((tmp / "README.md").read_text(encoding="utf-8"), natija)
        chop(qatorlar)
        print(f"  mos kelmagan raqamlar: {xatolar}")

        print("\n=== 2. README ichidagi o'zaro mosligi ===")
        r = (tmp / "README.md").read_text(encoding="utf-8")
        a = son(re.search(r"Test AUC (\d+[.,]\d+)", r).group(1))[0]
        b1 = son(re.search(r"regressiya (\d+[.,]\d+)", r).group(1))[0]
        b2 = son(re.search(r"\| bazaviy\s+\| (\d+[.,]\d+)", r).group(1))[0]
        print(f"  bazaviy AUC: xulosada {b1}, jadvalda {b2} -> bir xil: {b1 == b2}")
        for b in [b1, b2]:
            print(f"  +{100 * (a - b) / b:.1f}% (bazaviy {b} bilan) - README da '+17%'")

        print("\n=== 3. Tuzatilgan README ===")
        r2 = r.replace("regressiya 0.732", "regressiya 0.723")
        xatolar, _ = tekshir(r2, natija)
        print(f"  mos kelmagan raqamlar: {xatolar}")

        print("\n=== 4. Model qayta o'qitildi, README yangilanmadi ===")
        v2 = natijalar_yarat(0.8512, 0.7234, 0.7160, 0.5812, 0.3551, 13020, 0.1797)
        (tmp / "metrics.json").write_text(json.dumps(v2, indent=1, sort_keys=True),
                                          encoding="utf-8")
        natija = json.loads((tmp / "metrics.json").read_text(encoding="utf-8"))
        xatolar, qatorlar = tekshir(r2, natija)
        chop([q for q in qatorlar if q[3] != "OK"])
        print(f"  mos kelmagan raqamlar: {xatolar} -> CI da bu tekshiruv yiqilsa, "
              f"eskirgan README ochiq sahifaga chiqmaydi")


if __name__ == "__main__":
    main()

=== 1. README va metrics.json (1-versiya) ===
  raqam                        README      natija  holat
  xulosa: AUC                   0.847      0.8471  OK
  xulosa: bazaviy AUC           0.732      0.7234  FARQ
  xulosa: nisbiy o'sish %          17     17.0998  OK
  xulosa: top-10% qamrov %         34     34.0800  OK
  jadval: bazaviy AUC           0.723      0.7234  OK
  jadval: bazaviy F1             0.58      0.5812  OK
  jadval: HistGB AUC            0.847      0.8471  OK
  jadval: HistGB F1              0.71      0.7093  OK
  test hajmi                    12345  12345.0000  OK
  ketish ulushi %                18.2     18.2100  OK
  mos kelmagan raqamlar: 1

=== 2. README ichidagi o'zaro mosligi ===
  bazaviy AUC: xulosada 0.732, jadvalda 0.723 -> bir xil: False
  +15.7% (bazaviy 0.732 bilan) - README da '+17%'
  +17.2% (bazaviy 0.723 bilan) - README da '+17%'

=== 3. Tuzatilgan README ===
  mos kelmagan raqamlar: 0

=== 4. Model qayta o'qitildi, README yangilanmadi ===
  raqam                        README      natija  holat
  xulosa: AUC                   0.847      0.8512  FARQ
  xulosa: nisbiy o'sish %          17     17.6666  FARQ
  xulosa: top-10% qamrov %         34     35.5100  FARQ
  jadval: HistGB AUC            0.847      0.8512  FARQ
  jadval: HistGB F1              0.71      0.7160  FARQ
  test hajmi                    12345  13020.0000  FARQ
  ketish ulushi %                18.2     17.9700  FARQ
  mos kelmagan raqamlar: 7 -> CI da bu tekshiruv yiqilsa, eskirgan README ochiq sahifaga chiqmaydi

"""Ko'nikmalar matritsasi: portfolio qamrovi, takrorlanish va keyingi loyihani tanlash."""

from itertools import combinations

import numpy as np

KONIKMALAR = ["SQL", "EDA", "statistika/A-B", "tabular ML", "belgilar", "baholash",
              "NLP", "kompyuter ko'rish", "vaqt qatori", "chuqur o'rganish",
              "LLM/RAG", "deploy/API", "MLOps", "ma'lumot yig'ish", "muloqot"]

PORTFOLIO = {   # nomzodning hozirgi loyihalari (namuna)
    "Titanic": ["EDA", "tabular ML"],
    "Uy narxi (Kaggle)": ["EDA", "tabular ML", "belgilar"],
    "Kredit riski": ["EDA", "tabular ML", "belgilar", "baholash"],
    "Mijoz ketishi": ["SQL", "EDA", "tabular ML", "belgilar", "baholash", "muloqot"],
}

KURS_LOYIHALARI = {   # kurs amaliyot darslari asosidagi loyiha g'oyalari
    "8.10 EDA hisoboti": ["EDA", "muloqot"],
    "7.12 ma'lumot yig'ish": ["ma'lumot yig'ish", "SQL"],
    "11.10 A/B test": ["statistika/A-B", "muloqot"],
    "22.14 nuqson aniqlash": ["kompyuter ko'rish", "chuqur o'rganish", "baholash"],
    "23.14 murojaatlar toifasi": ["NLP", "baholash"],
    "24.12 sharh tonalligi": ["NLP", "chuqur o'rganish", "baholash"],
    "25.14 RAG yordamchi": ["LLM/RAG", "NLP", "baholash"],
    "27.14 ketish xizmati": ["tabular ML", "deploy/API", "MLOps", "baholash"],
    "28.12 talab bashorati": ["vaqt qatori", "baholash", "MLOps", "muloqot"],
}

# vakansiya matnlarida ko'nikma talab qilinish ulushi - FARAZIY raqamlar,
# o'z bozoringiz uchun vakansiyalarni o'zingiz sanang (29.8)
TALAB = {"SQL": 0.8, "EDA": 0.7, "statistika/A-B": 0.5, "tabular ML": 0.7,
         "belgilar": 0.4, "baholash": 0.5, "NLP": 0.3, "kompyuter ko'rish": 0.2,
         "vaqt qatori": 0.3, "chuqur o'rganish": 0.3, "LLM/RAG": 0.3,
         "deploy/API": 0.4, "MLOps": 0.3, "ma'lumot yig'ish": 0.3, "muloqot": 0.6}


def matritsa(loyihalar):
    M = np.zeros((len(loyihalar), len(KONIKMALAR)), dtype=int)
    for i, k in enumerate(loyihalar.values()):
        for s in k:
            M[i, KONIKMALAR.index(s)] = 1
    return M


def qamrov(M):
    w = np.array([TALAB[k] for k in KONIKMALAR])
    bor = M.max(axis=0) if len(M) else np.zeros(len(KONIKMALAR), dtype=int)
    return int(bor.sum()), float((w * bor).sum() / w.sum())


def main() -> None:
    M = matritsa(PORTFOLIO)
    nomlar = list(PORTFOLIO)

    print("=== 1. Hozirgi portfolio: ko'nikmalar matritsasi ===")
    for i, n in enumerate(nomlar):
        print(f"  {n:<20} " + "".join("#" if v else "-" for v in M[i]))
    soni, vaznli = qamrov(M)
    print(f"  qamrov: {soni}/{len(KONIKMALAR)} ko'nikma; talab bilan vaznlangan: {vaznli:.2f}")
    yoq = [k for j, k in enumerate(KONIKMALAR) if M[:, j].max() == 0]
    print(f"  yetishmaydi: {', '.join(yoq)}")

    print("\n=== 2. Takrorlanish: loyihalar orasidagi Jaccard o'xshashligi ===")
    juftlar = []
    for i in range(len(nomlar)):
        for j in range(i + 1, len(nomlar)):
            a, b = M[i].astype(bool), M[j].astype(bool)
            juftlar.append(((a & b).sum() / (a | b).sum(), nomlar[i], nomlar[j]))
    for s, a, b in sorted(juftlar, reverse=True)[:3]:
        print(f"  {a:<18} ~ {b:<20} {s:.2f}")
    qoldiq = {}
    for i, n in enumerate(nomlar):
        boshqalar = np.delete(M, i, axis=0)
        qoldiq[n] = qamrov(M)[1] - qamrov(boshqalar)[1]
    print("  loyihani olib tashlasak vaznli qamrov kamayishi:")
    for n in nomlar:
        print(f"    {n:<20} {abs(qoldiq[n]):.3f}")

    print("\n=== 3. Ochko'z tanlov: kurs loyihalaridan 3 ta qo'shish ===")
    asosiy = [n for n in nomlar if qoldiq[n] > 0]
    tanlangan = {n: PORTFOLIO[n] for n in asosiy}
    print(f"  qoldirildi: {', '.join(asosiy)} (qamrovga hissasi yo'q loyihalar olib tashlandi)")
    print(f"  boshlang'ich vaznli qamrov: {qamrov(matritsa(tanlangan))[1]:.2f}")
    for qadam in range(3):
        eng, eng_q = None, qamrov(matritsa(tanlangan))[1]
        for n, k in KURS_LOYIHALARI.items():
            if n in tanlangan:
                continue
            q = qamrov(matritsa({**tanlangan, n: k}))[1]
            if q > eng_q + 1e-12:
                eng, eng_q = n, q
        if eng is None:
            break
        tanlangan[eng] = KURS_LOYIHALARI[eng]
        print(f"  {qadam + 1}-qadam: + {eng:<26} vaznli qamrov {eng_q:.2f}")
    soni, vaznli = qamrov(matritsa(tanlangan))
    print(f"  yakuniy: {len(tanlangan)} loyiha, {soni}/{len(KONIKMALAR)} ko'nikma, "
          f"vaznli {vaznli:.2f}")
    yoq = [k for j, k in enumerate(KONIKMALAR) if matritsa(tanlangan)[:, j].max() == 0]
    print(f"  hali yetishmaydi: {', '.join(yoq) if yoq else 'yo_q'}")

    print("\n=== 4. Barcha 3 talik kombinatsiyalar bilan solishtirish ===")
    kurs = list(KURS_LOYIHALARI)
    boshl = {n: PORTFOLIO[n] for n in asosiy}
    hamma = np.array([qamrov(matritsa({**boshl, **{kurs[i]: KURS_LOYIHALARI[kurs[i]]
                                                  for i in c}}))[1]
                      for c in combinations(range(len(kurs)), 3)])
    print(f"  kombinatsiyalar: {len(hamma)}; o'rtacha {hamma.mean():.3f}, "
          f"maks {hamma.max():.3f}")
    print(f"  ochko'z tanlov ({vaznli:.3f}) maksimumga teng: "
          f"{abs(vaznli - hamma.max()) < 1e-12}; undan yaxshi kombinatsiyalar: "
          f"{int(np.sum(hamma > vaznli + 1e-12))}")


if __name__ == "__main__":
    main()

=== 1. Hozirgi portfolio: ko'nikmalar matritsasi ===
  Titanic              -#-#-----------
  Uy narxi (Kaggle)    -#-##----------
  Kredit riski         -#-###---------
  Mijoz ketishi        ##-###--------#
  qamrov: 6/15 ko'nikma; talab bilan vaznlangan: 0.56
  yetishmaydi: statistika/A-B, NLP, kompyuter ko'rish, vaqt qatori, chuqur o'rganish, LLM/RAG, deploy/API, MLOps, ma'lumot yig'ish

=== 2. Takrorlanish: loyihalar orasidagi Jaccard o'xshashligi ===
  Uy narxi (Kaggle)  ~ Kredit riski         0.75
  Titanic            ~ Uy narxi (Kaggle)    0.67
  Kredit riski       ~ Mijoz ketishi        0.67
  loyihani olib tashlasak vaznli qamrov kamayishi:
    Titanic              0.000
    Uy narxi (Kaggle)    0.000
    Kredit riski         0.000
    Mijoz ketishi        0.212

=== 3. Ochko'z tanlov: kurs loyihalaridan 3 ta qo'shish ===
  qoldirildi: Mijoz ketishi (qamrovga hissasi yo'q loyihalar olib tashlandi)
  boshlang'ich vaznli qamrov: 0.56
  1-qadam: + 27.14 ketish xizmati       vaznli qamrov 0.67
  2-qadam: + 24.12 sharh tonalligi      vaznli qamrov 0.76
  3-qadam: + 11.10 A/B test             vaznli qamrov 0.83
  yakuniy: 4 loyiha, 11/15 ko'nikma, vaznli 0.83
  hali yetishmaydi: kompyuter ko'rish, vaqt qatori, LLM/RAG, ma'lumot yig'ish

=== 4. Barcha 3 talik kombinatsiyalar bilan solishtirish ===
  kombinatsiyalar: 84; o'rtacha 0.749, maks 0.833
  ochko'z tanlov 0.833-bob maksimumga teng: True; undan yaxshi kombinatsiyalar: 0

"""30 soniyalik ko'rib chiqish: README ning boshida asosiy ma'lumot bormi?"""

import re

import numpy as np

KIRISH = ("Assalomu alaykum! Bu loyihani kursni o'rganish davomida qildim. "
          "Avval pandas bilan ishlashni o'rgandim, keyin grafiklar chizdim, "
          "keyin esa bir nechta modelni sinab ko'rdim. Bu jarayon juda qiziqarli "
          "bo'ldi va men ko'p narsani o'rgandim. ")

READMELAR = {
    "hikoya": "\n".join(
        ["# Mening loyiham"] + [KIRISH] * 6 +
        ["## O'rnatish", "    pip install -r requirements.txt",
         "    python train.py"] +
        ["Keyin notebookni ochib, kataklarni ketma-ket ishga tushiring. " * 3] * 4 +
        ["## Natija", "HistGB modeli test AUC 0.81 berdi, bazaviy model esa 0.72.",
         "![ROC egri chizig'i](reports/figures/roc.png)",
         "Loyiha telekom mijozlarining ketishini bashorat qiladi."]),
    "o_rta": "\n".join(
        ["# Telekom mijozlari ketishini bashorat qilish",
         "## Muammo"] + ["Telekom kompaniyasi uchun mijozni saqlash yangi mijoz jalb "
                         "qilishdan arzonroq, shuning uchun ketishni oldindan bilish muhim. "
                         * 2] * 4 +
        ["## Natija", "Test AUC 0.81 (bazaviy 0.72).",
         "![ROC egri chizig'i](reports/figures/roc.png)",
         "## O'rnatish", "    pip install -e .", "    python -m churn.train"]),
    "piramida": "\n".join(
        ["# Telekom mijozlari ketishini bashorat qilish",
         "Test AUC 0.81 (bazaviy 0.72); top-10% xavfli mijozlar ketuvchilarning 34% i.",
         "![ROC egri chizig'i](reports/figures/roc.png)",
         "    pip install -e . && python -m churn.train",
         "## Muammo"] + ["Telekom kompaniyasi uchun mijozni saqlash yangi mijoz jalb "
                         "qilishdan arzonroq. " * 2] * 4 +
        ["## Ma'lumot", "Sintetik, 20 000 mijoz."]),
}

ELEMENTLAR = {
    "nima": r"(?i)ketish\w* bashorat",
    "natija": r"(?i)AUC \d\.\d+",
    "bazaviy": r"(?i)bazaviy\w*( model esa)? \d\.\d+",
    "rasm": r"!\[",
    "buyruq": r"(?m)^\s{4}(pip|python)",
}


def joylashuv(matn):
    """Har element birinchi uchragan joy: undan oldingi so'zlar soni."""
    natija, sozlar = {}, 0
    for qator in matn.splitlines():
        for nom, r in ELEMENTLAR.items():
            m = re.search(r, qator)
            if nom not in natija and m:
                natija[nom] = sozlar + len(qator[: m.start()].split())
        sozlar += len(qator.split())
    return natija, sozlar


def main() -> None:
    rng = np.random.default_rng(0)
    n = 5000
    # FARAZIY ko'rib chiquvchi modeli: tez o'qish 3-6 so'z/s, e'tibor vaqti
    # log-normal (mediana 30 s) - real qiymatlar odamga va vaziyatga bog'liq
    tezlik = rng.uniform(3, 6, n)
    vaqt = rng.lognormal(np.log(30), 0.5, n)
    oqilgan = tezlik * vaqt

    print("=== 1. Elementlar README da qayerda? (undan oldingi so'zlar soni) ===")
    joy = {}
    print(f"  {'README':<10} {'jami':>6} " + "".join(f"{e:>9}" for e in ELEMENTLAR))
    for nom, matn in READMELAR.items():
        joy[nom], jami = joylashuv(matn)
        print(f"  {nom:<10} {jami:>6} " + "".join(
            f"{joy[nom].get(e, -1):>9}" for e in ELEMENTLAR))
    for nom, matn in READMELAR.items():
        bosh = "\n".join(matn.splitlines()[:10])
        print(f"  {nom:<10} birinchi 10 qatorda natija raqami: "
              f"{bool(re.search(ELEMENTLAR['natija'], bosh))}")

    print(f"\n=== 2. {n} ta faraziy ko'rib chiquvchi: element ko'rilish ehtimoli ===")
    print(f"  o'qilgan so'zlar: mediana {np.median(oqilgan):.0f}, "
          f"10% {np.percentile(oqilgan, 10):.0f}, 90% {np.percentile(oqilgan, 90):.0f}")
    korildi = {}
    print(f"  {'README':<10} " + "".join(f"{e:>9}" for e in ELEMENTLAR)
          + f"{'o_rtacha soni':>15}")
    for nom in READMELAR:
        k = np.column_stack([oqilgan >= joy[nom].get(e, np.inf) for e in ELEMENTLAR])
        korildi[nom] = k
        print(f"  {nom:<10} " + "".join(f"{v:>9.3f}" for v in k.mean(axis=0))
              + f"{k.sum(axis=1).mean():>15.2f}")

    print("\n=== 3. Juftlashgan: 'natija' ko'rildi (bir xil ko'rib chiquvchilar) ===")
    j = list(ELEMENTLAR).index("natija")
    for a, b in [("piramida", "hikoya"), ("piramida", "o_rta")]:
        d = korildi[a][:, j].astype(float) - korildi[b][:, j]
        se = d.std(ddof=1) / np.sqrt(n)
        print(f"  {a} - {b}: {d.mean():+.3f} (SE {se:.3f}) sezilarli: {abs(d.mean()) > 2 * se}")

    print("\n=== 4. Sezgirlik: e'tibor vaqti medianasi o'zgarsa ===")
    print(f"  {'mediana':>8} " + "".join(f"{nom:>10}" for nom in READMELAR))
    for med in [15, 30, 60]:
        oq = tezlik * rng.lognormal(np.log(med), 0.5, n)
        print(f"  {med:>7}s " + "".join(
            f"{np.mean(oq >= joy[nom]['natija']):>10.3f}" for nom in READMELAR))
    print("  (qiymatlar - README boshidan natija raqamigacha o'qib yetish ehtimoli)")


if __name__ == "__main__":
    main()

=== 1. Elementlar README da qayerda? (undan oldingi so'zlar soni) ===
  README       jami      nima   natija  bazaviy     rasm   buyruq
  hikoya        314       311      298      301      305      203
  o_rta         155         3      139      142      143      148
  piramida      116         3        7       10       17       20
  hikoya     birinchi 10 qatorda natija raqami: False
  o_rta      birinchi 10 qatorda natija raqami: True
  piramida   birinchi 10 qatorda natija raqami: True

=== 2. 5000 ta faraziy ko'rib chiquvchi: element ko'rilish ehtimoli ===
  o'qilgan so'zlar: mediana 135, 10% 67, 90% 266
  README          nima   natija  bazaviy     rasm   buyruq  o_rtacha soni
  hikoya         0.052    0.062    0.059    0.055    0.221           0.45
  o_rta          1.000    0.475    0.463    0.458    0.434           2.83
  piramida       1.000    1.000    1.000    1.000    1.000           5.00

=== 3. Juftlashgan: 'natija' ko'rildi (bir xil ko'rib chiquvchilar) ===
  piramida - hikoya: +0.938 (SE 0.003) sezilarli: True
  piramida - o_rta: +0.525 (SE 0.007) sezilarli: True

=== 4. Sezgirlik: e'tibor vaqti medianasi o'zgarsa ===
   mediana     hikoya     o_rta  piramida
       15s      0.002     0.084     1.000
       30s      0.066     0.459     1.000
       60s      0.414     0.886     1.000
  (qiymatlar - README boshidan natija raqamigacha o'qib yetish ehtimoli)

# README: 6 abzas "qanday o'rgandim" -> o'rnatish -> ... -> natija        # ⚠️
# README: sarlavha -> natija + bazaviy (1-2 qator) -> rasm -> buyruq     # ✅

"Model AUC 0.81"                                                        # ⚠️
"AUC 0.81 (bazaviy logreg 0.72; juftlashgan farq +0.09, SE 0.01)"       # ✅

readme = readme.replace("0.84", "0.85")   # qo'lda, har qayta o'qitishda  # ⚠️
# metrics.json -> README tekshiruvi CI da (2-misol)                     # ✅

portfolio = ["titanic", "uy_narxi", "kredit", "ketish"]   # hammasi tabular  # ⚠️
portfolio = ["ketish_xizmati", "sharh_tonalligi", "ab_test", "talab_bashorati"]  # ✅

# "Model har qanday mijoz uchun ketishni bashorat qiladi"               # ⚠️
# "## Cheklovlar: bitta hudud; kalibrlash tekshirilmagan; drift yo'q"   # ✅

df = pd.read_csv("ish_joyidan_mijozlar.csv")   # portfolio uchun         # ⚠️
df = yarat_sintetik(seed=0)  # yoki ochiq manba, litsenziyasi bilan      # ✅

1.  # README si bir qatorli, "Accuracy 0.82" li Titanic loyihasi ruberikada qancha oladi?
2.  # vaznlarni tasodifiy o'zgartirsak, eng yaxshi loyiha birinchiligicha qoladimi?
3.  # README da bazaviy AUC 0.732, natija faylida 0.7234 - tekshiruv nima deydi?
4.  # model qayta o'qitildi, README yangilanmadi - nechta raqam mos kelmaydi?
5.  # 4 ta tabular loyiha: bittasini olib tashlasak qamrov kamayadimi?
6.  # ochko'z tanlov (3 qadam) eng yaxshi 3 talik kombinatsiyadan yomonmi?
7.  # natija README ning 298-so'zida: 30 s lik ko'rib chiquvchi uni ko'radimi?
8.  # birinchi 10 qatorda natija bor - bu uning tez topilishini kafolatlaydimi?

1.  # README.md
    # Mening loyiham
    Bu loyihani kurs davomida qildim, ko'p narsa o'rgandim ...
    (natija 40-qatorda)

2.  "Modelimiz 95% aniqlikka erishdi"     # firibgarlik, 1% ijobiy sinf

3.  portfolio = ["titanic", "iris", "mnist", "uy_narxi", "titanic_v2"]

4.  # README: "AUC 0.85" ; metrics.json: {"auc": 0.8471}

5.  df = pd.read_csv("oldingi_ishdagi_mijozlar.csv")