29.12-dars: Doimiy o'rganish va kurs yakuni

BOSQICH 1: ASOSLAR (1-7)
  1 Kirish -> 2 NumPy -> 3 Pandas -> 4 Statistika, 5 Vizualizatsiya,
  6 Tozalash, 7 Ma'lumot yig'ish
  "ma'lumotni qo'lga olish, tozalash, ko'rish"
        |
        v
BOSQICH 2: TAHLIL VA MATEMATIKA (8-11)
  8 EDA  9 Ehtimollik  10 Chiziqli algebra  11 Gipoteza testlari
  "savol berish, noaniqlikni o'lchash, vektorlar tilida fikrlash"
        |
        v
BOSQICH 3: KLASSIK ML (12-19)
  12 ML asoslari -> 13 Regressiya -> 14 Klassifikatsiya -> 15 Daraxtlar
  16 Nazoratsiz  17 Feature engineering  18 Baholash va sozlash  19 scikit-learn
  "model qurish va - eng muhimi - uni HALOL baholash"
        |
        v
BOSQICH 4: CHUQUR O'RGANISH VA AI (20-26)
  20 Neyron tarmoqlar -> 21 PyTorch -> 22 Ko'rish, 23 NLP -> 24 Transformerlar
  -> 25 LLM -> 26 Generativ AI
  "tasvir, matn va generatsiya; katta modellarni tizimga aylantirish"
        |
        v
BOSQICH 5: ISHLAB CHIQARISH VA MAXSUS MAVZULAR (27-28)
  27 MLOps va deploy   28 Vaqt qatorlari, tavsiya, RL, geo, katta ma'lumot,
                          sababiy xulosa
  "modelni xizmatga aylantirish, kuzatish; yangi turdagi vazifalar"
        |
        v
BOSQICH 6: LOYIHALAR VA KARYERA (29)
  loyiha hayot sikli -> portfolio -> rezyume -> intervyu -> etika -> davom
  "bilimni natijaga va kasbga aylantirish"

G'OYA                   BIRINCHI MARTA         QAYTA KELDI
bootstrap, SE           11.8                   18.10, 22-26 taqqoslashlar, 27.13, 28.11
sizish (leakage)        12.9                   17.8, 18.2, 23.13, 28.3, 28.9
kalibrlash              14.10                  27.14, 29.11 (guruhlar bo'yicha)
embedding               17 (kategoriyalar)     21.10, 23.6, 25.7 (semantik qidiruv)
gradient tushish        13.6                   20.7, 21.4, 28.8 (policy gradient)
PCA / SVD               10.8-10.9              16.8, 28.5 (matritsa faktorizatsiyasi)
korrelyatsiya != sabab  4.10                   8.4, 28.11 (DAG, AIPW)
tasodifiy tajriba       11 (testlar)           27.13 (A/B), 28.7 (banditlar)
reproduksiya            19.7                   21.7, 27.2, 29.6
etika                   1.7, 7.11              25.13, 26.9, 29.11

1. BAZAVIY HAR DOIM
   har model eng sodda bazaviy bilan solishtiriladi: ko'pchilik sinf,
   o'rtacha, "kechagi qiymat", mashhurlik, sozlangan chiziqli model
   -> 12.6, 18.1, 28.1 (vaqt qatori bazaviylari), 28.4 (mashhurlik)

2. HALOL BAHOLASH DIZAYNI
   savolga mos bo'lish; validatsiya tanlov uchun, test yakuniy baho uchun
   -> 12.3, 18.1, 18.2, 18.4 (nested CV), 28.1 (rolling-origin)

3. SIZISHGA QARSHI VAQT / GURUH BO'YICHA BO'LISH
   bir mijoz, bir bemor, bir do'kon - faqat bitta tomonda; kelajak - testda
   -> 12.3, 12.9, 17.8, 18.2, 28.3, 28.9 (fazoviy)

4. JUFTLASHGAN TAQQOSLASH VA 2*SE
   bir xil bo'lishlarda farq, uning SE si; |farq| > 2*SE - sezilarli
   -> 11.8, 18.3, 18.10, 27.13

5. "ENG SODDA MUNOSIB MODEL"
   eng yaxshisidan sezilarli yomon bo'lmagan eng sodda yondashuv
   -> 18.10, 27.14, 28.12

6. TEST BIR MARTA
   testga qarab tanlash - uni validatsiyaga aylantirish (optimizm)
   -> 12.3, 18.11

7. REPRODUKSIYA
   urug'lar, muhit, manifest; bitta urug' - bitta namuna
   -> 19.7, 27.2, 29.6

8. NATIJANI HALOL YOZISH
   kutilmagan va salbiy natija ham; noaniqlik bilan; cheklovlar bilan
   -> 5.13 (yolg'on grafiklar), 8.9, 29.4, 29.11

9. FARAZLARNI O'LCHAB TEKSHIRISH
   model/usul farazlari - diagnostika bilan, ishonch bilan emas
   -> 13.4, 28.11 (overlap, placebo)

TEZ ESKIRADI (oylar - bir necha yil)      SEKIN ESKIRADI (o'n yillar)
kutubxona API lari, versiyalar            ehtimollik va statistika
"eng yaxshi" model nomlari                chiziqli algebra, optimallash
bulut xizmatlari, narxlar                 baholash dizayni, sizish, bazaviy
prompt texnikalari                        sababiy fikrlash
ish bozori talablari                      muloqot, muammoni aniqlash
                                          halollik va reproduksiya

-> vaqtingizning katta qismini o'ng ustunni chuqurlashtirishga,
   kichik qismini chap ustunni kuzatishga sarflang

1-O'TISH (5-10 daqiqa): sarlavha, abstract, rasmlar/jadvallar, xulosa
   savol: maqola nimani da'vo qiladi? bu menga kerakmi?
2-O'TISH (bir soat): kirish, usul (asosiy g'oya), tajriba bo'limi
   savol: da'vo QANDAY tekshirilgan? jadvallardagi raqamlar nimani o'lchaydi?
3-O'TISH (kerak bo'lsa, bir necha soat): formulalar, ilovalar, kod
   savol: men buni qayta ishlab chiqa olamanmi?

TANQIDIY SAVOLLAR (tajriba bo'limi uchun):
  [ ] bazaviy bormi? u SOZLANGANmi yoki "standart parametrlar"da?
  [ ] nechta urug' / bo'lish? variatsiya (std, CI, SE) ko'rsatilganmi?
  [ ] farq variatsiyadan kattami (2*SE)?
  [ ] test to'plami qanday tanlangan? giperparametrlar testda tanlanmaganmi?
  [ ] sizish ehtimoli: guruh, vaqt, dublikatlar?
  [ ] ablation: yutuq qaysi qismdan keladi?
  [ ] hisob xarajati tengmi? (yangi usulga 10 barobar ko'p vaqt berilganmi?)
  [ ] ma'lumotlar to'plami qanday? mening vazifamga o'xshashmi?
  [ ] kod va ma'lumot ochiqmi?
  [ ] mualliflar cheklovlarni yozganmi?

1. DA'VONI ANIQ YOZING: "X usuli Y ma'lumotda Z metrikasi bo'yicha
   bazaviydan +2% yaxshi"
2. KICHIK MIQYOSDA BOSHLANG: ma'lumotning bir qismi, kichik model
3. AVVAL BAZAVIYNI QAYTA OLING: maqoladagi bazaviy raqamiga yeta olasizmi?
   yeta olmasangiz - baholash protokoli farq qiladi, yangi usulga o'tmang
4. BIR XIL PROTOKOL: bir xil bo'lishlar, metrika, oldindan ishlov
5. BIR NECHA URUG': kamida 5-10, juftlashgan farq va SE
6. BAZAVIYNI HAM SOZLANG: bir xil sozlash byudjeti bilan
7. HISOBOT: nima qayta olindi, nima olinmadi, farq sabablari haqida
   farazlar; muhit va urug'lar (27.2)

# Qayta ishlab chiqish: "Yangi usul bazaviydan +2% yaxshi"

## Da'vo
Maqola: yangi usul (gradient boosting) logistik regressiyadan aniqlik
bo'yicha +2.7% yaxshi. Bitta urug', bitta bo'lish (70/30).

## Protokol
- Ma'lumot: maqoladagi generator, 1000 qator, 8 belgi
- Bo'lish: 70/30, stratifikatsiya; 10 yangi urug' (100-109)
- Variantlar: yangi usul, maqoladagi bazaviy, sozlangan bazaviy
  (masshtablash + spline + C ni 3-fold CV bilan)
- Taqqoslash: juftlashgan farq, SE, qoida |farq| > 2*SE

## Natija
| taqqoslash                 | farq    | SE     | musbat urug'lar |
|----------------------------|---------|--------|-----------------|
| yangi - maqoladagi bazaviy | +0.0260 | 0.0084 | 9/10            |
| yangi - sozlangan bazaviy  | -0.0223 | 0.0085 | 1/10            |

## Xulosa
Da'vo maqoladagi bazaviyga nisbatan tasdiqlandi, lekin sozlangan bazaviy
yangi usuldan sezilarli yaxshi. Farq bazaviyning masshtablashsiz va qattiq
regularizatsiya qilinganidan kelgan deb taxmin qilamiz (tekshirish: ablation).

## Cheklovlar
Sintetik ma'lumot; boshqa ma'lumotda natija farq qilishi mumkin.
Muhit va urug'lar: manifest.json 27.2-bob.

SAVOL                                    QANDAY TEKSHIRILADI
muammom bormi, u hal qiladimi?           hozirgi og'riq nuqtasi yozma
mening ma'lumotimda yaxshiroqmi?         bazaviy bilan juftlashgan taqqoslash,
                                         bir necha urug', 2*SE
xarajati?                                o'qitish/bashorat vaqti, xotira, narx
bog'liqliklar va litsenziya?             ruxsat etilganmi, og'irmi, xavfsizmi
barqarorlik va qo'llab-quvvatlash?       versiyalar, o'zgarishlar jurnali,
                                         hujjatlar sifati
chiqib ketish narxi?                     keyin almashtirish qanchalik qiyin

QOIDA: "eng sodda munosib model" - kutubxonalarga ham tegishli
  yangi vosita faqat sezilarli foyda bersa va xarajati oqlansa qabul qilinadi
  cheklangan sinov: vaqt chegarasi (masalan, 1-2 hafta) va oldindan yozilgan
  qabul mezoni

## Hafta 14
- O'rgandim: GroupKFold va vaqt bo'yicha bo'lish farqi (18.2, 28.3 takror)
- Qildim: loyihada bo'lishni tuzatdim, AUC 0.84 -> 0.71 (halol raqam)
- Qiyin bo'ldi: kalibrlash egri chizig'ini guruhlar bo'yicha talqin qilish
- Keyingi hafta: 14.10 ni qayta o'qish, kalibrlashni loyihaga qo'shish
- Reja holati: 3 oylik bosqichdan 2 hafta orqada - normal, qayta tuzmayman

BIRINCHI HISSALAR (kichikdan boshlang):
  hujjatdagi xato yoki noaniq joyni tuzatish
  xato haqidagi xabarni (issue) minimal takrorlanadigan misol bilan yozish
  mavjud xato uchun test qo'shish
  "yangi boshlovchilar uchun" deb belgilangan kichik vazifa
QOIDALAR:
  loyihaning hissa qo'shish qo'llanmasini o'qing
  kod uslubi va testlarga rioya qiling; kichik, bitta maqsadli o'zgarish
  sharhlarga xotirjam javob bering - kod ko'rib chiqish o'rganishdir
JAMOA ICHIDA:
  kod ko'rib chiqish (review) - berish ham, olish ham
  ichki seminar: o'qigan maqolangiz yoki xatodan saboq
  "postmortem" - aybsiz tahlil
O'ZBEK TILIDA KONTENT:
  atamalar lug'ati, tushuntirish maqolasi, ochiq ma'lumot to'plami
  -> o'zingiz tushunganingizni tekshirishning ham eng yaxshi usuli

**Sarlavha:** `fit` bir xil `random_state` bilan ikki xil natija beradi

**Kutilgan:** bir xil ma'lumot va `random_state=0` bilan ikki marta
o'qitilgan model bir xil bashorat beradi.

**Haqiqatda:** bashoratlar 12 ta qatorda farq qiladi.

**Takrorlash uchun minimal misol:**
    import numpy as np
    from kutubxona import Model
    X = np.random.default_rng(0).normal(size=(200, 5))
    y = (X[:, 0] > 0).astype(int)
    a = Model(random_state=0).fit(X, y).predict(X)
    b = Model(random_state=0).fit(X, y).predict(X)
    print((a != b).sum())   # 12

**Muhit:** Python 3.x, kutubxona x.y.z, numpy a.b.c, OS
**Qo'shimcha:** `n_jobs=1` bilan muammo yo'qoladi - ehtimol parallel
ishlov tartibi bilan bog'liq.

import numpy as np


def juftlashgan(a, b):
    """Bir xil urug'/bo'lishlardagi ikki usul natijasi: farq, SE, sezilarlimi."""
    f = np.asarray(a) - np.asarray(b)
    se = f.std(ddof=1) / np.sqrt(len(f))
    return float(f.mean()), float(se), bool(abs(f.mean()) > 2 * se)


def qayta_ishlab_chiqish(usul, bazaviy, sozlangan_bazaviy, baho, urug_lar):
    """Da'voni tekshirish: har urug'da uchala variant bir xil bo'lishda."""
    y = [baho(usul, s) for s in urug_lar]
    b = [baho(bazaviy, s) for s in urug_lar]
    k = [baho(sozlangan_bazaviy, s) for s in urug_lar]
    return {"zaif": juftlashgan(y, b), "sozlangan": juftlashgan(y, k)}


def eng_sodda_munosib(natijalar, soddalik_tartibi):
    """natijalar: {nom: [urug' bo'yicha ball]}; eng yaxshidan sezilarli
    yomon bo'lmagan eng sodda nom."""
    eng = max(natijalar, key=lambda n: np.mean(natijalar[n]))
    for nom in soddalik_tartibi:
        farq, se, _ = juftlashgan(natijalar[eng], natijalar[nom])
        if farq <= 2 * se:
            return nom
    return eng

da'vo:            ________________________________
bazaviy sozlangan:  ha / yo'q / noma'lum
urug'/bo'lishlar:   __ ta, variatsiya: ha / yo'q
farq > 2*SE:        ha / yo'q / hisoblab bo'lmaydi
test qanday:        ________   sizish xavfi: ________
ablation:           ha / yo'q      kod: ha / yo'q
mening vazifamga:   mos / qisman / mos emas
qaror:              e'tiborsiz / kuzatish / qayta ishlab chiqish / sinov

asoslar -> tahlil -> klassik ML -> DL/AI -> ishlab chiqarish -> karyera
bazaviy | halol dizayn | vaqt/guruh bo'yicha bo'lish | juftlashgan + 2*SE
eng sodda munosib | test bir marta | reproduksiya | halol yozish
maqola: 3 o'tish, tanqidiy savollar; da'vo: qayta ishlab chiq, bazaviyni sozla
reja: T-shakl, har 3 oyda qayta ko'rib chiq; hissa: kichikdan boshla

"""Tamoyillar imtihoni: kursdagi to'rt tuzoq bitta kichik ma'lumotda."""

import numpy as np
from sklearn.ensemble import RandomForestClassifier
from sklearn.linear_model import LogisticRegression
from sklearn.metrics import roc_auc_score
from sklearn.model_selection import GroupKFold, GroupShuffleSplit, KFold
from sklearn.pipeline import make_pipeline
from sklearn.preprocessing import StandardScaler


def yarat(seed, mijozlar=300, oylar=6, nomzodlar=30):
    """Mijozning 6 oylik yozuvi; 'ketdi' yorlig'i mijoz darajasida (hamma oylarda bir xil)."""
    rng = np.random.default_rng(seed)
    n = mijozlar * oylar
    guruh = np.repeat(np.arange(mijozlar), oylar)
    z = rng.normal(0, 1, (mijozlar, 3))                  # mijozning asl xulqi
    x = z[guruh] + rng.normal(0, 0.8, (n, 3))            # oylik o'lchovlar
    tarif = rng.integers(0, 5, mijozlar)[guruh].astype(float)
    kun = rng.uniform(0, 2000, mijozlar)[guruh]          # ro'yxatdan o'tgan kun
    logit = -1.8 + 1.2 * z[:, 0] - 0.8 * z[:, 1] + 0.4 * z[:, 2]
    ketdi = rng.random(mijozlar) < 1 / (1 + np.exp(-logit))
    X = np.column_stack([x, tarif, kun])
    yangi_belgilar = rng.normal(0, 1, (n, nomzodlar))    # "belgi fabrikasi" - foydasiz
    return X, ketdi[guruh].astype(int), guruh, yangi_belgilar


def rf(seed=0):
    return RandomForestClassifier(n_estimators=60, random_state=seed, n_jobs=1)


def lr():
    return make_pipeline(StandardScaler(), LogisticRegression(max_iter=2000))


def auc_of(model, Xa, ya, Xb, yb):
    return roc_auc_score(yb, model.fit(Xa, ya).predict_proba(Xb)[:, 1])


def main() -> None:
    X, y, guruh, Z = yarat(0)
    print(f"Ma'lumot: {len(y)} qator, {len(np.unique(guruh))} mijoz, "
          f"ketganlar ulushi {y.mean():.3f}")

    print("\n=== Tuzoq 1: bazaviysiz 'yaxshi' model (12.6, 18.1) ===")
    sp = GroupShuffleSplit(n_splits=1, test_size=0.3, random_state=0)
    a, b = next(sp.split(X, y, guruh))
    m = rf().fit(X[a], y[a])
    aniq = np.mean(m.predict(X[b]) == y[b])
    baz = max(y[b].mean(), 1 - y[b].mean())
    print(f"  RandomForest aniqligi {aniq:.3f} - 'ajoyib'?")
    print(f"  bazaviy 'hech kim ketmaydi' aniqligi {baz:.3f}")
    print(f"  model bazaviydan {aniq - baz:+.3f} farq qiladi; AUC "
          f"{roc_auc_score(y[b], m.predict_proba(X[b])[:, 1]):.3f}")

    print("\n=== Tuzoq 2: tasodifiy bo'lish sizishi (12.3, 17.8, 18.2) ===")
    for nom, bol in [("tasodifiy KFold",
                      KFold(5, shuffle=True, random_state=0).split(X)),
                     ("mijoz bo'yicha GroupKFold", GroupKFold(5).split(X, y, guruh))]:
        s = [auc_of(rf(), X[i], y[i], X[j], y[j]) for i, j in bol]
        print(f"  RF, {nom:<26} AUC {np.mean(s):.3f}")
    print("  -> tasodifiy bo'lishda mijozning boshqa oylari o'quvda: model uni "
          "'kun' va 'tarif' bo'yicha taniydi")

    print("\n=== Tuzoq 3: bitta urug' natijasi (18.3, 18.10) ===")
    f = []
    for s in range(20):
        sp = GroupShuffleSplit(n_splits=1, test_size=0.3, random_state=s)
        a, b = next(sp.split(X, y, guruh))
        f.append(auc_of(rf(s), X[a], y[a], X[b], y[b])
                 - auc_of(lr(), X[a], y[a], X[b], y[b]))
    f = np.array(f)
    se = f.std(ddof=1) / np.sqrt(len(f))
    print(f"  urug' 0: RF - LogReg = {f[0]:+.4f}")
    print(f"  20 urug'da farq oralig'i: [{f.min():+.4f}, {f.max():+.4f}], "
          f"RF yaxshiroq: {int((f > 0).sum())} / {len(f)}")
    print(f"  20 urug' o'rtacha {f.mean():+.4f} (SE {se:.4f}), sezilarli: "
          f"{abs(f.mean()) > 2 * se}")
    if f.mean() > 2 * se:
        tanlov = "RandomForest (sezilarli yaxshi)"
    elif f.mean() < -2 * se:
        tanlov = "LogReg (sezilarli yaxshi va soddaroq)"
    else:
        tanlov = "LogReg (soddaroq, farq sezilarsiz)"
    print(f"  qaror: {tanlov}")

    print("\n=== Tuzoq 4: testga qarab belgi tanlash (12.3, 18.11) ===")
    X2, y2, _, Z2 = yarat(1, mijozlar=1000)      # yangi mijozlar - haqiqiy kelajak
    asos = [0, 1, 2, 3]
    natija = []
    for s in range(5):
        sp = GroupShuffleSplit(n_splits=1, test_size=0.3, random_state=100 + s)
        a, b = next(sp.split(X, y, guruh))
        A, B, C = (np.column_stack([M, W]) for M, W in
                   [(X[a], Z[a]), (X[b], Z[b]), (X2, Z2)])
        tanlangan = list(asos)
        joriy = auc_of(lr(), A[:, asos], y[a], B[:, asos], y[b])
        boshlang = joriy
        for _ in range(6):                           # ochko'z qo'shish, TEST bo'yicha
            nomzod = [(auc_of(lr(), A[:, tanlangan + [k]], y[a],
                              B[:, tanlangan + [k]], y[b]), k)
                      for k in range(5, A.shape[1]) if k not in tanlangan]
            eng, k = max(nomzod)
            if eng <= joriy:
                break
            tanlangan.append(k)
            joriy = eng
        yangi_asos = auc_of(lr(), A[:, asos], y[a], C[:, asos], y2)
        yangi_tan = auc_of(lr(), A[:, tanlangan], y[a], C[:, tanlangan], y2)
        natija.append((boshlang, joriy, yangi_asos, yangi_tan, len(tanlangan) - 4))
        if s == 0:
            print(f"  asosiy 4 belgi: test AUC {boshlang:.3f}")
            print(f"  +{len(tanlangan) - 4} 'yangi belgi' (test bo'yicha tanlangan): "
                  f"test AUC {joriy:.3f}")
            print(f"  1000 yangi mijozda: asosiy {yangi_asos:.3f}, "
                  f"tanlangan {yangi_tan:.3f}")
    r = np.array(natija)
    opt = r[:, 1] - r[:, 3]
    real = r[:, 3] - r[:, 2]
    print(f"  5 takror: test bo'yicha 'yutuq' {np.mean(r[:, 1] - r[:, 0]):+.3f}, "
          f"yangi mijozlarda haqiqiy yutuq {real.mean():+.3f} "
          f"(SE {real.std(ddof=1) / np.sqrt(5):.3f})")
    print(f"  tanlangan modelning optimizmi (test - yangi): {opt.mean():+.3f}")
    print("  ⭐ Tanlov validatsiyada, test - bir marta, oxirida")


if __name__ == "__main__":
    main()

Ma'lumot: 1800 qator, 300 mijoz, ketganlar ulushi 0.170

=== Tuzoq 1: bazaviysiz 'yaxshi' model (12.6, 18.1) ===
  RandomForest aniqligi 0.800 - 'ajoyib'?
  bazaviy 'hech kim ketmaydi' aniqligi 0.844
  model bazaviydan -0.044 farq qiladi; AUC 0.575

=== Tuzoq 2: tasodifiy bo'lish sizishi (12.3, 17.8, 18.2) ===
  RF, tasodifiy KFold            AUC 0.841
  RF, mijoz bo'yicha GroupKFold  AUC 0.643
  -> tasodifiy bo'lishda mijozning boshqa oylari o'quvda: model uni 'kun' va 'tarif' bo'yicha taniydi

=== Tuzoq 3: bitta urug' natijasi (18.3, 18.10) ===
  urug' 0: RF - LogReg = -0.1178
  20 urug'da farq oralig'i: [-0.1459, +0.0022], RF yaxshiroq: 1 / 20
  20 urug' o'rtacha -0.0825 (SE 0.0088), sezilarli: True
  qaror: LogReg (sezilarli yaxshi va soddaroq)

=== Tuzoq 4: testga qarab belgi tanlash (12.3, 18.11) ===
  asosiy 4 belgi: test AUC 0.789
  +6 'yangi belgi' (test bo'yicha tanlangan): test AUC 0.804
  1000 yangi mijozda: asosiy 0.732, tanlangan 0.721
  5 takror: test bo'yicha 'yutuq' +0.018, yangi mijozlarda haqiqiy yutuq -0.008 (SE 0.001)
  tanlangan modelning optimizmi (test - yangi): +0.041
  ⭐ Tanlov validatsiyada, test - bir marta, oxirida

"""Maqoladagi da'voni tekshirish: 'yangi usul bazaviydan +2% yaxshi'."""

import numpy as np
from sklearn.ensemble import HistGradientBoostingClassifier
from sklearn.linear_model import LogisticRegression
from sklearn.model_selection import GridSearchCV, train_test_split
from sklearn.pipeline import make_pipeline
from sklearn.preprocessing import SplineTransformer, StandardScaler


def yarat(seed, n=1000):
    """Signal asosan chiziqli, bitta belgida yumshoq egrilik; belgilar turli masshtabda."""
    rng = np.random.default_rng(seed)
    X = rng.normal(0, 1, (n, 8))
    logit = (1.2 * X[:, 0] - 0.9 * X[:, 1] + 0.6 * X[:, 2] + 0.8 * np.tanh(2 * X[:, 3])
             + 0.3 * X[:, 4])
    y = (rng.random(n) < 1 / (1 + np.exp(-logit))).astype(int)
    masshtab = np.array([1, 1000, 0.01, 1, 50, 1, 1, 1])
    return X * masshtab, y


def yangi_usul(seed):
    return HistGradientBoostingClassifier(max_iter=150, learning_rate=0.05,
                                          random_state=seed)


def zaif_bazaviy():
    """Maqoladagi bazaviy: masshtablashsiz, qattiq regularizatsiya, sozlanmagan."""
    return LogisticRegression(C=0.004, max_iter=5000)


def sozlangan_bazaviy():
    """Halol bazaviy: masshtablash + spline + C ni CV bilan tanlash."""
    q = make_pipeline(StandardScaler(), SplineTransformer(n_knots=4, degree=3),
                      LogisticRegression(max_iter=2000))
    return GridSearchCV(q, {"logisticregression__C": [0.03, 0.3, 3.0]}, cv=3)


def baho(model, seed):
    X, y = yarat(seed)
    a, b, ya, yb = train_test_split(X, y, test_size=0.3, random_state=seed,
                                    stratify=y)
    return float(np.mean(model.fit(a, ya).predict(b) == yb))


def juft(nom, fy, fb):
    """Juftlashgan farq: (o'rtacha, SE); ikkala tomonga 2*SE qoidasi."""
    f = np.array(fy) - np.array(fb)
    se = f.std(ddof=1) / np.sqrt(len(f))
    print(f"  {nom:<27} farq {f.mean():+.4f} (SE {se:.4f}), "
          f"musbat urug'lar {int((f > 0).sum())}/{len(f)}")
    return f.mean(), se


def main() -> None:
    print("=== 1. Maqoladagi da'vo: bitta urug' (0), bitta bo'lish ===")
    y0, b0 = baho(yangi_usul(0), 0), baho(zaif_bazaviy(), 0)
    print(f"  yangi usul {y0:.4f} vs bazaviy {b0:.4f} -> "
          f"'+{100 * (y0 - b0):.1f}% yaxshi'")
    sinov = [(baho(yangi_usul(s), s) - baho(zaif_bazaviy(), s), s)
             for s in range(1, 5)] + [(y0 - b0, 0)]
    f, s = max(sinov)
    print(f"  5 urug'dagi farqlar: "
          + ", ".join(f"{d:+.4f}" for d, _ in sorted(sinov, key=lambda t: t[1])))
    print(f"  agar muallif eng chiroylisini tanlasa (urug' {s}): '+{100 * f:.1f}%'")

    print("\n=== 2. Qayta ishlab chiqish: 10 YANGI urug' (100-109), juftlashgan ===")
    urug = range(100, 110)
    yangi = [baho(yangi_usul(s), s) for s in urug]
    zaif = [baho(zaif_bazaviy(), s) for s in urug]
    kuchli = [baho(sozlangan_bazaviy(), s) for s in urug]
    for nom, v in [("yangi usul", yangi), ("zaif bazaviy (maqoladagi)", zaif),
                   ("sozlangan bazaviy", kuchli)]:
        print(f"  {nom:<26} o'rtacha aniqlik {np.mean(v):.4f} "
              f"(urug'lar oralig'i {min(v):.4f}-{max(v):.4f})")
    zf, zse = juft("yangi - zaif bazaviy", yangi, zaif)
    kf, kse = juft("yangi - sozlangan bazaviy", yangi, kuchli)

    print("\n=== 3. Xulosa (natijadan) ===")
    print(f"  zaif bazaviyga nisbatan da'vo turadimi: {zf > 2 * zse}")
    print(f"  sozlangan bazaviyga nisbatan turadimi: {kf > 2 * kse}")
    if kf > 2 * kse:
        print("  da'vo tasdiqlandi: sozlangan bazaviydan ham sezilarli yaxshi")
    elif kf < -2 * kse:
        print("  sozlangan bazaviy yangi usuldan SEZILARLI yaxshi -> 'yutuq'")
        print("  usuldan emas, bazaviyning zaifligidan kelgan")
    else:
        print("  sozlangan bazaviy bilan farq sezilarsiz -> soddasi tanlanadi")
    print("  ⭐ Maqolani o'qishda: bazaviy sozlanganmi, nechta urug', SE bormi?")


if __name__ == "__main__":
    main()

=== 1. Maqoladagi da'vo: bitta urug' (0), bitta bo'lish ===
  yangi usul 0.7167 vs bazaviy 0.6900 -> '+2.7% yaxshi'
  5 urug'dagi farqlar: +0.0267, +0.0100, +0.0533, +0.0000, +0.0333
  agar muallif eng chiroylisini tanlasa (urug' 2): '+5.3%'

=== 2. Qayta ishlab chiqish: 10 YANGI urug' (100-109), juftlashgan ===
  yangi usul                 o'rtacha aniqlik 0.7363 (urug'lar oralig'i 0.6933-0.8000)
  zaif bazaviy (maqoladagi)  o'rtacha aniqlik 0.7103 (urug'lar oralig'i 0.6633-0.7800)
  sozlangan bazaviy          o'rtacha aniqlik 0.7587 (urug'lar oralig'i 0.7000-0.8100)
  yangi - zaif bazaviy        farq +0.0260 (SE 0.0084), musbat urug'lar 9/10
  yangi - sozlangan bazaviy   farq -0.0223 (SE 0.0085), musbat urug'lar 1/10

=== 3. Xulosa (natijadan) ===
  zaif bazaviyga nisbatan da'vo turadimi: True
  sozlangan bazaviyga nisbatan turadimi: False
  sozlangan bazaviy yangi usuldan SEZILARLI yaxshi -> 'yutuq'
  usuldan emas, bazaviyning zaifligidan kelgan
  ⭐ Maqolani o'qishda: bazaviy sozlanganmi, nechta urug', SE bormi?

"""O'rganish rejasi generatori: ko'nikmalar grafi (DAG) va topologik tartib."""

import heapq

QISMLAR = {
    1: ("Kirish", 8), 2: ("NumPy", 14), 3: ("Pandas", 14), 4: ("Statistika", 14),
    5: ("Vizualizatsiya", 14), 6: ("Tozalash", 12), 7: ("Ma'lumot yig'ish", 12),
    8: ("EDA", 10), 9: ("Ehtimollik", 10), 10: ("Chiziqli algebra", 10),
    11: ("Gipoteza testlari", 10), 12: ("ML asoslari", 10), 13: ("Regressiya", 12),
    14: ("Klassifikatsiya", 14), 15: ("Daraxtlar", 14), 16: ("Nazoratsiz", 12),
    17: ("Feature engineering", 10), 18: ("Baholash va sozlash", 12),
    19: ("scikit-learn", 10), 20: ("Neyron tarmoqlar", 12), 21: ("PyTorch", 12),
    22: ("Kompyuter ko'rish", 14), 23: ("NLP", 14), 24: ("Transformerlar", 12),
    25: ("LLM", 14), 26: ("Generativ AI", 10), 27: ("MLOps", 14),
    28: ("Maxsus mavzular", 12), 29: ("Loyihalar va karyera", 12),
}
TAYANADI = {  # qism -> qaysi qismlarga tayanadi
    2: [1], 3: [2], 4: [3], 5: [3], 6: [3], 7: [3], 8: [4, 5, 6],
    9: [4], 10: [2], 11: [9], 12: [8, 10], 13: [12], 14: [13], 15: [14],
    16: [10, 12], 17: [12], 18: [11, 17], 19: [18], 20: [10, 12], 21: [20],
    22: [21], 23: [21], 24: [23], 25: [24], 26: [22, 24], 27: [19],
    28: [18, 11], 29: [27, 18],
}
ROLLAR = {
    "Ma'lumot tahlilchisi": [8, 11, 7, 29],
    "ML muhandisi": [19, 27, 15, 29],
    "NLP / LLM muhandisi": [25, 27, 29],
    "Tadqiqotchi (sababiy tahlil)": [28, 18, 29],
}
SOAT_DARS = 1.5          # faraziy: bir darsni takrorlash + topshiriq
SOAT_HAFTA = 8           # faraziy: haftalik vaqt


def topologik(tugunlar):
    """Kahn algoritmi; teng holatda kichik raqam oldin (deterministik)."""
    kirish = {t: 0 for t in tugunlar}
    bola = {t: [] for t in tugunlar}
    for t in tugunlar:
        for p in TAYANADI.get(t, []):
            if p in tugunlar:
                kirish[t] += 1
                bola[p].append(t)
    navbat = [t for t in tugunlar if kirish[t] == 0]
    heapq.heapify(navbat)
    tartib = []
    while navbat:
        t = heapq.heappop(navbat)
        tartib.append(t)
        for b in sorted(bola[t]):
            kirish[b] -= 1
            if kirish[b] == 0:
                heapq.heappush(navbat, b)
    if len(tartib) != len(tugunlar):
        raise ValueError(f"sikl: {' -> '.join(map(str, sikl_top(bola, tartib)))}")
    return tartib


def sikl_top(bola, tartiblangan):
    """Tartiblanmay qolgan tugunlar ichidan bitta siklni DFS bilan topadi."""
    qolgan = sorted(set(bola) - set(tartiblangan))
    yol, holat = [], {}

    def dfs(t):
        holat[t] = 1
        yol.append(t)
        for b in sorted(bola[t]):
            if b not in qolgan:
                continue
            if holat.get(b) == 1:
                return yol[yol.index(b):] + [b]
            if b not in holat:
                r = dfs(b)
                if r:
                    return r
        holat[t] = 2
        yol.pop()
        return None

    for t in qolgan:
        if t not in holat:
            r = dfs(t)
            if r:
                return r
    return []


def ajdodlar(maqsadlar):
    kerak, stek = set(), list(maqsadlar)
    while stek:
        t = stek.pop()
        if t not in kerak:
            kerak.add(t)
            stek.extend(TAYANADI.get(t, []))
    return kerak


def main() -> None:
    print("=== 1. Graf tekshiruvi ===")
    tartib = topologik(set(QISMLAR))
    qirra = sum(len(v) for v in TAYANADI.values())
    print(f"  {len(QISMLAR)} tugun, {qirra} qirra, sikl yo'q; kurs tartibi "
          f"topologikmi: {tartib == sorted(QISMLAR)}")
    TAYANADI[3].append(12)                     # ataylab xato qirra
    try:
        topologik(set(QISMLAR))
    except ValueError as e:
        print(f"  xato qirra (3-qism 12-qismga tayanadi) qo'shilganda: {e}")
    TAYANADI[3].remove(12)

    print("\n=== 2. Rollar bo'yicha takrorlash hajmi (faraziy soatlar) ===")
    print(f"  {'rol':<30} {'qism':>4} {'dars':>5} {'soat':>5}   oy: 5 / 10 / 15 soat/hafta")
    rejalar = {}
    for rol, maqsad in ROLLAR.items():
        kerak = ajdodlar(maqsad)
        t = topologik(kerak)
        dars = sum(QISMLAR[q][1] for q in t)
        soat = dars * SOAT_DARS
        rejalar[rol] = t
        oylar = " / ".join(f"{soat / h / 4.33:4.1f}" for h in [5, 10, 15])
        print(f"  {rol:<30} {len(t):>4} {dars:>5} {soat:>5.0f}   {oylar}")

    rol = "ML muhandisi"
    print(f"\n=== 3. '{rol}' uchun reja: {SOAT_HAFTA} soat/hafta ===")
    hafta, qoldiq, bosqich = 0.0, [], {3: [], 6: [], 12: []}
    for q in rejalar[rol]:
        hafta += QISMLAR[q][1] * SOAT_DARS / SOAT_HAFTA
        oy = hafta / 4.33
        kalit = 3 if oy <= 3 else (6 if oy <= 6 else 12)
        (bosqich[kalit] if oy <= 12 else qoldiq).append(f"{q} {QISMLAR[q][0]}")
    for k, nom in [(3, "1-3 oy"), (6, "4-6 oy"), (12, "7-12 oy")]:
        print(f"  {nom}: " + ", ".join(bosqich[k]))
    if qoldiq:
        print(f"  12 oydan keyin qolgani: {', '.join(qoldiq)}")
    else:
        print("  hammasi 12 oy ichiga sig'di")
    print(f"  jami: {hafta:.1f} hafta ({hafta / 4.33:.1f} oy)")
    chiqmagan = sorted(set(QISMLAR) - set(rejalar[rol]))
    print(f"  bu rol uchun keyinga qoldirilgan qismlar: {chiqmagan}")
    print("  ⭐ Reja - taxmin: har 3 oyda natijaga qarab qayta tuzing")


if __name__ == "__main__":
    main()

=== 1. Graf tekshiruvi ===
  29 tugun, 37 qirra, sikl yo'q; kurs tartibi topologikmi: True
  xato qirra (3-qism 12-qismga tayanadi) qo'shilganda: sikl: 3 -> 4 -> 8 -> 12 -> 3

=== 2. Rollar bo'yicha takrorlash hajmi (faraziy soatlar) ===
  rol                            qism  dars  soat   oy: 5 / 10 / 15 soat/hafta
  Ma'lumot tahlilchisi             17   196   294   13.6 /  6.8 /  4.5
  ML muhandisi                     19   224   336   15.5 /  7.8 /  5.2
  NLP / LLM muhandisi              21   248   372   17.2 /  8.6 /  5.7
  Tadqiqotchi (sababiy tahlil)     17   196   294   13.6 /  6.8 /  4.5

=== 3. 'ML muhandisi' uchun reja: 8 soat/hafta ===
  1-3 oy: 1 Kirish, 2 NumPy, 3 Pandas, 4 Statistika, 5 Vizualizatsiya
  4-6 oy: 6 Tozalash, 8 EDA, 9 Ehtimollik, 10 Chiziqli algebra, 11 Gipoteza testlari, 12 ML asoslari, 13 Regressiya
  7-12 oy: 14 Klassifikatsiya, 15 Daraxtlar, 17 Feature engineering, 18 Baholash va sozlash, 19 scikit-learn, 27 MLOps, 29 Loyihalar va karyera
  hammasi 12 oy ichiga sig'di
  jami: 42.0 hafta (9.7 oy)
  bu rol uchun keyinga qoldirilgan qismlar: [7, 16, 20, 21, 22, 23, 24, 25, 26, 28]
  ⭐ Reja - taxmin: har 3 oyda natijaga qarab qayta tuzing

"""Kurs statistikasi: qismlar, bosqichlar va tamoyillar (ro'yxat kod ichida qo'lda)."""

QISMLAR = [  # (raqam, nom, darslar soni, bosqich)
    (1, "Kirish", 8, "asoslar"), (2, "NumPy", 14, "asoslar"),
    (3, "Pandas", 14, "asoslar"), (4, "Statistika", 14, "asoslar"),
    (5, "Vizualizatsiya", 14, "asoslar"), (6, "Ma'lumotni tozalash", 12, "asoslar"),
    (7, "Ma'lumot yig'ish", 12, "asoslar"), (8, "EDA", 10, "tahlil"),
    (9, "Ehtimollik", 10, "tahlil"), (10, "Chiziqli algebra", 10, "tahlil"),
    (11, "Gipoteza testlari", 10, "tahlil"), (12, "ML asoslari", 10, "ML"),
    (13, "Regressiya", 12, "ML"), (14, "Klassifikatsiya", 14, "ML"),
    (15, "Daraxtlar va ansambllar", 14, "ML"), (16, "Nazoratsiz o'rganish", 12, "ML"),
    (17, "Feature engineering", 10, "ML"), (18, "Model baholash va sozlash", 12, "ML"),
    (19, "scikit-learn to'liq", 10, "ML"), (20, "Neyron tarmoqlar", 12, "DL/AI"),
    (21, "PyTorch", 12, "DL/AI"), (22, "Kompyuter ko'rish", 14, "DL/AI"),
    (23, "NLP", 14, "DL/AI"), (24, "Transformerlar", 12, "DL/AI"),
    (25, "Katta til modellari", 14, "DL/AI"), (26, "Generativ AI", 10, "DL/AI"),
    (27, "MLOps va deploy", 14, "ishlab chiqarish"),
    (28, "Maxsus mavzular", 12, "ishlab chiqarish"),
    (29, "Loyihalar va karyera", 12, "karyera"),
]
BOSQICHLAR = ["asoslar", "tahlil", "ML", "DL/AI", "ishlab chiqarish", "karyera"]
TAMOYILLAR = {  # tamoyil -> u muntazam ishlatilgan qismlar (taxminiy belgilash)
    "bazaviy har doim": [12, 13, 14, 15, 16, 17, 18, 20, 21, 22, 23, 24, 25, 26,
                         28, 29],
    "test bir marta": [6, 12, 13, 15, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28,
                       29],
    "vaqt/guruh bo'yicha bo'lish": [12, 17, 18, 19, 20, 23, 24, 25, 27, 28, 29],
    "juftlashgan taqqoslash, 2*SE": [11, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27,
                                     28, 29],
    "eng sodda munosib model": [18, 21, 22, 23, 24, 25, 26, 27, 28, 29],
    "reproduksiya va urug'lar": [1, 2, 6, 7, 8, 12, 19, 21, 22, 27, 29],
}
MISOL_DARSDA, VAZIFA_DARSDA = 4, 7      # har dars formati bo'yicha


def main() -> None:
    jami = sum(d for _, _, d, _ in QISMLAR)
    print("=== 1. Kurs xaritasi: bosqichlar ===")
    print(f"  {'bosqich':<17} {'qismlar':<8} {'dars':>4} {'ulush':>6}")
    for b in BOSQICHLAR:
        q = [(r, d) for r, _, d, bb in QISMLAR if bb == b]
        dars = sum(d for _, d in q)
        oraliq = f"{q[0][0]}-{q[-1][0]}" if len(q) > 1 else str(q[0][0])
        print(f"  {b:<17} {oraliq:<8} {dars:>4} {dars / jami:>6.1%} "
              + "#" * round(60 * dars / jami))
    print(f"  jami: {len(QISMLAR)} qism, {jami} dars, taxminan "
          f"{jami * MISOL_DARSDA} ishlaydigan misol va {jami * VAZIFA_DARSDA} topshiriq")

    print("\n=== 2. Qism uzunliklari ===")
    uz = sorted(QISMLAR, key=lambda t: (t[2], t[0]))
    print(f"  eng qisqa: {uz[0][0]}-qism {uz[0][1]} ({uz[0][2]} dars); "
          f"eng uzun: {', '.join(f'{r}-qism' for r, _, d, _ in uz if d == uz[-1][2])}"
          f" ({uz[-1][2]} dars)")
    print(f"  o'rtacha qism: {jami / len(QISMLAR):.1f} dars")

    print("\n=== 3. Tamoyillar: qayerda boshlandi va qancha yashadi ===")
    print(f"  {'tamoyil':<30} {'qism':>4} {'birinchi':>8} {'oxirgi':>6} "
          f"{'bosqichlar':>10}")
    bosqich_of = {r: b for r, _, _, b in QISMLAR}
    qamrov = []
    for t, qs in TAMOYILLAR.items():
        bs = len({bosqich_of[q] for q in qs})
        qamrov.append((len(qs), t))
        print(f"  {t:<30} {len(qs):>4} {min(qs):>8} {max(qs):>6} {bs:>10}")
    qamrov.sort(reverse=True)
    print(f"  eng ko'p qismda ishlatilgani: '{qamrov[0][1]}' ({qamrov[0][0]} qism)")
    zich = {r: sum(r in v for v in TAMOYILLAR.values()) for r, _, _, _ in QISMLAR}
    for k in range(len(TAMOYILLAR), 0, -1):
        qs = [r for r in sorted(zich) if zich[r] == k]
        if qs:
            print(f"  {k} ta tamoyil birga ishlatilgan qismlar: {qs}")
    bosh = [r for r in sorted(zich) if zich[r] == 0]
    print(f"  asosan vosita o'rganilgan qismlar (poydevor): {bosh}")

    print("\n=== 4. Ramziy yakun ===")
    tugatilgan = len(QISMLAR)
    print(f"  qismlar: [{'#' * tugatilgan}] {tugatilgan}/{len(QISMLAR)}")
    print(f"  darslar: {jami}/{jami} - kurs tugadi, o'rganish esa davom etadi")
    print("  ⭐ Keyingi qadam: bitta loyiha, bitta maqola, bitta hissa")


if __name__ == "__main__":
    main()

=== 1. Kurs xaritasi: bosqichlar ===
  bosqich           qismlar  dars  ulush
  asoslar           1-7        88  25.3% ###############
  tahlil            8-11       40  11.5% #######
  ML                12-19      94  27.0% ################
  DL/AI             20-26      88  25.3% ###############
  ishlab chiqarish  27-28      26   7.5% ####
  karyera           29         12   3.4% ##
  jami: 29 qism, 348 dars, taxminan 1392 ishlaydigan misol va 2436 topshiriq

=== 2. Qism uzunliklari ===
  eng qisqa: 1-qism Kirish (8 dars); eng uzun: 2-qism, 3-qism, 4-qism, 5-qism, 14-qism, 15-qism, 22-qism, 23-qism, 25-qism, 27-qism (14 dars)
  o'rtacha qism: 12.0 dars

=== 3. Tamoyillar: qayerda boshlandi va qancha yashadi ===
  tamoyil                        qism birinchi oxirgi bosqichlar
  bazaviy har doim                 16       12     29          4
  test bir marta                   17        6     29          5
  vaqt/guruh bo'yicha bo'lish      11       12     29          4
  juftlashgan taqqoslash, 2*SE     13       11     29          5
  eng sodda munosib model          10       18     29          4
  reproduksiya va urug'lar         11        1     29          6
  eng ko'p qismda ishlatilgani: 'test bir marta' (17 qism)
  6 ta tamoyil birga ishlatilgan qismlar: [29]
  5 ta tamoyil birga ishlatilgan qismlar: [18, 21, 22, 23, 24, 25, 27, 28]
  4 ta tamoyil birga ishlatilgan qismlar: [12, 19, 20, 26]
  3 ta tamoyil birga ishlatilgan qismlar: [17]
  2 ta tamoyil birga ishlatilgan qismlar: [6, 13, 15]
  1 ta tamoyil birga ishlatilgan qismlar: [1, 2, 7, 8, 11, 14, 16]
  asosan vosita o'rganilgan qismlar (poydevor): [3, 4, 5, 9, 10]

=== 4. Ramziy yakun ===
  qismlar: [#############################] 29/29
  darslar: 348/348 - kurs tugadi, o'rganish esa davom etadi
  ⭐ Keyingi qadam: bitta loyiha, bitta maqola, bitta hissa

if maqola_farqi > 0: joriy_qil(yangi_usul)                      # ⚠️
natija = qayta_ishlab_chiqish(yangi, zaif, sozlangan, baho, range(10))  # ✅

bazaviy = LogisticRegression()                                  # ⚠️ standart, masshtabsiz
bazaviy = GridSearchCV(make_pipeline(StandardScaler(), LogisticRegression()),
                       {"logisticregression__C": [0.01, 0.1, 1, 10]})   # ✅ teng byudjet

print(baho(yangi, 0) - baho(bazaviy, 0))                        # ⚠️
print(juftlashgan([baho(yangi, s) for s in range(10)],
                  [baho(bazaviy, s) for s in range(10)]))       # ✅ farq, SE, sezilarli

cross_val_score(model, X, y, cv=KFold(5, shuffle=True))         # ⚠️ bir mijoz ikki tomonda
cross_val_score(model, X, y, cv=GroupKFold(5), groups=mijoz)    # ✅

for belgi in nomzodlar: ... test_auc ...                        # ⚠️ test -> validatsiya
# tanlov: validatsiya yoki CV; test - bir marta, oxirida, qaror yozilgandan keyin  # ✅

import yangi_modny_kutubxona                                     # ⚠️
# og'riq nuqtasi -> o'z ma'lumotingizda juftlashgan taqqoslash -> xarajat,
# litsenziya, qo'llab-quvvatlash -> oldindan yozilgan qabul mezoni           # ✅

# har kuni yangi mavzu, hech biri tugamaydi                                # ⚠️
# rol -> maqsad qismlar -> tayanchlar grafi -> tartib -> 3 oylik bosqichlar  # ✅

1.  # nomutanosib ma'lumot (ketganlar 17%), model aniqligi 0.80 - yaxshimi?
2.  # bir mijozning 6 oyi, tasodifiy KFold va GroupKFold - qaysi AUC katta?
3.  # 20 urug'da farq [-0.15, +0.002] - bitta urug' bilan qanday xulosa chiqishi mumkin?
4.  # 30 ta shovqin belgidan test bo'yicha tanlash - test AUC va yangi ma'lumotdagi AUC?
5.  # maqola: bitta urug', +2.7% - 5 urug'dagi farqlar oralig'i?
6.  # yangi usul sozlanmagan bazaviydan sezilarli yaxshi - sozlangandan-chi?
7.  # "kurs tartibi topologikmi" tekshiruvi nimani ko'rsatadi?
8.  # 3-qism 12-qismga tayansa nima bo'ladi?
9.  # 336 soat, haftasiga 10 soat - necha oy?
10. # kursdagi eng katta bosqich qaysi?
11. # qaysi qismda oltita tamoyil ham ishlatilgan?
12. # qayta ishlab chiqish natija bermadi - nima qilish kerak?

1.  natija = baho(yangi, seed=0) - baho(bazaviy, seed=0)
    print("yangi usul", natija, "ga yaxshi - joriy qilamiz")

2.  bazaviy = LogisticRegression(C=0.004)   # maqoladagidek
    yangi = HistGradientBoostingClassifier()  # 50 marta sozlangan

3.  cv = KFold(5, shuffle=True)   # har mijozning 6 oyi
    print(cross_val_score(rf, X, y, cv=cv).mean())

4.  for k in nomzodlar:
        if test_auc(belgilar + [k]) > test_auc(belgilar):
            belgilar.append(k)

5.  reja = ["hamma qismlar", "har kuni yangi mavzu"]