14.7-dars: Qaror chegaralarini solishtirish

ALGORITM        CHEGARA                     XOSSASI
LogReg          giperslip                   silliq, global
LDA             giperslip                   silliq, global (generativ)
QDA             kvadratik sirt              o'rtacha moslashuvchan
GaussianNB      kvadratik (diagonal)        cheklangan kvadratik
KNN             mahalliy, "tishli"          juda moslashuvchan
SVM-linear      giperslip (maksimal marja)  silliq, chekka nuqtalarga tayanadi
SVM-rbf         silliq nochiziqli           moslashuvchanlik gamma bilan
Daraxt          o'qlarga parallel to'rtburchak  bo'lakli doimiy (17-qism)

XOSSA                      MOS ALGORITMLAR
chegara chiziqli           LogReg, LDA, chiziqli SVM
chegara nochiziqli         SVM-rbf, KNN, daraxtlar, QDA
namuna kam (n < 500)       LDA(shrinkage), NB, regularizatsiyalangan LogReg
namuna ko'p (n > 100k)     chiziqli modellar, SGD, boosting
belgi ko'p (p > n)         chiziqli SVM, LogReg(L1/L2), NB
shovqin ko'p               regularizatsiyalangan chiziqli, katta k li KNN
kategoriyalar ko'p         daraxtlar, target encoding + chiziqli
ehtimol kerak              LogReg (kalibrlangan), keyin kalibrlash
talqin kerak               LogReg, LDA, daraxt
tezlik kerak               NB, chiziqli modellar

Kam namunada:
  · kuchli taxminli modellar yutadi (LDA, NB) — taxmin "qo'shimcha ma'lumot"
  · moslashuvchan modellar overfitting qiladi (KNN k=1, chuqur daraxt)

Ko'p namunada:
  · moslashuvchan modellar yutadi (ularning bias i kamayadi)
  · taxminli modellar "to'xtab qoladi" (bias qoladi)

O'QUV EGRI CHIZIG'I (learning curve) buni ko'rsatadi:
  learning_curve(model, X, y, train_sizes=[...], cv=5)

Shovqin turlari:
  · yorliq shovqini (noto'g'ri belgilangan namunalar)
  · belgi shovqini (o'lchov xatosi)
  · foydasiz belgilar

Chidamli:      regularizatsiyalangan chiziqli, katta k li KNN, LDA, ansambllar
Sezgir:        k=1 li KNN, chuqur daraxt, katta C/gamma li SVM

Qoida: shovqin ko'p bo'lsa — SODDAROQ model va kuchliroq regularizatsiya

p ortganda:
  KNN          — keskin yomonlashadi (o'lcham la'nati — 14.2)
  QDA          — parametrlar portlaydi 14.4-bob
  GaussianNB   — barqaror (har belgi alohida)
  LogReg/SVM   — regularizatsiya bilan barqaror
  Daraxtlar    — belgi tanlash o'zida bor, nisbatan barqaror

p > n holati: chiziqli SVM, L1/L2 LogReg, NB — ishlaydi
              KNN, QDA — deyarli ishlamaydi

ALGORITM      O'QITISH          BASHORAT        XOTIRA
NB            O(n·p)            O(p·K)          kichik
LogReg        O(n·p·iter)       O(p)            kichik
LDA/QDA       O(n·p^2 + p^3)    O(p^2)          o'rtacha
Chiziqli SVM  O(n·p)            O(p)            kichik
Kernel SVM    O(n^2..n^3)       O(n_TV·p)       katta
KNN           O(1)              O(n·p)          butun ma'lumot

import numpy as np
from sklearn.model_selection import StratifiedKFold, cross_val_score, learning_curve
from sklearn.pipeline import Pipeline
from sklearn.preprocessing import StandardScaler

cv = StratifiedKFold(5, shuffle=True, random_state=0)
nomzodlar = {"LogReg": ..., "SVM-rbf": ..., "KNN": ...}
for nom, m in nomzodlar.items():
    b = cross_val_score(m, X, y, cv=cv, scoring="f1_macro")
    print(f"{nom}: {b.mean():.4f} ± {b.std():.4f}")

hajm, oquv, val = learning_curve(model, X, y, cv=cv,
                                 train_sizes=np.linspace(0.1, 1.0, 6),
                                 scoring="accuracy")
QOIDA: xossani o'lcha · nomzodni qisqart · bir xil CV · SD bilan · narxni hisobla

Chiziqli chegara → LogReg/LDA/LinearSVC · Nochiziqli → SVM-rbf/KNN/daraxt
n kichik → LDA(shrinkage)/NB · n katta → chiziqli/SGD/boosting
p > n → chiziqli + regularizatsiya/NB · Shovqin → soddaroq model
Ehtimol → LogReg · Talqin → LogReg/LDA/daraxt · Tezlik → NB/chiziqli

"""Chegara shakli natijani qanday belgilaydi (real numpy/sklearn)."""

import numpy as np
from sklearn.discriminant_analysis import (LinearDiscriminantAnalysis,
                                           QuadraticDiscriminantAnalysis)
from sklearn.linear_model import LogisticRegression
from sklearn.model_selection import StratifiedKFold, cross_val_score
from sklearn.naive_bayes import GaussianNB
from sklearn.neighbors import KNeighborsClassifier
from sklearn.pipeline import Pipeline
from sklearn.preprocessing import StandardScaler
from sklearn.svm import SVC


def yarat(tur: str, seed: int = 4, n: int = 1500):
    rng = np.random.default_rng(seed)
    if tur == "chiziqli":
        X = rng.normal(0, 1, (n, 2))
        y = (1.3 * X[:, 0] + 0.9 * X[:, 1] + rng.normal(0, 0.5, n) > 0).astype(int)
    elif tur == "halqa":
        y = rng.integers(0, 2, n)
        r = np.where(y == 1, 2.3, 1.0) + rng.normal(0, 0.35, n)
        a = rng.uniform(0, 2 * np.pi, n)
        X = np.column_stack([r * np.cos(a), r * np.sin(a)])
    else:                                           # "xor"
        X = rng.uniform(-2.5, 2.5, (n, 2))
        y = ((X[:, 0] > 0) ^ (X[:, 1] > 0)).astype(int)
        alm = rng.random(n) < 0.06
        y[alm] = 1 - y[alm]
    return X, y


def modellar() -> dict:
    sc = lambda m: Pipeline([("sc", StandardScaler()), ("m", m)])
    return {
        "LogReg": sc(LogisticRegression(max_iter=2000)),
        "LDA": LinearDiscriminantAnalysis(),
        "QDA": QuadraticDiscriminantAnalysis(),
        "GaussNB": GaussianNB(),
        "KNN(15)": sc(KNeighborsClassifier(15)),
        "SVM-lin": sc(SVC(kernel="linear", C=1.0)),
        "SVM-rbf": sc(SVC(C=10.0, gamma="scale")),
    }


def main() -> None:
    cv = StratifiedKFold(5, shuffle=True, random_state=0)
    nomlar = list(modellar())

    print("=== 1. CV aniqligi (uch xil chegara) ===")
    print(f"  {'malumot':<11} " + "".join(f"{k:>9}" for k in nomlar))
    natija = {}
    for tur in ["chiziqli", "halqa", "xor"]:
        X, y = yarat(tur)
        ballar = [cross_val_score(m, X, y, cv=cv).mean()
                  for m in modellar().values()]
        natija[tur] = dict(zip(nomlar, ballar))
        print(f"  {tur:<11} " + "".join(f"{b:>9.4f}" for b in ballar))

    print("\n=== 2. Har ma'lumot uchun eng yaxshi ===")
    for tur, ballar in natija.items():
        eng = max(ballar, key=ballar.get)
        yomon = min(ballar, key=ballar.get)
        print(f"  {tur:<11}: eng yaxshi {eng} ({ballar[eng]:.4f}), "
              f"eng yomon {yomon} ({ballar[yomon]:.4f})")

    print("\n=== 3. Chiziqli modellar nochiziqli ma'lumotda ===")
    for tur in ["halqa", "xor"]:
        chiziqli = np.mean([natija[tur][k] for k in ["LogReg", "LDA", "SVM-lin"]])
        nochiziqli = np.mean([natija[tur][k] for k in ["QDA", "KNN(15)", "SVM-rbf"]])
        print(f"  {tur:<7}: chiziqli o'rtacha {chiziqli:.4f}, "
              f"nochiziqli o'rtacha {nochiziqli:.4f}")

    print("\n=== 4. Nochiziqli belgilar chiziqli modelni tiklaydi ===")
    X, y = yarat("halqa")
    X2 = np.column_stack([X, X[:, 0] ** 2, X[:, 1] ** 2, X[:, 0] * X[:, 1]])
    oddiy = cross_val_score(Pipeline([("sc", StandardScaler()),
                                      ("m", LogisticRegression(max_iter=2000))]),
                            X, y, cv=cv).mean()
    boyitilgan = cross_val_score(Pipeline([("sc", StandardScaler()),
                                           ("m", LogisticRegression(max_iter=2000))]),
                                 X2, y, cv=cv).mean()
    print(f"  LogReg (x1, x2):            {oddiy:.4f}")
    print(f"  LogReg (+ kvadratik hadlar): {boyitilgan:.4f}")
    print("  ⭐ Chegara shakli algoritmdan ham, belgilardan ham keladi 13.5-bob")


if __name__ == "__main__":
    main()

=== 1. CV aniqligi (uch xil chegara) ===
  malumot        LogReg      LDA      QDA  GaussNB  KNN(15)  SVM-lin  SVM-rbf
  chiziqli       0.9080   0.9073   0.9080   0.8940   0.9000   0.9053   0.9060
  halqa          0.4867   0.4867   0.9540   0.9553   0.9633   0.5873   0.9667
  xor            0.5340   0.5333   0.9047   0.5007   0.9040   0.5660   0.8993

=== 2. Har ma'lumot uchun eng yaxshi ===
  chiziqli   : eng yaxshi LogReg 0.9080-bob, eng yomon GaussNB 0.8940-bob
  halqa      : eng yaxshi SVM-rbf 0.9667-bob, eng yomon LogReg 0.4867-bob
  xor        : eng yaxshi QDA 0.9047-bob, eng yomon GaussNB 0.5007-bob

=== 3. Chiziqli modellar nochiziqli ma'lumotda ===
  halqa  : chiziqli o'rtacha 0.5202, nochiziqli o'rtacha 0.9613
  xor    : chiziqli o'rtacha 0.5444, nochiziqli o'rtacha 0.9027

=== 4. Nochiziqli belgilar chiziqli modelni tiklaydi ===
  LogReg (x1, x2):            0.4867
  LogReg (+ kvadratik hadlar): 0.9693
  ⭐ Chegara shakli algoritmdan ham, belgilardan ham keladi (13.5)

"""Kam va ko'p ma'lumotda qaysi model yutadi (real numpy/sklearn)."""

import numpy as np
from sklearn.discriminant_analysis import LinearDiscriminantAnalysis
from sklearn.linear_model import LogisticRegression
from sklearn.model_selection import train_test_split
from sklearn.naive_bayes import GaussianNB
from sklearn.neighbors import KNeighborsClassifier
from sklearn.pipeline import Pipeline
from sklearn.preprocessing import StandardScaler
from sklearn.svm import SVC


def yarat(n: int, seed: int, p: int = 10):
    rng = np.random.default_rng(seed)
    y = rng.integers(0, 2, n)
    markaz = np.zeros(p)
    markaz[:5] = [1.0, -0.8, 0.9, -0.6, 0.7]
    X = rng.normal(0, 1, (n, p)) + y[:, None] * markaz
    # yengil nochiziqlik
    X[:, 0] += 0.5 * X[:, 1] ** 2 * (y == 1)
    return X, y


def main() -> None:
    Xte, yte = yarat(8000, seed=999)
    sc = lambda m: Pipeline([("sc", StandardScaler()), ("m", m)])

    print("=== 1. O'quv hajmi bo'yicha test aniqligi ===")
    nomlar = ["GaussNB", "LDA", "LogReg", "KNN(15)", "SVM-rbf"]
    print(f"  {'n':>7} " + "".join(f"{k:>10}" for k in nomlar))
    tarix = {k: [] for k in nomlar}
    hajmlar = [40, 100, 300, 1000, 4000]
    for n in hajmlar:
        Xtr, ytr = yarat(n, seed=n)
        modellar = {
            "GaussNB": GaussianNB(),
            "LDA": LinearDiscriminantAnalysis(solver="lsqr", shrinkage="auto"),
            "LogReg": sc(LogisticRegression(max_iter=3000)),
            "KNN(15)": sc(KNeighborsClassifier(15)),
            "SVM-rbf": sc(SVC(C=10.0, gamma="scale")),
        }
        ballar = []
        for nom, m in modellar.items():
            m.fit(Xtr, ytr)
            b = (m.predict(Xte) == yte).mean()
            tarix[nom].append(b)
            ballar.append(b)
        print(f"  {n:>7} " + "".join(f"{b:>10.4f}" for b in ballar))

    print("\n=== 2. Kim qayerda yutadi ===")
    for i, n in enumerate(hajmlar):
        eng = max(nomlar, key=lambda k: tarix[k][i])
        print(f"  n = {n:>5}: eng yaxshi {eng} ({tarix[eng][i]:.4f})")

    print("\n=== 3. Yaxshilanish sur'ati (40 dan 4000 gacha) ===")
    for nom in nomlar:
        print(f"  {nom:<9}: {tarix[nom][0]:.4f} → {tarix[nom][-1]:.4f} "
              f"(+{tarix[nom][-1] - tarix[nom][0]:.4f})")

    print("\n=== 4. Xulosa ===")
    print("  kam ma'lumot: taxminli modellar (NB, LDA) ustun")
    print("  ko'p ma'lumot: moslashuvchan modellar (SVM-rbf, KNN) ularni quvib yetadi")
    print("  ⭐ O'quv egri chizig'i modelni almashtirish vaqtini ko'rsatadi")


if __name__ == "__main__":
    main()

=== 1. O'quv hajmi bo'yicha test aniqligi ===
        n    GaussNB       LDA    LogReg   KNN(15)   SVM-rbf
       40     0.7890    0.8203    0.7967    0.7964    0.7560
      100     0.8083    0.8226    0.8176    0.7836    0.7090
      300     0.8442    0.8456    0.8444    0.8125    0.7859
     1000     0.8451    0.8511    0.8528    0.8276    0.8153
     4000     0.8462    0.8474    0.8509    0.8259    0.8296

=== 2. Kim qayerda yutadi ===
  n =    40: eng yaxshi LDA 0.8203-bob
  n =   100: eng yaxshi LDA 0.8226-bob
  n =   300: eng yaxshi LDA 0.8456-bob
  n =  1000: eng yaxshi LogReg 0.8528-bob
  n =  4000: eng yaxshi LogReg 0.8509-bob

=== 3. Yaxshilanish sur'ati (40 dan 4000 gacha) ===
  GaussNB  : 0.7890 → 0.8462 (+0.0572)
  LDA      : 0.8203 → 0.8474 (+0.0271)
  LogReg   : 0.7967 → 0.8509 (+0.0541)
  KNN(15)  : 0.7964 → 0.8259 (+0.0295)
  SVM-rbf  : 0.7560 → 0.8296 (+0.0736)

=== 4. Xulosa ===
  kam ma'lumot: taxminli modellar (NB, LDA) ustun
  ko'p ma'lumot: moslashuvchan modellar (SVM-rbf, KNN) ularni quvib yetadi
  ⭐ O'quv egri chizig'i modelni almashtirish vaqtini ko'rsatadi

"""Yorliq shovqini va foydasiz belgilar ta'siri (real numpy/sklearn)."""

import numpy as np
from sklearn.discriminant_analysis import LinearDiscriminantAnalysis
from sklearn.linear_model import LogisticRegression
from sklearn.model_selection import StratifiedKFold, cross_val_score
from sklearn.naive_bayes import GaussianNB
from sklearn.neighbors import KNeighborsClassifier
from sklearn.pipeline import Pipeline
from sklearn.preprocessing import StandardScaler
from sklearn.svm import SVC


def yarat(n: int, p: int, shovqin: float, seed: int = 5):
    rng = np.random.default_rng(seed)
    y = rng.integers(0, 2, n)
    X = rng.normal(0, 1, (n, p))
    X[:, 0] += y * 1.4
    X[:, 1] -= y * 1.1
    alm = rng.random(n) < shovqin
    y[alm] = 1 - y[alm]
    return X, y


def modellar() -> dict:
    sc = lambda m: Pipeline([("sc", StandardScaler()), ("m", m)])
    return {
        "GaussNB": GaussianNB(),
        "LDA": LinearDiscriminantAnalysis(solver="lsqr", shrinkage="auto"),
        "LogReg": sc(LogisticRegression(max_iter=3000)),
        "KNN(1)": sc(KNeighborsClassifier(1)),
        "KNN(41)": sc(KNeighborsClassifier(41)),
        "SVM-rbf": sc(SVC(C=1.0, gamma="scale")),
    }


def main() -> None:
    cv = StratifiedKFold(5, shuffle=True, random_state=0)
    nomlar = list(modellar())

    print("=== 1. Yorliq shovqini (n=2000, p=6) ===")
    print(f"  {'shovqin':>8} " + "".join(f"{k:>9}" for k in nomlar))
    for sh in [0.0, 0.10, 0.25]:
        X, y = yarat(2000, 6, sh)
        ballar = [cross_val_score(m, X, y, cv=cv).mean()
                  for m in modellar().values()]
        print(f"  {sh:>8.0%} " + "".join(f"{b:>9.4f}" for b in ballar))

    print("\n=== 2. Foydasiz belgilar (n=2000, shovqin 0) ===")
    print(f"  {'p':>8} " + "".join(f"{k:>9}" for k in nomlar))
    for p in [2, 10, 50, 200]:
        X, y = yarat(2000, p, 0.0)
        ballar = [cross_val_score(m, X, y, cv=cv).mean()
                  for m in modellar().values()]
        print(f"  {p:>8} " + "".join(f"{b:>9.4f}" for b in ballar))

    print("\n=== 3. Kim eng ko'p yo'qotdi (p: 2 → 200) ===")
    X2, y2 = yarat(2000, 2, 0.0)
    X200, y200 = yarat(2000, 200, 0.0)
    for nom in nomlar:
        a = cross_val_score(modellar()[nom], X2, y2, cv=cv).mean()
        b = cross_val_score(modellar()[nom], X200, y200, cv=cv).mean()
        print(f"  {nom:<9}: {a:.4f} → {b:.4f} ({b - a:+.4f})")

    print("\n=== 4. Xulosa ===")
    print("  shovqin → KNN(1) keskin yomonlashadi, katta k va chiziqli barqaror")
    print("  foydasiz belgilar → KNN eng ko'p yo'qotadi (o'lcham la'nati)")
    print("  ⭐ Ma'lumot xossasi algoritm tanlovini belgilaydi")


if __name__ == "__main__":
    main()

=== 1. Yorliq shovqini (n=2000, p=6) ===
   shovqin   GaussNB      LDA   LogReg   KNN(1)  KNN(41)  SVM-rbf
        0%    0.8060   0.8035   0.8070   0.7245   0.8000   0.8045
       10%    0.7470   0.7435   0.7410   0.6565   0.7360   0.7400
       25%    0.6410   0.6445   0.6465   0.5395   0.6365   0.6515

=== 2. Foydasiz belgilar (n=2000, shovqin 0) ===
         p   GaussNB      LDA   LogReg   KNN(1)  KNN(41)  SVM-rbf
         2    0.8150   0.8140   0.8115   0.7425   0.8135   0.8135
        10    0.8250   0.8235   0.8225   0.7020   0.8055   0.8045
        50    0.8210   0.8290   0.8250   0.6165   0.7600   0.8145
       200    0.7905   0.7950   0.7915   0.5550   0.6605   0.7920

=== 3. Kim eng ko'p yo'qotdi (p: 2 → 200) ===
  GaussNB  : 0.8150 → 0.7905 (-0.0245)
  LDA      : 0.8140 → 0.7950 (-0.0190)
  LogReg   : 0.8115 → 0.7915 (-0.0200)
  KNN(1)   : 0.7425 → 0.5550 (-0.1875)
  KNN(41)  : 0.8135 → 0.6605 (-0.1530)
  SVM-rbf  : 0.8135 → 0.7920 (-0.0215)

=== 4. Xulosa ===
  shovqin → KNN(1) keskin yomonlashadi, katta k va chiziqli barqaror
  foydasiz belgilar → KNN eng ko'p yo'qotadi (o'lcham la'nati)
  ⭐ Ma'lumot xossasi algoritm tanlovini belgilaydi

"""Sozlangan nomzodlar, noaniqlik va vaqt (real numpy/sklearn)."""

import numpy as np
from sklearn.datasets import load_breast_cancer
from sklearn.discriminant_analysis import LinearDiscriminantAnalysis
from sklearn.linear_model import LogisticRegression
from sklearn.model_selection import GridSearchCV, StratifiedKFold, cross_val_score
from sklearn.naive_bayes import GaussianNB
from sklearn.neighbors import KNeighborsClassifier
from sklearn.pipeline import Pipeline
from sklearn.preprocessing import StandardScaler
from sklearn.svm import SVC


def main() -> None:
    X, y = load_breast_cancer(return_X_y=True)
    cv = StratifiedKFold(5, shuffle=True, random_state=0)
    sc = lambda m: Pipeline([("sc", StandardScaler()), ("m", m)])

    print("=== 1. Ma'lumot ===")
    print(f"  {X.shape[0]} namuna, {X.shape[1]} belgi, "
          f"musbat sinf ulushi {y.mean():.1%}")

    print("\n=== 2. Sozlanmagan nomzodlar (CV F1) ===")
    oddiy = {
        "GaussNB": GaussianNB(),
        "LDA": LinearDiscriminantAnalysis(solver="lsqr", shrinkage="auto"),
        "LogReg": sc(LogisticRegression(max_iter=5000)),
        "KNN": sc(KNeighborsClassifier()),
        "SVM-rbf": sc(SVC()),
    }
    for nom, m in oddiy.items():
        b = cross_val_score(m, X, y, cv=cv, scoring="f1")
        print(f"  {nom:<9}: {b.mean():.4f} ± {b.std():.4f}")

    print("\n=== 3. Sozlangan nomzodlar ===")
    setkalar = {
        "LogReg": (sc(LogisticRegression(max_iter=5000)),
                   {"m__C": np.logspace(-3, 3, 7)}),
        "KNN": (sc(KNeighborsClassifier()),
                {"m__n_neighbors": [3, 5, 9, 15, 25],
                 "m__weights": ["uniform", "distance"]}),
        "SVM-rbf": (sc(SVC()),
                    {"m__C": np.logspace(-1, 3, 5),
                     "m__gamma": np.logspace(-4, 0, 5)}),
    }
    sozlangan = {}
    for nom, (model, setka) in setkalar.items():
        q = GridSearchCV(model, setka, cv=cv, scoring="f1").fit(X, y)
        sozlangan[nom] = q.best_score_
        konfiguratsiya = len(q.cv_results_["params"])
        print(f"  {nom:<9}: {q.best_score_:.4f}, parametrlar "
              f"{ {k.split('__')[1]: v for k, v in q.best_params_.items()} }, "
              f"{konfiguratsiya} konfiguratsiya")

    print("\n=== 4. Sifat va model hajmi ===")
    print(f"  {'model':<9} {'CV F1':>8} {'model hajmi':>22}")
    yakuniy = {
        "GaussNB": GaussianNB(),
        "LDA": LinearDiscriminantAnalysis(solver="lsqr", shrinkage="auto"),
        "LogReg": sc(LogisticRegression(C=1.0, max_iter=5000)),
        "KNN": sc(KNeighborsClassifier(9, weights="distance")),
        "SVM-rbf": sc(SVC(C=10.0, gamma=0.01)),
    }
    for nom, m in yakuniy.items():
        b = cross_val_score(m, X, y, cv=cv, scoring="f1").mean()
        m.fit(X, y)
        if nom == "KNN":
            olcham = f"{X.nbytes // 1024} KB ma'lumot"
        elif nom == "SVM-rbf":
            olcham = f"{len(m.named_steps['m'].support_)} tayanch vektor"
        elif nom == "GaussNB":
            olcham = f"{m.theta_.size * 2} parametr"
        elif nom == "LDA":
            olcham = f"{m.coef_.size} koeffitsiyent"
        else:
            olcham = f"{m.named_steps['m'].coef_.size} koeffitsiyent"
        print(f"  {nom:<9} {b:>8.4f} {olcham:>22}")
    print("  ⭐ Sozlashdan keyin farq kichrayadi — narx va talqin hal qiladi")


if __name__ == "__main__":
    main()

=== 1. Ma'lumot ===
  569 namuna, 30 belgi, musbat sinf ulushi 62.7%

=== 2. Sozlanmagan nomzodlar (CV F1) ===
  GaussNB  : 0.9522 ± 0.0148
  LDA      : 0.9674 ± 0.0075
  LogReg   : 0.9834 ± 0.0112
  KNN      : 0.9727 ± 0.0164
  SVM-rbf  : 0.9819 ± 0.0056

=== 3. Sozlangan nomzodlar ===
  LogReg   : 0.9834, parametrlar {'C': np.float64(1.0)}, 7 konfiguratsiya
  KNN      : 0.9727, parametrlar {'n_neighbors': 5, 'weights': 'uniform'}, 10 konfiguratsiya
  SVM-rbf  : 0.9848, parametrlar {'C': np.float64(100.0), 'gamma': np.float64(0.001)}, 25 konfiguratsiya

=== 4. Sifat va model hajmi ===
  model        CV F1            model hajmi
  GaussNB     0.9522           120 parametr
  LDA         0.9674       30 koeffitsiyent
  LogReg      0.9834       30 koeffitsiyent
  KNN         0.9726        133 KB ma'lumot
  SVM-rbf     0.9833      64 tayanch vektor
  ⭐ Sozlashdan keyin farq kichrayadi — narx va talqin hal qiladi

for m in [LogReg(), SVC(), KNN()]: cross_val_score(m, X, y)       # ⚠️
GridSearchCV(m, setka, cv=cv)   # har biri uchun                  # ✅

cross_val_score(m1, X, y, cv=5); cross_val_score(m2, X, y, cv=3)  # ⚠️
cv = StratifiedKFold(5, shuffle=True, random_state=0)             # ✅

# SVM uchun masshtablab, KNN uchun unutish                        # ⚠️
# har biri uchun pipeline ichida                                  # ✅

print(f"{b.mean():.4f}")                                          # ⚠️
print(f"{b.mean():.4f} ± {b.std():.4f}")                          # ✅

# "model yomon — boshqasini sinaymiz"                             # ⚠️
learning_curve(model, X, y, cv=5)   # ma'lumot yetarlimi?         # ✅

# eng yuqori F1 li modelni tanlash                                # ⚠️
# bashorat vaqti va xotira talabini ham o'lchang                  # ✅

# SVM tanlab, keyin ehtimol kerakligini bilish                    # ⚠️
# talablarni boshida yozib qo'ying                                # ✅

1.  # induktiv siljish nima?
2.  # KNN chegarasi qanday?
3.  # SVM-rbf chegarasi?
4.  # daraxt chegarasi?
5.  # kam ma'lumotda qaysi modellar?
6.  # p > n da?
7.  # shovqin ko'p bo'lsa?
8.  # o'quv egri chizig'i nima ko'rsatadi?
9.  # KNN bashorat narxi?
10. # kernel SVM o'qitish narxi?
11. # ehtimol kerak bo'lsa?
12. # yakuniy qaror qanday?

1.  for m in [SVC(), KNeighborsClassifier()]: cross_val_score(m, X, y)

2.  cross_val_score(m1, X, y, cv=5); cross_val_score(m2, X, y, cv=10)

3.  print(f"SVM {b1:.4f} vs LogReg {b2:.4f}")   # SD yo'q

4.  # eng yuqori F1 li modelni ishlab chiqarishga

5.  # "model yomon" — ma'lumot hajmi tekshirilmagan