14.1-dars: Klassifikatsiya vazifasi va qaror chegarasi

BINAR         — ikki sinf (spam / spam emas)
KO'P SINFLI   — bir nechta, lekin BITTA yorliq (raqam: 0..9)
KO'P YORLIQLI — bir vaqtda bir nechta yorliq (maqola: "siyosat" + "iqtisod")
TARTIBLI      — sinflar tartiblangan (past < o'rta < yuqori)

sklearn:
  ko'p sinfli — ko'pchilik algoritmlar o'zi qo'llab-quvvatlaydi
  ko'p yorliqli — MultiOutputClassifier yoki har yorliqqa alohida model
  tartibli — maxsus yondashuv kerak (ketma-ket binar modellar)

Qaror chegarasi — belgilar fazosida sinflarni ajratuvchi sirt

CHIZIQLI:    logistik regressiya, chiziqli SVM, LDA, Naive Bayes (ba'zi holatda)
NOCHIZIQLI:  kernel SVM, KNN, daraxtlar, neyron tarmoqlar

Chiziqli chegara: w·x + b = 0  (to'g'ri chiziq, tekislik, giperslip)

Muhim: chiziqli model NOCHIZIQLI belgilar bilan nochiziqli chegara bera oladi 13.5-bob
  → x1^2, x1·x2 qo'shsangiz, chegara egri bo'ladi

DISKRIMINATIV — to'g'ridan-to'g'ri P(y | x) ni modellaydi
  logistik regressiya, SVM, daraxtlar, neyron tarmoqlar
  + ko'pincha aniqroq; - ma'lumot generatsiya qila olmaydi

GENERATIV — P(x | y) va P(y) ni modellab, Bayes bilan P(y | x) ni oladi
  Naive Bayes, LDA/QDA, Gaussian aralashmalari
  + kam ma'lumotda yaxshi, yetishmovchilikka chidamli, tez
  - taxminlari kuchli (mustaqillik, normallik)

Bayes: P(y | x) = P(x | y) · P(y) / P(x)        (9-qism)

Agar haqiqiy taqsimotlarni BILSAK, eng yaxshi qoida:
  y_bash = argmax_k P(y = k | x)

Bu — BAYES OPTIMAL klassifikator; uning xatosi — BAYES XATOSI
  → hech qanday model undan yaxshi bo'la olmaydi (nazariy chegara)

Amalda: taqsimotlar noma'lum, shuning uchun uni faqat sun'iy ma'lumotda hisoblash mumkin
  lekin tushuncha muhim: 100% aniqlik odatda IMKONSIZ (sinflar ustma-ust tushadi)

ALGORITM          CHEGARA        KUCHI                    ZAIFLIGI
Logistik regr.    chiziqli       tez, kalibrlangan 13.10-bob nochiziqlikni ko'rmaydi
KNN               mahalliy       taxminsiz, oddiy          sekin, o'lchov la'nati
Naive Bayes       chiziqli*      juda tez, matn uchun      mustaqillik taxmini
LDA / QDA         chiziqli/kvadr kam ma'lumotda yaxshi     normallik taxmini
SVM (chiziqli)    chiziqli       yuqori o'lchamda kuchli   ehtimol bermaydi
SVM (kernel)      nochiziqli     murakkab shakllar         sekin, sozlash qiyin
Daraxt/ansambl    to'g'ri burch. nochiziqlik, o'zaro ta'sir 17-qism
Neyron tarmoq     ixtiyoriy      murakkab ma'lumot         ko'p ma'lumot kerak

1. Baza: DummyClassifier va logistik regressiya (12.6, 13.10)
2. Ma'lumot turi:
     jadval, kam belgi     → LogReg, daraxtlar, SVM
     matn                  → Naive Bayes, chiziqli SVM, LogReg (TF-IDF bilan)
     rasm/ovoz             → neyron tarmoqlar (24-25 qismlar)
     juda kam namuna       → generativ (NB, LDA), regularizatsiyalangan LogReg
3. Talab: ehtimol kerakmi? talqin kerakmi? tezlik kerakmi?
4. CV bilan solishtirish (bir xil bo'linish, oldindan tanlangan metrika — 12.7)

import numpy as np
from sklearn.dummy import DummyClassifier
from sklearn.linear_model import LogisticRegression
from sklearn.model_selection import StratifiedKFold, cross_val_score
from sklearn.pipeline import Pipeline
from sklearn.preprocessing import StandardScaler

cv = StratifiedKFold(5, shuffle=True, random_state=0)
baza = DummyClassifier(strategy="most_frequent")
chiziqli = Pipeline([("sc", StandardScaler()),
                     ("m", LogisticRegression(max_iter=2000))])
cross_val_score(chiziqli, X, y, cv=cv, scoring="average_precision")

# qaror chegarasini ko'rish uchun setka
xx, yy = np.meshgrid(np.linspace(x1min, x1max, 200), np.linspace(x2min, x2max, 200))
Z = model.predict(np.c_[xx.ravel(), yy.ravel()]).reshape(xx.shape)
QOIDA: baza qo'y · chegara shaklini o'yla · masshtabla · CV bilan tanla

Turlari: binar / ko'p sinfli / ko'p yorliqli / tartibli
Chegara shakli — algoritmlar orasidagi asosiy farq
Diskriminativ P(y|x) · Generativ P(x|y)P(y)
Bayes xatosi — nazariy chegara; 100% aniqlik odatda imkonsiz

"""Algoritmlar qanday shakldagi chegara chizadi (real numpy/sklearn)."""

import numpy as np
from sklearn.discriminant_analysis import QuadraticDiscriminantAnalysis
from sklearn.linear_model import LogisticRegression
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 = 600):
    rng = np.random.default_rng(seed)
    if tur == "chiziqli":
        X = rng.normal(0, 1, (n, 2))
        y = (1.2 * X[:, 0] + 0.8 * X[:, 1] + rng.normal(0, 0.5, n) > 0).astype(int)
    elif tur == "doira":
        X = rng.normal(0, 1, (n, 2))
        r = np.hypot(X[:, 0], X[:, 1])
        y = (r + rng.normal(0, 0.15, n) > 1.1).astype(int)
    else:                                    # "xor"
        X = rng.uniform(-2, 2, (n, 2))
        y = ((X[:, 0] > 0) ^ (X[:, 1] > 0)).astype(int)
        almash = rng.random(n) < 0.05
        y[almash] = 1 - y[almash]
    return X, y


def chegara_sifati(model, X, y) -> float:
    """O'quv ma'lumotida qaror chegarasining aniqligi."""
    return float((model.fit(X, y).predict(X) == y).mean())


def main() -> None:
    modellar = {
        "LogReg": Pipeline([("sc", StandardScaler()),
                            ("m", LogisticRegression(max_iter=2000))]),
        "KNN(15)": Pipeline([("sc", StandardScaler()),
                             ("m", KNeighborsClassifier(15))]),
        "QDA": QuadraticDiscriminantAnalysis(),
        "SVM-rbf": Pipeline([("sc", StandardScaler()), ("m", SVC(C=1.0))]),
    }

    print("=== 1. Uch xil ma'lumot ===")
    for tur in ["chiziqli", "doira", "xor"]:
        X, y = yarat(tur)
        print(f"  {tur:<9}: {len(X)} nuqta, musbat sinf {y.mean():.1%}")

    print("\n=== 2. O'quv aniqligi (chegara shakli mosligi) ===")
    sarlavha = "ma'lumot"
    print(f"  {sarlavha:<10} " + " ".join(f"{k:>9}" for k in modellar))
    for tur in ["chiziqli", "doira", "xor"]:
        X, y = yarat(tur)
        ballar = [chegara_sifati(m, X, y) for m in modellar.values()]
        print(f"  {tur:<10} " + " ".join(f"{b:>9.3f}" for b in ballar))

    print("\n=== 3. Nega farq bor ===")
    print("  chiziqli ma'lumot — hamma model yaxshi")
    print("  doira — chiziqli chegara ishlamaydi (QDA, KNN, SVM-rbf mos)")
    print("  XOR — kvadratik ham yetarli emas, mahalliy yoki kernel kerak")

    print("\n=== 4. Chiziqli model + nochiziqli belgilar ===")
    X, y = yarat("doira")
    X2 = np.column_stack([X, X[:, 0] ** 2, X[:, 1] ** 2])
    m = Pipeline([("sc", StandardScaler()),
                  ("m", LogisticRegression(max_iter=2000))]).fit(X2, y)
    print(f"  LogReg (x1, x2):           {chegara_sifati(modellar['LogReg'], X, y):.3f}")
    print(f"  LogReg (+ x1^2, x2^2):     {(m.predict(X2) == y).mean():.3f}")
    print("  ⭐ Chegara shakli algoritmdan ham, belgilardan ham keladi 13.5-bob")


if __name__ == "__main__":
    main()

=== 1. Uch xil ma'lumot ===
  chiziqli : 600 nuqta, musbat sinf 50.2%
  doira    : 600 nuqta, musbat sinf 57.0%
  xor      : 600 nuqta, musbat sinf 48.3%

=== 2. O'quv aniqligi (chegara shakli mosligi) ===
  ma'lumot      LogReg   KNN(15)       QDA   SVM-rbf
  chiziqli       0.897     0.898     0.900     0.905
  doira          0.570     0.918     0.913     0.922
  xor            0.527     0.915     0.900     0.890

=== 3. Nega farq bor ===
  chiziqli ma'lumot — hamma model yaxshi
  doira — chiziqli chegara ishlamaydi (QDA, KNN, SVM-rbf mos)
  XOR — kvadratik ham yetarli emas, mahalliy yoki kernel kerak

=== 4. Chiziqli model + nochiziqli belgilar ===
  LogReg (x1, x2):           0.570
  LogReg (+ x1^2, x2^2):     0.920
  ⭐ Chegara shakli algoritmdan ham, belgilardan ham keladi (13.5)

"""Hech qanday model yengolmaydigan chegara (real numpy/sklearn)."""

import numpy as np
from sklearn.ensemble import RandomForestClassifier
from sklearn.linear_model import LogisticRegression
from sklearn.model_selection import train_test_split
from sklearn.neighbors import KNeighborsClassifier
from sklearn.pipeline import Pipeline
from sklearn.preprocessing import StandardScaler
from sklearn.svm import SVC


def yarat(ajralish: float, seed: int = 7, n: int = 4000):
    """Ikki normal sinf; 'ajralish' — markazlar orasidagi masofa."""
    rng = np.random.default_rng(seed)
    y = rng.integers(0, 2, n)
    markaz = np.array([[0.0, 0.0], [ajralish, 0.0]])
    X = markaz[y] + rng.normal(0, 1, (n, 2))
    return X, y


def bayes_aniqlik(ajralish: float, X, y) -> float:
    """Haqiqiy taqsimotlarni bilgan holda optimal qaror."""
    # P(x|0) va P(x|1) — teng dispersiyali normal; chegara o'rtada
    d0 = np.sum((X - np.array([0.0, 0.0])) ** 2, axis=1)
    d1 = np.sum((X - np.array([ajralish, 0.0])) ** 2, axis=1)
    return float(((d1 < d0).astype(int) == y).mean())


def main() -> None:
    print("=== 1. Sinflar qanchalik ustma-ust ===")
    for a in [0.5, 1.5, 3.0, 5.0]:
        X, y = yarat(a)
        print(f"  ajralish {a:.1f}: Bayes aniqligi = {bayes_aniqlik(a, X, y):.4f}")

    print("\n=== 2. Modellar Bayes chegarasiga yaqinlashadi ===")
    modellar = {
        "LogReg": Pipeline([("sc", StandardScaler()),
                            ("m", LogisticRegression(max_iter=2000))]),
        "KNN(25)": Pipeline([("sc", StandardScaler()),
                             ("m", KNeighborsClassifier(25))]),
        "SVM-rbf": Pipeline([("sc", StandardScaler()), ("m", SVC(C=1.0))]),
        "O'rmon": RandomForestClassifier(n_estimators=200, min_samples_leaf=5,
                                         random_state=0),
    }
    for a in [1.5, 3.0]:
        X, y = yarat(a)
        Xtr, Xte, ytr, yte = train_test_split(X, y, test_size=0.3, random_state=0,
                                              stratify=y)
        print(f"\n  ajralish {a:.1f} (Bayes {bayes_aniqlik(a, Xte, yte):.4f}):")
        for nom, m in modellar.items():
            m.fit(Xtr, ytr)
            print(f"    {nom:<9}: test aniqligi {(m.predict(Xte) == yte).mean():.4f}")

    print("\n=== 3. Ko'proq ma'lumot yordam beradimi ===")
    # test to'plami QAT'IY va katta — shovqin taqqoslashni buzmasligi uchun
    Xte, yte = yarat(1.5, seed=999, n=40_000)
    print(f"  qat'iy test to'plami: {len(Xte)} namuna, "
          f"Bayes aniqligi {bayes_aniqlik(1.5, Xte, yte):.4f}")
    for n in [200, 800, 3000, 12_000]:
        Xtr, ytr = yarat(1.5, seed=n, n=n)
        m = Pipeline([("sc", StandardScaler()),
                      ("m", LogisticRegression(max_iter=2000))]).fit(Xtr, ytr)
        print(f"  o'quv n = {n:>6}: test aniqligi {(m.predict(Xte) == yte).mean():.4f}")

    print("\n=== 4. Xulosa ===")
    print("  ma'lumot ko'paysa model Bayes chegarasiga yaqinlashadi, lekin o'tolmaydi")
    print("  ⭐ 100% aniqlik talab qilish — ko'pincha noto'g'ri qo'yilgan vazifa")


if __name__ == "__main__":
    main()

=== 1. Sinflar qanchalik ustma-ust ===
  ajralish 0.5: Bayes aniqligi = 0.6025
  ajralish 1.5: Bayes aniqligi = 0.7718
  ajralish 3.0: Bayes aniqligi = 0.9295
  ajralish 5.0: Bayes aniqligi = 0.9930

=== 2. Modellar Bayes chegarasiga yaqinlashadi ===

  ajralish 1.5 (Bayes 0.7700):
    LogReg   : test aniqligi 0.7700
    KNN(25)  : test aniqligi 0.7558
    SVM-rbf  : test aniqligi 0.7692
    O'rmon   : test aniqligi 0.7642

  ajralish 3.0 (Bayes 0.9292):
    LogReg   : test aniqligi 0.9275
    KNN(25)  : test aniqligi 0.9208
    SVM-rbf  : test aniqligi 0.9250
    O'rmon   : test aniqligi 0.9233

=== 3. Ko'proq ma'lumot yordam beradimi ===
  qat'iy test to'plami: 40000 namuna, Bayes aniqligi 0.7739
  o'quv n =    200: test aniqligi 0.7658
  o'quv n =    800: test aniqligi 0.7724
  o'quv n =   3000: test aniqligi 0.7743
  o'quv n =  12000: test aniqligi 0.7730

=== 4. Xulosa ===
  ma'lumot ko'paysa model Bayes chegarasiga yaqinlashadi, lekin o'tolmaydi
  ⭐ 100% aniqlik talab qilish — ko'pincha noto'g'ri qo'yilgan vazifa

"""Bir yorliq va bir nechta yorliq (real numpy/sklearn)."""

import numpy as np
from sklearn.linear_model import LogisticRegression
from sklearn.metrics import accuracy_score, f1_score, hamming_loss
from sklearn.model_selection import train_test_split
from sklearn.multioutput import MultiOutputClassifier
from sklearn.pipeline import Pipeline
from sklearn.preprocessing import StandardScaler


def yarat(seed: int = 11, n: int = 4000):
    """Maqola: 3 mavzu bo'lishi mumkin (ko'p yorliqli)."""
    rng = np.random.default_rng(seed)
    X = rng.normal(0, 1, (n, 8))
    w = rng.normal(0, 1, (8, 3))
    z = X @ w + rng.normal(0, 0.8, (n, 3))
    Y = (z > 0.6).astype(int)                      # har mavzu mustaqil
    return X, Y


def main() -> None:
    X, Y = yarat()
    Xtr, Xte, Ytr, Yte = train_test_split(X, Y, test_size=0.3, random_state=0)

    print("=== 1. Ma'lumot ===")
    print(f"  {len(X)} maqola, 3 ta mavzu yorlig'i")
    sanoq, soni = np.unique(Y.sum(axis=1), return_counts=True)
    print(f"  har maqoladagi yorliqlar soni: "
          f"{ {int(k): int(v) for k, v in zip(sanoq, soni)} }")
    print(f"  mavzu ulushlari: {Y.mean(axis=0).round(3)}")

    print("\n=== 2. XATO: ko'p sinfli deb qarash ===")
    # har maqolaga faqat BITTA yorliq beramiz (birinchisini)
    y_bitta = np.array([np.flatnonzero(r)[0] if r.any() else 3 for r in Ytr])
    y_bitta_te = np.array([np.flatnonzero(r)[0] if r.any() else 3 for r in Yte])
    m = Pipeline([("sc", StandardScaler()),
                  ("m", LogisticRegression(max_iter=2000))]).fit(Xtr, y_bitta)
    pred = m.predict(Xte)
    print(f"  aniqlik (bitta yorliq) = {accuracy_score(y_bitta_te, pred):.3f}")
    yoqotilgan = (Ytr.sum(axis=1) > 1).mean()
    print(f"  lekin {yoqotilgan:.1%} maqolada bir nechta mavzu bor — "
          f"ular yo'qotildi")

    print("\n=== 3. TO'G'RI: ko'p yorliqli model ===")
    ko_p = MultiOutputClassifier(
        Pipeline([("sc", StandardScaler()),
                  ("m", LogisticRegression(max_iter=2000))])).fit(Xtr, Ytr)
    P = ko_p.predict(Xte)
    print(f"  aniq moslik (barcha 3 yorliq to'g'ri) = "
          f"{(P == Yte).all(axis=1).mean():.3f}")
    print(f"  Hamming loss (yorliq darajasida xato) = "
          f"{hamming_loss(Yte, P):.4f}")
    print(f"  F1 micro = {f1_score(Yte, P, average='micro'):.3f}, "
          f"macro = {f1_score(Yte, P, average='macro'):.3f}")

    print("\n=== 4. Har mavzu bo'yicha ===")
    for k in range(3):
        print(f"  mavzu {k}: ulush {Yte[:, k].mean():.3f}, "
              f"F1 {f1_score(Yte[:, k], P[:, k]):.3f}")
    print("  ⭐ Vazifa turini boshida aniqlang — metrika ham shundan kelib chiqadi")


if __name__ == "__main__":
    main()

=== 1. Ma'lumot ===
  4000 maqola, 3 ta mavzu yorlig'i
  har maqoladagi yorliqlar soni: {0: 804, 1: 1656, 2: 1259, 3: 281}
  mavzu ulushlari: [0.389 0.434 0.432]

=== 2. XATO: ko'p sinfli deb qarash ===
  aniqlik (bitta yorliq) = 0.785
  lekin 39.4% maqolada bir nechta mavzu bor — ular yo'qotildi

=== 3. TO'G'RI: ko'p yorliqli model ===
  aniq moslik (barcha 3 yorliq to'g'ri) = 0.757
  Hamming loss (yorliq darajasida xato) = 0.0914
  F1 micro = 0.889, macro = 0.888

=== 4. Har mavzu bo'yicha ===
  mavzu 0: ulush 0.382, F1 0.850
  mavzu 1: ulush 0.425, F1 0.913
  mavzu 2: ulush 0.425, F1 0.900
  ⭐ Vazifa turini boshida aniqlang — metrika ham shundan kelib chiqadi

"""Kam ma'lumotda generativ, ko'p ma'lumotda diskriminativ (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.pipeline import Pipeline
from sklearn.preprocessing import StandardScaler


def yarat(n: int, seed: int = 3, p: int = 10):
    """Taxminlarga MOS ma'lumot: teng kovariatsiyali ikki normal sinf."""
    rng = np.random.default_rng(seed)
    y = rng.integers(0, 2, n)
    markaz = np.zeros((2, p))
    markaz[1, :4] = [1.0, -0.8, 0.9, -0.6]
    X = markaz[y] + rng.normal(0, 1, (n, p))
    return X, y


def main() -> None:
    modellar = {
        "LogReg (diskr.)": Pipeline([("sc", StandardScaler()),
                                     ("m", LogisticRegression(max_iter=2000))]),
        "LDA (generativ)": LinearDiscriminantAnalysis(),
        "GaussianNB (gen.)": GaussianNB(),
    }

    print("=== 1. Ma'lumot hajmi bo'yicha aniqlik ===")
    print(f"  {'n':>7} " + " ".join(f"{k:>18}" for k in modellar))
    for n in [30, 60, 150, 600, 4000]:
        X, y = yarat(n + 3000)
        Xtr, Xte = X[:n], X[n:]
        ytr, yte = y[:n], y[n:]
        ballar = []
        for m in modellar.values():
            m.fit(Xtr, ytr)
            ballar.append((m.predict(Xte) == yte).mean())
        print(f"  {n:>7} " + " ".join(f"{b:>18.4f}" for b in ballar))

    print("\n=== 2. Taxminlar buzilganda (turli kovariatsiya) ===")
    rng = np.random.default_rng(5)
    n = 4000
    y = rng.integers(0, 2, n)
    X = np.where(y[:, None] == 0,
                 rng.normal(0, 1, (n, 2)),
                 rng.normal(0, 1, (n, 2)) @ np.array([[2.5, 1.8], [0.0, 0.6]])
                 + np.array([1.0, 0.0]))
    Xtr, Xte, ytr, yte = train_test_split(X, y, test_size=0.3, random_state=0,
                                          stratify=y)
    from sklearn.discriminant_analysis import QuadraticDiscriminantAnalysis
    for nom, m in [("LogReg", modellar["LogReg (diskr.)"]),
                   ("LDA", LinearDiscriminantAnalysis()),
                   ("QDA", QuadraticDiscriminantAnalysis()),
                   ("GaussianNB", GaussianNB())]:
        m.fit(Xtr, ytr)
        print(f"  {nom:<11}: {(m.predict(Xte) == yte).mean():.4f}")
    print("  (LDA teng kovariatsiya deb taxmin qiladi — bu yerda buzilgan)")

    print("\n=== 3. Tezlik (o'qitish vaqti tartibi) ===")
    import time
    X, y = yarat(20_000)
    for nom, m in modellar.items():
        t0 = time.perf_counter()
        m.fit(X, y)
        print(f"  {nom:<18}: {(time.perf_counter() - t0) * 1000:7.1f} ms")

    print("\n=== 4. Xulosa ===")
    print("  kam ma'lumot → generativ (taxmin qo'shimcha ma'lumot beradi)")
    print("  ko'p ma'lumot → diskriminativ (noto'g'ri taxminlardan erkin)")
    print("  ⭐ Taxminlar to'g'ri bo'lsa generativ model 'bepul' aniqlik beradi")


if __name__ == "__main__":
    main()

=== 1. Ma'lumot hajmi bo'yicha aniqlik ===
        n    LogReg (diskr.)    LDA (generativ)  GaussianNB (gen.)
       30             0.7367             0.6997             0.7287
       60             0.7847             0.7857             0.7497
      150             0.7943             0.7893             0.7843
      600             0.8103             0.8090             0.8070
     4000             0.8137             0.8130             0.8107

=== 2. Taxminlar buzilganda (turli kovariatsiya) ===
  LogReg     : 0.6775
  LDA        : 0.6792
  QDA        : 0.7917
  GaussianNB : 0.7208
  (LDA teng kovariatsiya deb taxmin qiladi — bu yerda buzilgan)

=== 3. Tezlik (o'qitish vaqti tartibi) ===
  LogReg (diskr.)   :    11.4 ms
  LDA (generativ)   :    13.5 ms
  GaussianNB (gen.) :     4.9 ms

=== 4. Xulosa ===
  kam ma'lumot → generativ (taxmin qo'shimcha ma'lumot beradi)
  ko'p ma'lumot → diskriminativ (noto'g'ri taxminlardan erkin)
  ⭐ Taxminlar to'g'ri bo'lsa generativ model 'bepul' aniqlik beradi

y = [labels[0] for labels in yorliqlar]                           # ⚠️
MultiOutputClassifier(LogisticRegression())                       # ✅

print("aniqlik 0.86")                                             # ⚠️
print(f"0.86 (baza {DummyClassifier().fit(X, y).score(X, y):.2f})") # ✅

KNeighborsClassifier().fit(X, y)                                  # ⚠️
Pipeline([("sc", StandardScaler()), ("m", KNeighborsClassifier())]) # ✅

LogisticRegression().fit(X, ["past", "o'rta", "yuqori"])          # ⚠️
# tartibli yondashuv yoki xato narxini hisobga olish              # ✅

model = RandomForestClassifier().fit(X, y)                        # ⚠️
# kamida chiziqli baza bilan solishtiring                         # ✅

f1_score(y, pred)                                                 # ⚠️
f1_score(y, pred, average="macro")                                # ✅

model.predict(X_te)                                               # ⚠️
(model.predict_proba(X_te)[:, 1] >= chegara).astype(int)          # ✅

1.  # klassifikatsiya turlari?
2.  # ko'p sinfli va ko'p yorliqli farqi?
3.  # qaror chegarasi nima?
4.  # chiziqli chegara tenglamasi?
5.  # chiziqli model egri chegara bera oladimi?
6.  # diskriminativ model nimani modellaydi?
7.  # generativ model?
8.  # Bayes optimal qoidasi?
9.  # Bayes xatosi nima?
10. # No Free Lunch nima?
11. # KNN uchun masshtablash shartmi?
12. # tanlov qanday qabul qilinadi?

1.  y = [teglar[0] for teglar in hammasi]   # maqolada 3 tagacha teg

2.  KNeighborsClassifier().fit(X, y)   # turli birlikli belgilar

3.  print("aniqlik 0.94")   # 94% sinf ulushi

4.  f1_score(y, pred)   # 6 sinf

5.  # "modelni 100% aniqlikka olib chiqamiz"