18.2-dars: Cross-validation turlari

KFold(n_splits=5, shuffle=False)
  ma'lumotni KETMA-KET 5 bo'lakka bo'ladi
  shuffle=False -> tartib saqlanadi (xavfli!)
  shuffle=True  -> random_state bilan aralashtiriladi

StratifiedKFold(n_splits=5, shuffle=False)
  har foldda sinf ulushlari umumiy ulushga yaqin
  klassifikatsiya uchun DEFAULT

NIMA UCHUN stratifikatsiya:
  musbat ulushi 3% bo'lsa, oddiy KFold da
  bitta foldda 1%, boshqasida 5% chiqishi mumkin
  -> foldlar orasida katta dispersiya

GroupKFold(n_splits=5)
  bir GURUHning barcha qatorlari BITTA foldda qoladi

QACHON KERAK:
  bir foydalanuvchining ko'p sessiyasi
  bir bemorning ko'p tasviri
  bir do'konning ko'p kuni
  bir hujjatning ko'p jumlasi

StratifiedGroupKFold - guruhni saqlaydi VA sinf ulushini
  (sklearn 0.24+, guruhlar soni yetarli bo'lsa)

GroupShuffleSplit - guruh bo'yicha tasodifiy bo'lish

TimeSeriesSplit(n_splits=5)
  fold 1: o'quv [0:100]      test [100:200]
  fold 2: o'quv [0:200]      test [200:300]
  fold 3: o'quv [0:300]      test [300:400]
  ...
  test HAR DOIM o'quvdan KEYIN

max_train_size=N -> siljuvchi oyna (kengayuvchi emas)
gap=N            -> o'quv va test orasida bo'shliq

QACHON KERAK: bashorat kelajakka qaratilgan bo'lsa
  narx, talab, nosozlik, churn (kelasi oy)

ShuffleSplit(n_splits=10, test_size=0.2)
  har safar mustaqil tasodifiy bo'linish
  qatorlar bir necha marta testga tushishi mumkin
  + foldlar soni va test hajmi ALOHIDA sozlanadi

RepeatedStratifiedKFold(n_splits=5, n_repeats=3)
  5-fold CV ni 3 marta, har safar boshqa aralashtirish bilan
  + baho dispersiyasi kamayadi (15 ta o'lchov)
  + har qator har takrorda aynan bir marta testda

KICHIK MA'LUMOTDA (<1000) Repeated eng yaxshi tanlov

LeaveOneOut()  -> n ta fold, har birida 1 ta test qatori

+ deyarli xolis (o'quv hajmi n-1)
- n ta model o'rgatish (juda qimmat)
- BAHO DISPERSIYASI YUQORI (foldlar deyarli bir xil
  o'quv to'plamiga ega -> xatolar korrelyatsiyali)

LeaveOneGroupOut - bitta guruhni chiqarib qoldirish
  (masalan bitta kasalxona, bitta yil)

AMALIYOTDA: 5 yoki 10 fold deyarli har doim afzal

Savol: ma'lumotda vaqt tartibi bormi?
  ha  -> TimeSeriesSplit (+ gap)
  yo'q -> keyingi savol

Savol: takrorlanuvchi obyektlar bormi (user, bemor, do'kon)?
  ha  -> GroupKFold / StratifiedGroupKFold
  yo'q -> keyingi savol

Savol: klassifikatsiyami?
  ha  -> StratifiedKFold(shuffle=True, random_state=...)
  yo'q -> KFold(shuffle=True, random_state=...)

Savol: ma'lumot kichikmi (<1000)?
  ha  -> Repeated... (n_repeats=3..10)

from sklearn.model_selection import (GroupKFold, GroupShuffleSplit, KFold,
                                     LeaveOneGroupOut, LeaveOneOut,
                                     RepeatedStratifiedKFold, ShuffleSplit,
                                     StratifiedGroupKFold, StratifiedKFold,
                                     TimeSeriesSplit, cross_val_score)

KFold(5, shuffle=True, random_state=0)              # regressiya
StratifiedKFold(5, shuffle=True, random_state=0)    # klassifikatsiya
GroupKFold(5)                                       # guruh bor
StratifiedGroupKFold(5, shuffle=True, random_state=0)
TimeSeriesSplit(n_splits=5, gap=7)                  # vaqt qatori
RepeatedStratifiedKFold(n_splits=5, n_repeats=3, random_state=0)

cross_val_score(model, X, y, cv=cv, groups=guruh, scoring="roc_auc")
for tr, te in cv.split(X, y, groups=guruh): ...     # qo'lda
QOIDA: vaqt? -> guruh? -> stratifikatsiya? ·
       shuffle=True + random_state · strategiya bitta bo'lsin

KFold            oddiy, shuffle=True qo'ying
StratifiedKFold  klassifikatsiya uchun default
GroupKFold       takrorlanuvchi obyektlar
TimeSeriesSplit  kelajakni bashorat qilish
Repeated...      kichik ma'lumot
LeaveOneOut      qimmat, dispersiyasi yuqori

"""Stratifikatsiya va aralashtirishning ta'siri (real numpy/sklearn)."""

import numpy as np
from sklearn.datasets import make_classification
from sklearn.linear_model import LogisticRegression
from sklearn.metrics import roc_auc_score
from sklearn.model_selection import (KFold, StratifiedKFold,
                                     cross_val_score)
from sklearn.pipeline import make_pipeline
from sklearn.preprocessing import StandardScaler


def model():
    return make_pipeline(StandardScaler(),
                         LogisticRegression(max_iter=2000,
                                            class_weight="balanced"))


def main() -> None:
    X, y = make_classification(n_samples=1200, n_features=15,
                               n_informative=5, weights=[0.94, 0.06],
                               flip_y=0.05, class_sep=1.0, random_state=0)
    # ma'lumot maqsad bo'yicha TARTIBLANGAN (tez-tez uchraydigan holat)
    tartib = np.argsort(y, kind="stable")
    X_t, y_t = X[tartib], y[tartib]
    print("=== 1. Ma'lumot ===")
    print(f"  {len(y)} qator, musbat ulushi {y.mean():.2%}")
    print(f"  tartiblangan nusxada birinchi 10 ta y: {y_t[:10].tolist()}")
    print(f"  oxirgi 10 ta y: {y_t[-10:].tolist()}")

    print("\n=== 2. Foldlardagi musbat ulushi ===")
    strategiyalar = {
        "KFold(shuffle=False)": KFold(5),
        "KFold(shuffle=True)": KFold(5, shuffle=True, random_state=0),
        "StratifiedKFold": StratifiedKFold(5, shuffle=True, random_state=0),
    }
    for nom, cv in strategiyalar.items():
        ulushlar = [float(y_t[te].mean())
                    for _, te in cv.split(X_t, y_t)]
        print(f"  {nom:<22} {[f'{u:.3f}' for u in ulushlar]}")

    print("\n=== 3. Tartiblangan ma'lumotda CV natijasi ===")
    # cross_val_score buzilgan foldda ogohlantirish chiqaradi,
    # shuning uchun foldlarni qo'lda aylanamiz
    print(f"  {'strategiya':<22} {'ishlagan fold':>14} {'CV AUC':>9} "
          f"{'std':>8}")
    for nom, cv in strategiyalar.items():
        ballar = []
        for tr, te in cv.split(X_t, y_t):
            if len(np.unique(y_t[tr])) < 2 or len(np.unique(y_t[te])) < 2:
                continue                       # fold yaroqsiz
            m = model().fit(X_t[tr], y_t[tr])
            ballar.append(roc_auc_score(y_t[te],
                                        m.predict_proba(X_t[te])[:, 1]))
        if ballar:
            print(f"  {nom:<22} {len(ballar):>7}/5 {np.mean(ballar):>15.4f} "
                  f"{np.std(ballar):>8.4f}")
        else:
            print(f"  {nom:<22} {0:>7}/5 {'-':>15} {'-':>8}")
    print("  shuffle=False bilan foldda bitta sinf qolishi mumkin ->")
    print("  model o'rgatilmaydi va AUC hisoblanmaydi")

    print("\n=== 4. Aralashtirilgan ma'lumotda ===")
    print(f"  {'strategiya':<22} {'CV AUC':>9} {'std':>8}")
    for nom, cv in strategiyalar.items():
        b = cross_val_score(model(), X, y, cv=cv, scoring="roc_auc")
        print(f"  {nom:<22} {b.mean():>9.4f} {b.std():>8.4f}")
    print("  tartib tasodifiy bo'lsa farq kichik, lekin")
    print("  stratifikatsiya std ni baribir kamaytiradi")
    print("  ⭐ cv=5 - bu shuffle=False degani")


if __name__ == "__main__":
    main()

=== 1. Ma'lumot ===
  1200 qator, musbat ulushi 8.00%
  tartiblangan nusxada birinchi 10 ta y: [0, 0, 0, 0, 0, 0, 0, 0, 0, 0]
  oxirgi 10 ta y: [1, 1, 1, 1, 1, 1, 1, 1, 1, 1]

=== 2. Foldlardagi musbat ulushi ===
  KFold(shuffle=False)   ['0.000', '0.000', '0.000', '0.000', '0.400']
  KFold(shuffle=True)    ['0.100', '0.071', '0.067', '0.075', '0.087']
  StratifiedKFold        ['0.079', '0.079', '0.079', '0.079', '0.083']

=== 3. Tartiblangan ma'lumotda CV natijasi ===
  strategiya              ishlagan fold    CV AUC      std
  KFold(shuffle=False)         0/5               -        -
  KFold(shuffle=True)          5/5          0.8097   0.0332
  StratifiedKFold              5/5          0.8076   0.0530
  shuffle=False bilan foldda bitta sinf qolishi mumkin ->
  model o'rgatilmaydi va AUC hisoblanmaydi

=== 4. Aralashtirilgan ma'lumotda ===
  strategiya                CV AUC      std
  KFold(shuffle=False)      0.8119   0.0473
  KFold(shuffle=True)       0.8035   0.0544
  StratifiedKFold           0.8076   0.0530
  tartib tasodifiy bo'lsa farq kichik, lekin
  stratifikatsiya std ni baribir kamaytiradi
  ⭐ cv=5 - bu shuffle=False degani

"""Takrorlanuvchi obyektlar CV ni qanday buzadi (real numpy/pandas/sklearn)."""

import numpy as np
import pandas as pd
from sklearn.ensemble import HistGradientBoostingClassifier
from sklearn.model_selection import (GroupKFold, StratifiedGroupKFold,
                                     StratifiedKFold, cross_val_score)


def yarat(seed: int = 0, obyektlar: int = 500, qatorlar_soni: int = 10):
    """Har obyektning bir necha o'lchovi; obyektga xos siljish bor."""
    rng = np.random.default_rng(seed)
    qatorlar = []
    for o in range(obyektlar):
        siljish = rng.normal(0, 1.4)          # obyektga xos daraja
        imzo = rng.normal(0, 1, 3)            # obyektga xos "barmoq izi"
        for _ in range(qatorlar_soni):
            x = rng.normal(0, 1, 3)
            kuch = -0.2 + 0.9 * x[0] + 0.6 * x[1] + siljish
            y = int(rng.random() < 1 / (1 + np.exp(-kuch)))
            qatorlar.append([o, *x, *imzo, y])
    ustunlar = (["obyekt"] + [f"x{i}" for i in range(3)]
                + [f"imzo{i}" for i in range(3)] + ["y"])
    return pd.DataFrame(qatorlar, columns=ustunlar)


def main() -> None:
    df = yarat()
    belgilar = [c for c in df.columns if c not in ("obyekt", "y")]
    X, y = df[belgilar], df["y"].to_numpy()
    guruh = df["obyekt"].to_numpy()

    print("=== 1. Ma'lumot ===")
    print(f"  {len(df)} qator, {df['obyekt'].nunique()} obyekt")
    print(f"  har obyektda {len(df) // df['obyekt'].nunique()} qator")
    print(f"  belgilar: {belgilar}")
    print("  imzo0-2 - obyektga xos, maqsadga bevosita ta'sir qilmaydi")

    def model():
        return HistGradientBoostingClassifier(learning_rate=0.1, max_iter=200,
                                              random_state=0)

    print("\n=== 2. Strategiyalarni taqqoslash ===")
    variantlar = {
        "StratifiedKFold": (StratifiedKFold(5, shuffle=True, random_state=0),
                            None),
        "GroupKFold": (GroupKFold(5), guruh),
        "StratifiedGroupKFold": (
            StratifiedGroupKFold(5, shuffle=True, random_state=0), guruh),
    }
    print(f"  {'strategiya':<24} {'CV AUC':>9} {'std':>8}")
    ballar = {}
    for nom, (cv, g) in variantlar.items():
        b = cross_val_score(model(), X, y, cv=cv, groups=g,
                            scoring="roc_auc")
        ballar[nom] = b.mean()
        print(f"  {nom:<24} {b.mean():>9.4f} {b.std():>8.4f}")
    print(f"  leakage: {ballar['StratifiedKFold'] - ballar['GroupKFold']:+.4f}")

    print("\n=== 3. Foldlarda obyektlar kesishadimi ===")
    for nom, (cv, g) in variantlar.items():
        kesishish = 0
        for tr, te in cv.split(X, y, groups=g):
            kesishish += len(np.intersect1d(guruh[tr], guruh[te]))
        print(f"  {nom:<24} kesishgan obyekt-fold: {kesishish}")

    print("\n=== 4. Guruh hajmi leakage ni qanday oshiradi ===")
    print(f"  {'qator/obyekt':>13} {'StratifiedKFold':>17} "
          f"{'GroupKFold':>12} {'farq':>8}")
    for nechta in [2, 5, 10, 20]:
        d = yarat(obyektlar=300, qatorlar_soni=nechta)
        b_l = [c for c in d.columns if c not in ("obyekt", "y")]
        Xd, yd, gd = d[b_l], d["y"].to_numpy(), d["obyekt"].to_numpy()
        a = cross_val_score(model(), Xd, yd,
                            cv=StratifiedKFold(5, shuffle=True,
                                               random_state=0),
                            scoring="roc_auc").mean()
        b = cross_val_score(model(), Xd, yd, cv=GroupKFold(5), groups=gd,
                            scoring="roc_auc").mean()
        print(f"  {nechta:>13} {a:>17.4f} {b:>12.4f} {a - b:>+8.4f}")
    print("  ⭐ Guruh qancha katta - leakage shuncha kuchli")


if __name__ == "__main__":
    main()

=== 1. Ma'lumot ===
  5000 qator, 500 obyekt
  har obyektda 10 qator
  belgilar: ['x0', 'x1', 'x2', 'imzo0', 'imzo1', 'imzo2']
  imzo0-2 - obyektga xos, maqsadga bevosita ta'sir qilmaydi

=== 2. Strategiyalarni taqqoslash ===
  strategiya                  CV AUC      std
  StratifiedKFold             0.7457   0.0056
  GroupKFold                  0.6426   0.0130
  StratifiedGroupKFold        0.6322   0.0104
  leakage: +0.1031

=== 3. Foldlarda obyektlar kesishadimi ===
  StratifiedKFold          kesishgan obyekt-fold: 2242
  GroupKFold               kesishgan obyekt-fold: 0
  StratifiedGroupKFold     kesishgan obyekt-fold: 0

=== 4. Guruh hajmi leakage ni qanday oshiradi ===
   qator/obyekt   StratifiedKFold   GroupKFold     farq
              2            0.5940       0.5516  +0.0423
              5            0.6992       0.6236  +0.0755
             10            0.7477       0.6635  +0.0843
             20            0.7746       0.6359  +0.1387
  ⭐ Guruh qancha katta - leakage shuncha kuchli

"""Vaqt bo'yicha bo'lish va gap (real numpy/pandas/sklearn)."""

import numpy as np
import pandas as pd
from sklearn.ensemble import HistGradientBoostingRegressor
from sklearn.metrics import mean_absolute_error
from sklearn.model_selection import KFold, TimeSeriesSplit, cross_val_score


def yarat(n: int = 1200, seed: int = 0) -> pd.DataFrame:
    """Trend + mavsumiylik + rejim o'zgarishi bo'lgan kunlik qator."""
    rng = np.random.default_rng(seed)
    t = np.arange(n)
    trend = 0.02 * t
    mavsum = 3.0 * np.sin(2 * np.pi * t / 7) + 1.5 * np.sin(2 * np.pi * t / 365)
    rejim = np.where(t > 800, 4.0, 0.0)          # 800-kunda daraja siljidi
    shovqin = rng.normal(0, 1.0, n)
    y = 20 + trend + mavsum + rejim + shovqin
    df = pd.DataFrame({"kun": t, "qiymat": y})
    for lag in [1, 2, 3, 7, 14]:
        df[f"lag{lag}"] = df["qiymat"].shift(lag)
    df["oyna7"] = df["qiymat"].shift(1).rolling(7).mean()
    df["hafta_kuni"] = df["kun"] % 7
    return df.dropna().reset_index(drop=True)


def main() -> None:
    df = yarat()
    belgilar = [c for c in df.columns if c not in ("kun", "qiymat")]
    X, y = df[belgilar], df["qiymat"].to_numpy()

    print("=== 1. Ma'lumot ===")
    print(f"  {len(df)} kun, belgilar: {len(belgilar)}")
    print(f"  qiymat: {y.min():.1f} .. {y.max():.1f}")
    print("  800-kunda daraja siljishi bor")

    def model():
        return HistGradientBoostingRegressor(learning_rate=0.1, max_iter=200,
                                             random_state=0)

    print("\n=== 2. KFold va TimeSeriesSplit ===")
    variantlar = {
        "KFold(shuffle=True)": KFold(5, shuffle=True, random_state=0),
        "TimeSeriesSplit(5)": TimeSeriesSplit(5),
        "TimeSeriesSplit(gap=7)": TimeSeriesSplit(5, gap=7),
        "TSS(oyna=300)": TimeSeriesSplit(5, max_train_size=300),
    }
    print(f"  {'strategiya':<24} {'MAE':>8} {'std':>8}")
    for nom, cv in variantlar.items():
        b = -cross_val_score(model(), X, y, cv=cv,
                             scoring="neg_mean_absolute_error")
        print(f"  {nom:<24} {b.mean():>8.4f} {b.std():>8.4f}")
    print("  aralashtirilgan KFold kelajakdan o'rganadi -> optimistik")

    print("\n=== 3. TimeSeriesSplit foldlari ===")
    print(f"  {'fold':>5} {'o_quv':>8} {'test':>7} {'o_quv oxiri':>13} "
          f"{'test boshi':>12}")
    for i, (tr, te) in enumerate(TimeSeriesSplit(5).split(X), 1):
        print(f"  {i:>5} {len(tr):>8} {len(te):>7} "
              f"{int(df['kun'].iloc[tr[-1]]):>13} "
              f"{int(df['kun'].iloc[te[0]]):>12}")

    print("\n=== 4. Kengayuvchi va siljuvchi oyna ===")
    print(f"  {'fold':>5} {'kengayuvchi MAE':>17} {'siljuvchi(300) MAE':>20}")
    keng = list(TimeSeriesSplit(5).split(X))
    silj = list(TimeSeriesSplit(5, max_train_size=300).split(X))
    for i, ((tr1, te1), (tr2, te2)) in enumerate(zip(keng, silj), 1):
        m1 = model().fit(X.iloc[tr1], y[tr1])
        m2 = model().fit(X.iloc[tr2], y[tr2])
        e1 = mean_absolute_error(y[te1], m1.predict(X.iloc[te1]))
        e2 = mean_absolute_error(y[te2], m2.predict(X.iloc[te2]))
        print(f"  {i:>5} {e1:>17.4f} {e2:>20.4f}")
    print("  rejim o'zgargandan keyin siljuvchi oyna tezroq moslashadi")
    print("  ⭐ Vaqt qatorida test har doim o'quvdan keyin")


if __name__ == "__main__":
    main()

=== 1. Ma'lumot ===
  1186 kun, belgilar: 7
  qiymat: 17.5 .. 53.3
  800-kunda daraja siljishi bor

=== 2. KFold va TimeSeriesSplit ===
  strategiya                    MAE      std
  KFold(shuffle=True)        1.0169   0.0530
  TimeSeriesSplit(5)         2.3502   0.4588
  TimeSeriesSplit(gap=7)     2.4940   0.7949
  TSS(oyna=300)              2.3817   0.5169
  aralashtirilgan KFold kelajakdan o'rganadi -> optimistik

=== 3. TimeSeriesSplit foldlari ===
   fold    o_quv    test   o_quv oxiri   test boshi
      1      201     197           214          215
      2      398     197           411          412
      3      595     197           608          609
      4      792     197           805          806
      5      989     197          1002         1003

=== 4. Kengayuvchi va siljuvchi oyna ===
   fold   kengayuvchi MAE   siljuvchi(300) MAE
      1            2.0385               2.0385
      2            1.7106               1.7499
      3            2.3942               2.5602
      4            2.5463               2.2950
      5            3.0615               3.2648
  rejim o'zgargandan keyin siljuvchi oyna tezroq moslashadi
  ⭐ Vaqt qatorida test har doim o'quvdan keyin

"""Kichik ma'lumotda qaysi strategiya barqaror (real numpy/sklearn)."""

import numpy as np
from sklearn.datasets import make_classification
from sklearn.linear_model import LogisticRegression
from sklearn.model_selection import (LeaveOneOut, RepeatedStratifiedKFold,
                                     ShuffleSplit, StratifiedKFold,
                                     cross_val_score)
from sklearn.pipeline import make_pipeline
from sklearn.preprocessing import StandardScaler


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


def main() -> None:
    X, y = make_classification(n_samples=300, n_features=12, n_informative=5,
                               flip_y=0.12, class_sep=1.0, random_state=0)
    print("=== 1. Kichik ma'lumot ===")
    print(f"  {len(y)} qator, {X.shape[1]} belgi")

    print("\n=== 2. Strategiyalar va ularning bahosi ===")
    print(f"  {'strategiya':<28} {'baho':>8} {'foldlar':>8} "
          f"{'model soni':>11}")
    natija = {}
    variantlar = {
        "StratifiedKFold(5)": StratifiedKFold(5, shuffle=True,
                                              random_state=0),
        "StratifiedKFold(10)": StratifiedKFold(10, shuffle=True,
                                               random_state=0),
        "Repeated(5x5)": RepeatedStratifiedKFold(n_splits=5, n_repeats=5,
                                                 random_state=0),
        "ShuffleSplit(20, 0.2)": ShuffleSplit(n_splits=20, test_size=0.2,
                                              random_state=0),
        "LeaveOneOut": LeaveOneOut(),
    }
    for nom, cv in variantlar.items():
        b = cross_val_score(model(), X, y, cv=cv, scoring="accuracy")
        natija[nom] = b
        print(f"  {nom:<28} {b.mean():>8.4f} {len(b):>8} {len(b):>11}")

    print("\n=== 3. Baho qanchalik barqaror (10 ta turli seed) ===")
    print(f"  {'strategiya':<28} {'bahoning std i':>16}")
    for nom, yasovchi in [
            ("StratifiedKFold(5)",
             lambda s: StratifiedKFold(5, shuffle=True, random_state=s)),
            ("StratifiedKFold(10)",
             lambda s: StratifiedKFold(10, shuffle=True, random_state=s)),
            ("Repeated(5x5)",
             lambda s: RepeatedStratifiedKFold(n_splits=5, n_repeats=5,
                                               random_state=s)),
            ("ShuffleSplit(20, 0.2)",
             lambda s: ShuffleSplit(n_splits=20, test_size=0.2,
                                    random_state=s))]:
        ballar = [cross_val_score(model(), X, y, cv=yasovchi(s),
                                  scoring="accuracy").mean()
                  for s in range(10)]
        print(f"  {nom:<28} {np.std(ballar):>16.5f}")
    print("  (LeaveOneOut da tasodif yo'q - std = 0, lekin bu")
    print("   barqarorlik emas: baho o'zi yuqori dispersiyali)")

    print("\n=== 4. LeaveOneOut ning fold ballari ===")
    loo = natija["LeaveOneOut"]
    print(f"  fold ballari faqat 0 yoki 1: "
          f"{sorted(set(loo.tolist()))}")
    print(f"  shuning uchun 'std' ma'nosiz: {loo.std():.4f}")
    print(f"  o'rtacha aniqlik: {loo.mean():.4f}")
    print(f"  narx: {len(loo)} ta model (5-fold da atigi 5 ta)")
    print("  ⭐ Kichik ma'lumotda Repeated - eng yaxshi muvozanat")


if __name__ == "__main__":
    main()

=== 1. Kichik ma'lumot ===
  300 qator, 12 belgi

=== 2. Strategiyalar va ularning bahosi ===
  strategiya                       baho  foldlar  model soni
  StratifiedKFold(5)             0.7900        5           5
  StratifiedKFold(10)            0.8100       10          10
  Repeated(5x5)                  0.7933       25          25
  ShuffleSplit(20, 0.2)          0.8108       20          20
  LeaveOneOut                    0.8100      300         300

=== 3. Baho qanchalik barqaror (10 ta turli seed) ===
  strategiya                     bahoning std i
  StratifiedKFold(5)                    0.00844
  StratifiedKFold(10)                   0.00733
  Repeated(5x5)                         0.00298
  ShuffleSplit(20, 0.2)                 0.00806
  (LeaveOneOut da tasodif yo'q - std = 0, lekin bu
   barqarorlik emas: baho o'zi yuqori dispersiyali)

=== 4. LeaveOneOut ning fold ballari ===
  fold ballari faqat 0 yoki 1: [0.0, 1.0]
  shuning uchun 'std' ma'nosiz: 0.3923
  o'rtacha aniqlik: 0.8100
  narx: 300 ta model (5-fold da atigi 5 ta)
  ⭐ Kichik ma'lumotda Repeated - eng yaxshi muvozanat

cross_val_score(model, X, y, cv=5)                               # ⚠️
cross_val_score(model, X, y,
                cv=StratifiedKFold(5, shuffle=True,
                                   random_state=0))              # ✅

cross_val_score(model, X, y, cv=StratifiedKFold(5))              # ⚠️
cross_val_score(model, X, y, cv=GroupKFold(5), groups=user_id)   # ✅

KFold(5, shuffle=True)                                           # ⚠️
TimeSeriesSplit(5, gap=ufq)                                      # ✅

cross_val_score(m, X, y, cv=GroupKFold(5))          # ValueError  # ⚠️
cross_val_score(m, X, y, cv=GroupKFold(5), groups=g)             # ✅

StratifiedKFold(5, shuffle=True)     # random_state yo'q         # ⚠️
CV = StratifiedKFold(5, shuffle=True, random_state=0)  # umumiy  # ✅

cross_val_score(model, X, y, cv=LeaveOneOut())   # 10000 model   # ⚠️
cross_val_score(model, X, y, cv=RepeatedStratifiedKFold(...))    # ✅

TimeSeriesSplit(5)          # 7 kunlik ufq uchun leakage         # ⚠️
TimeSeriesSplit(5, gap=7)                                        # ✅

1.  # cv=5 klassifikatsiyada nima beradi?
2.  # shuffle sukut bo'yicha qanday?
3.  # stratifikatsiya nima qiladi?
4.  # GroupKFold qachon kerak?
5.  # StratifiedGroupKFold nima?
6.  # TimeSeriesSplit da test qayerda?
7.  # gap nima uchun?
8.  # max_train_size nima beradi?
9.  # ShuffleSplit va KFold farqi?
10. # Repeated nima uchun?
11. # LeaveOneOut kamchiligi?
12. # uch savol tartibi?

1.  cross_val_score(model, X, y, cv=5)

2.  cross_val_score(model, X, y, cv=StratifiedKFold(5))   # user_id bor

3.  KFold(5, shuffle=True)   # kunlik narx qatori

4.  cross_val_score(m, X, y, cv=GroupKFold(5))

5.  cross_val_score(model, X, y, cv=LeaveOneOut())   # n=50000