KNN va Naive Bayes

import pandas as pd
import numpy as np
from sklearn.model_selection import train_test_split, cross_val_score
from sklearn.neighbors import KNeighborsClassifier
from sklearn.pipeline import Pipeline
from sklearn.preprocessing import StandardScaler

df = pd.read_csv(DATA / "uy_ijara.csv")
son = ["xonalar", "maydon_m2", "qavat", "qavatlar_soni", "metro_km", "mebel"]
X, y = df[son], df["ijaraga_berildi_30k"]
X_tr, X_te, y_tr, y_te = train_test_split(X, y, test_size=0.3, random_state=42, stratify=y)

quvur = Pipeline([("sc", StandardScaler()), ("m", KNeighborsClassifier(n_neighbors=5))]).fit(X_tr, y_tr)

# bitta kvartira uchun qo'shnilarini ko'rsatamiz
sc = quvur.named_steps["sc"]
knn = quvur.named_steps["m"]
masofa, indeks = knn.kneighbors(sc.transform(X_te.iloc[[0]]), n_neighbors=5)

print("Tekshirilayotgan kvartira:")
print(X_te.iloc[0].to_string())
print(f"\nHaqiqiy javob: {y_te.iloc[0]}")
print("\nEng yaqin 5 qo'shni:")
qoshnilar = X_tr.iloc[indeks[0]].copy()
qoshnilar["javob"] = y_tr.iloc[indeks[0]].values
qoshnilar["masofa"] = masofa[0].round(3)
show(qoshnilar)
print(f"Qo'shnilar ovozi: {y_tr.iloc[indeks[0]].mean():.1%} 'ha' -> bashorat {quvur.predict(X_te.iloc[[0]])[0]}")

import time
from sklearn.linear_model import LogisticRegression

print(f"{'model':<24} {'fit vaqti':>12} {'predict vaqti':>15}")
print("-" * 54)
for nom, m in [("KNN", Pipeline([("sc", StandardScaler()), ("m", KNeighborsClassifier())])),
               ("LogisticRegression", Pipeline([("sc", StandardScaler()), ("m", LogisticRegression(max_iter=2000))]))]:
    t0 = time.perf_counter(); m.fit(X_tr, y_tr); ft = (time.perf_counter()-t0)*1000
    t0 = time.perf_counter(); m.predict(X_te); pt = (time.perf_counter()-t0)*1000
    print(f"{nom:<24} {ft:>10.2f} ms {pt:>13.2f} ms")

print(f"{'holat':<22} {'CV F1':>9} {'±':>8}")
print("-" * 40)
b1 = cross_val_score(KNeighborsClassifier(), X, y, cv=5, scoring="f1")
b2 = cross_val_score(Pipeline([("sc", StandardScaler()), ("m", KNeighborsClassifier())]),
                     X, y, cv=5, scoring="f1")
print(f"{'scaling YO`Q':<22} {b1.mean():>9.4f} {b1.std():>8.4f}")
print(f"{'scaling BOR':<22} {b2.mean():>9.4f} {b2.std():>8.4f}")
print(f"{'farq':<22} {b2.mean()-b1.mean():>+9.4f}")

from sklearn.metrics import f1_score
print(f"{'K':>5} {'train F1':>10} {'test F1':>9} {'CV F1':>9} {'izoh'}")
print("-" * 52)
for k in [1, 3, 5, 15, 50, 200]:
    q = Pipeline([("sc", StandardScaler()), ("m", KNeighborsClassifier(n_neighbors=k))]).fit(X_tr, y_tr)
    tr_f = f1_score(y_tr, q.predict(X_tr))
    te_f = f1_score(y_te, q.predict(X_te))
    cv = cross_val_score(Pipeline([("sc", StandardScaler()),
                                   ("m", KNeighborsClassifier(n_neighbors=k))]),
                         X, y, cv=5, scoring="f1").mean()
    izoh = "K=1: har nuqta o'zini topadi" if k == 1 else ("juda silliq" if k >= 200 else "")
    print(f"{k:>5} {tr_f:>10.4f} {te_f:>9.4f} {cv:>9.4f} {izoh}")

show(pd.DataFrame([
    {"K": "kichik (1-3)", "Model": "Juda moslashuvchan", "Xavf": "Overfitting, shovqinga sezgir"},
    {"K": "o'rta (5-20)", "Model": "Muvozanat", "Xavf": "Odatda eng yaxshi"},
    {"K": "katta (100+)", "Model": "Juda silliq", "Xavf": "Underfitting — hamma joyda bir xil javob"},
]))
print()
print("Qoida: K ni JUFT bo'lmagan son qiling (binary classification da teng ovoz bo'lmasligi uchun).")

print(f"{'metrika':<16} {'CV F1':>9}  izoh")
print("-" * 58)
for nom, p in [("euclidean", 2), ("manhattan", 1)]:
    b = cross_val_score(Pipeline([("sc", StandardScaler()),
                                  ("m", KNeighborsClassifier(n_neighbors=15, p=p))]),
                        X, y, cv=5, scoring="f1")
    izoh = "sqrt(sum(d^2)) — sukut" if p == 2 else "sum(|d|) — chetki qiymatga chidamli"
    print(f"{nom:<16} {b.mean():>9.4f}  {izoh}")
print()
b_w = cross_val_score(Pipeline([("sc", StandardScaler()),
                                ("m", KNeighborsClassifier(n_neighbors=15, weights="distance"))]),
                      X, y, cv=5, scoring="f1")
print(f"{'weights=distance':<16} {b_w.mean():>9.4f}  yaqin qo'shni ko'proq ovozga ega")

r = np.random.default_rng(42)
print("Tasodifiy nuqtalar orasidagi masofa — o'lchov oshganda:")
print(f"{'o`lchov':>8} {'eng yaqin':>11} {'eng uzoq':>10} {'nisbat':>8}")
print("-" * 42)
for m in [2, 10, 50, 200, 1000]:
    P = r.normal(size=(500, m))
    d = np.linalg.norm(P[1:] - P[0], axis=1)
    print(f"{m:>8} {d.min():>11.3f} {d.max():>10.3f} {d.max()/d.min():>8.2f}")

print("KNN ga shovqin ustunlari qo'shsak:")
print(f"{'qo`shilgan shovqin':>20} {'CV F1':>9}")
print("-" * 32)
for n_sh in [0, 10, 50, 200]:
    if n_sh == 0:
        Xn = X
    else:
        sh = pd.DataFrame(r.normal(size=(len(X), n_sh)),
                          columns=[f"sh_{i}" for i in range(n_sh)], index=X.index)
        Xn = pd.concat([X, sh], axis=1)
    b = cross_val_score(Pipeline([("sc", StandardScaler()),
                                  ("m", KNeighborsClassifier(n_neighbors=15))]),
                        Xn, y, cv=5, scoring="f1")
    print(f"{n_sh:>20} {b.mean():>9.4f}")

from sklearn.naive_bayes import GaussianNB, MultinomialNB, BernoulliNB

print(f"{'model':<24} {'CV F1':>9} {'fit vaqti':>12}")
print("-" * 48)
for nom, m in [("GaussianNB", GaussianNB()),
               ("KNN (K=15)", Pipeline([("sc", StandardScaler()),
                                        ("m", KNeighborsClassifier(n_neighbors=15))])),
               ("LogisticRegression", Pipeline([("sc", StandardScaler()),
                                                ("m", LogisticRegression(max_iter=2000))]))]:
    t0 = time.perf_counter()
    b = cross_val_score(m, X, y, cv=5, scoring="f1")
    dt = (time.perf_counter()-t0)*1000
    print(f"{nom:<24} {b.mean():>9.4f} {dt:>10.1f} ms")

show(pd.DataFrame([
    {"Variant": "GaussianNB", "Qanday ma'lumot": "Uzluksiz sonlar",
     "Taxmini": "Har xususiyat normal taqsimlangan", "Misol": "Bo'y, vazn, narx"},
    {"Variant": "MultinomialNB", "Qanday ma'lumot": "Sanoq (count)",
     "Taxmini": "So'z chastotalari", "Misol": "SPAM FILTRI — matn tasnifi"},
    {"Variant": "BernoulliNB", "Qanday ma'lumot": "Binary (0/1)",
     "Taxmini": "So'z bor/yo'q", "Misol": "Qisqa matn"},
]))

from sklearn.feature_extraction.text import CountVectorizer

xatlar = [
    "Tabriklaymiz siz yutdingiz pul oling hoziroq",
    "Bepul kredit tez pul oling ariza",
    "Ertaga yigilish soat 10 da bo`ladi",
    "Hisobot tayyor tekshirib bering iltimos",
    "Yutuq pul mukofot bepul oling",
    "Loyiha hujjatlari yuborildi korib chiqing",
    "Bepul bonus hoziroq oling pul",
    "Dars jadvali ozgardi xabar beraman",
]
yorliq = [1, 1, 0, 0, 1, 0, 1, 0]        # 1 = spam

vec = CountVectorizer()
Xt = vec.fit_transform(xatlar)
nb = MultinomialNB().fit(Xt, yorliq)

yangi = ["bepul pul oling hoziroq", "ertaga hisobot tayyor boladi"]
e = nb.predict_proba(vec.transform(yangi))
for matn, p in zip(yangi, e):
    print(f'  "{matn}"')
    print(f"     spam ehtimoli: {p[1]:.4f}  ->  {'SPAM' if p[1] > 0.5 else 'oddiy xat'}")

print("Smoothing ning ta'siri:")
notanish = ["mutlaqo notanish sozlar bilan yozilgan xat"]
for a in [1.0, 1e-10]:
    nb_a = MultinomialNB(alpha=a).fit(Xt, yorliq)
    p = nb_a.predict_proba(vec.transform(notanish))[0]
    print(f"  alpha={a:<8} spam ehtimoli = {p[1]:.6f}")

show(pd.DataFrame([
    {"Model": "KNN", "Qachon yaxshi": "Kichik ma'lumot, kam ustun, mahalliy naqsh",
     "Qachon yomon": "Ko'p ustun, katta ma'lumot, real vaqt",
     "Scaling": "SHART"},
    {"Model": "GaussianNB", "Qachon yaxshi": "Juda tez baza kerak bo'lsa",
     "Qachon yomon": "Xususiyatlar kuchli bog'liq bo'lsa",
     "Scaling": "Kerak emas"},
    {"Model": "MultinomialNB", "Qachon yaxshi": "MATN tasnifi, spam, kam ma'lumot",
     "Qachon yomon": "Uzluksiz sonlar",
     "Scaling": "Kerak emas"},
]))

show(pd.DataFrame([
    {"Tushuncha": "KNN g'oyasi", "Bitta jumla": "Hech narsa o'rganmaydi — qo'shnilarga qaraydi"},
    {"Tushuncha": "KNN narxi", "Bitta jumla": "fit tez, predict sekin; butun train ni saqlaydi"},
    {"Tushuncha": "KNN va scaling", "Bitta jumla": "Busiz katta shkalali ustun hammasini bosadi"},
    {"Tushuncha": "K ning roli", "Bitta jumla": "Kichik K overfitting, katta K underfitting"},
    {"Tushuncha": "O'lchov la'nati", "Bitta jumla": "Ustun ko'paysa hamma nuqta teng masofada bo'ladi"},
    {"Tushuncha": "Naive Bayes", "Bitta jumla": "Bayes teoremasi + xususiyatlar mustaqil degan soxta taxmin"},
    {"Tushuncha": "NB ning uyi", "Bitta jumla": "Matn tasnifi — MultinomialNB"},
    {"Tushuncha": "Smoothing", "Bitta jumla": "alpha=1 nol chastota muammosini yechadi"},
]))