Decision tree (CART)

import pandas as pd
import numpy as np
from sklearn.model_selection import train_test_split, cross_val_score
from sklearn.tree import DecisionTreeClassifier, export_text

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)

daraxt = DecisionTreeClassifier(max_depth=3, random_state=42).fit(X_tr, y_tr)
print(export_text(daraxt, feature_names=son, decimals=1))

def gini(y):
    if len(y) == 0: return 0.0
    p = np.bincount(y, minlength=2) / len(y)
    return float(1 - np.sum(p ** 2))

def entropiya(y):
    if len(y) == 0: return 0.0
    p = np.bincount(y, minlength=2) / len(y)
    p = p[p > 0]
    return float(-np.sum(p * np.log2(p)))

print(f"{'holat':<34} {'Gini':>8} {'Entropiya':>11}")
print("-" * 55)
for nom, arr in [
    ("Toza: hammasi 1 (10 ta)", np.ones(10, int)),
    ("Toza: hammasi 0 (10 ta)", np.zeros(10, int)),
    ("Deyarli toza: 9 ta 1, 1 ta 0", np.r_[np.ones(9, int), np.zeros(1, int)]),
    ("Yarmi-yarmi: 5 ta 1, 5 ta 0", np.r_[np.ones(5, int), np.zeros(5, int)]),
]:
    print(f"{nom:<34} {gini(arr):>8.4f} {entropiya(arr):>11.4f}")

def eng_yaxshi_bolinish(X, y, ustun):
    qiymatlar = np.unique(X[ustun])
    chegaralar = (qiymatlar[:-1] + qiymatlar[1:]) / 2
    eng, eng_ch = -1, None
    boshlangich = gini(y.to_numpy())
    for ch in chegaralar:
        chap = y[X[ustun] <= ch].to_numpy()
        ong = y[X[ustun] > ch].to_numpy()
        if len(chap) == 0 or len(ong) == 0: continue
        vaznli = (len(chap) * gini(chap) + len(ong) * gini(ong)) / len(y)
        foyda = boshlangich - vaznli
        if foyda > eng:
            eng, eng_ch = foyda, ch
    return eng_ch, eng

print("Har bir ustun uchun ENG YAXSHI savol (Gini foydasi bo'yicha):")
natija = []
for u in son:
    ch, foyda = eng_yaxshi_bolinish(X_tr, y_tr, u)
    natija.append({"ustun": u, "eng yaxshi chegara": round(float(ch), 2),
                   "Gini foydasi": round(foyda, 5)})
show(pd.DataFrame(natija).sort_values("Gini foydasi", ascending=False))

show(pd.DataFrame([
    {"Mezon": "gini", "Formula": "1 - sum(p^2)", "Tezlik": "Tezroq",
     "sklearn da": "SUKUT BO'YICHA", "Amalda": "Deyarli har doim shu"},
    {"Mezon": "entropy", "Formula": "-sum(p * log2(p))", "Tezlik": "Sekinroq (log hisobi)",
     "sklearn da": "criterion='entropy'", "Amalda": "Natija deyarli bir xil"},
]))

print("Ikki mezon o'lchab solishtiriladi:")
for mezon in ["gini", "entropy"]:
    b = cross_val_score(DecisionTreeClassifier(criterion=mezon, max_depth=6, random_state=42),
                        X, y, cv=5, scoring="f1")
    print(f"  criterion={mezon:<8} F1 = {b.mean():.4f} ±{b.std():.4f}")
print()
print("Farq odatda ahamiyatsiz — shuning uchun sukut qiymatni o'zgartirmaysiz.")

print(f"{'max_depth':>10} {'train F1':>10} {'test F1':>9} {'farq':>8} {'barglar':>9}")
print("-" * 52)
from sklearn.metrics import f1_score
for d in [2, 3, 5, 8, 15, None]:
    m = DecisionTreeClassifier(max_depth=d, random_state=42).fit(X_tr, y_tr)
    tr_f = f1_score(y_tr, m.predict(X_tr))
    te_f = f1_score(y_te, m.predict(X_te))
    belgi = "  <-- YODLADI" if tr_f - te_f > 0.2 else ""
    print(f"{str(d):>10} {tr_f:>10.4f} {te_f:>9.4f} {tr_f-te_f:>8.4f} {m.get_n_leaves():>9}{belgi}")

show(pd.DataFrame([
    {"Parametr": "max_depth", "Nima qiladi": "Daraxt chuqurligi chegarasi",
     "Amaliy qiymat": "3-10"},
    {"Parametr": "min_samples_leaf", "Nima qiladi": "Bargda kamida shuncha namuna bo'lishi shart",
     "Amaliy qiymat": "5-50"},
    {"Parametr": "min_samples_split", "Nima qiladi": "Bo'linish uchun kamida shuncha namuna kerak",
     "Amaliy qiymat": "10-100"},
    {"Parametr": "ccp_alpha", "Nima qiladi": "Pruning — o'sgandan keyin kesish",
     "Amaliy qiymat": "0.0-0.02"},
]))

print("min_samples_leaf eng foydali tutqich:")
print(f"{'min_samples_leaf':>18} {'CV F1':>9} {'±':>8} {'barglar':>9}")
print("-" * 48)
for msl in [1, 5, 20, 50, 100]:
    m = DecisionTreeClassifier(min_samples_leaf=msl, random_state=42)
    b = cross_val_score(m, X, y, cv=5, scoring="f1")
    m.fit(X_tr, y_tr)
    print(f"{msl:>18} {b.mean():>9.4f} {b.std():>8.4f} {m.get_n_leaves():>9}")

m = DecisionTreeClassifier(max_depth=6, min_samples_leaf=20, random_state=42).fit(X_tr, y_tr)
muhim = pd.DataFrame({"xususiyat": son, "muhimligi": m.feature_importances_.round(4)})
show(muhim.sort_values("muhimligi", ascending=False))
print()
print(f"Yig'indi: {m.feature_importances_.sum():.4f}  (har doim 1.0)")

from sklearn.inspection import permutation_importance
pi = permutation_importance(m, X_te, y_te, n_repeats=20, random_state=42, scoring="f1")
taqqos = pd.DataFrame({
    "xususiyat": son,
    "daraxt ichidagi": m.feature_importances_.round(4),
    "permutation": pi.importances_mean.round(4),
}).sort_values("permutation", ascending=False)
show(taqqos)

show(pd.DataFrame([
    {"Xususiyat": "Scaling kerakmi", "Daraxt": "YO'Q — faqat 'kattami/kichikmi' deb so'raydi",
     "Chiziqli model": "Ha"},
    {"Xususiyat": "Chiziqli bo'lmagan naqsh", "Daraxt": "Eplaydi (halqa: 0.9883)",
     "Chiziqli model": "Eplamaydi (0.5350)"},
    {"Xususiyat": "Tushuntirish", "Daraxt": "Eng oson — chizib ko'rsatiladi",
     "Chiziqli model": "Koeffitsiyent orqali"},
    {"Xususiyat": "Matn ustun", "Daraxt": "sklearn da ENCODING KERAK",
     "Chiziqli model": "Encoding kerak"},
    {"Xususiyat": "Overfitting", "Daraxt": "JUDA moyil — cheklash shart",
     "Chiziqli model": "Kamroq moyil"},
    {"Xususiyat": "Barqarorlik", "Daraxt": "Past — ma'lumot bir oz o'zgarsa daraxt butunlay boshqa",
     "Chiziqli model": "Yuqoriroq"},
]))

print("Bitta daraxt, turli train bo'linishlarida birinchi savol:")
for rs in [0, 1, 7, 42, 99]:
    Xa, _, ya, _ = train_test_split(X, y, test_size=0.3, random_state=rs, stratify=y)
    d1 = DecisionTreeClassifier(max_depth=2, random_state=42).fit(Xa, ya)
    ildiz = son[d1.tree_.feature[0]]
    chegara = d1.tree_.threshold[0]
    print(f"  random_state={rs:<4} birinchi savol: {ildiz} <= {chegara:.2f}")

from sklearn.pipeline import Pipeline
from sklearn.compose import ColumnTransformer
from sklearn.preprocessing import OneHotEncoder

try:
    DecisionTreeClassifier().fit(df[["tuman", "maydon_m2"]], y)
except ValueError as e:
    print("Matn ustunni to'g'ridan-to'g'ri bersak:")
    print(f"  ValueError: {str(e)[:78]}")
print()
print("Shuning uchun daraxt uchun ham encoding kerak:")
quvur = Pipeline([
    ("t", ColumnTransformer([("matn", OneHotEncoder(handle_unknown="ignore"), ["tuman"])],
                            remainder="passthrough")),
    ("m", DecisionTreeClassifier(max_depth=6, min_samples_leaf=20, random_state=42)),
])
b = cross_val_score(quvur, df[son + ["tuman"]], y, cv=5, scoring="f1")
print(f"  tuman bilan F1 = {b.mean():.4f} ±{b.std():.4f}")
b2 = cross_val_score(DecisionTreeClassifier(max_depth=6, min_samples_leaf=20, random_state=42),
                     X, y, cv=5, scoring="f1")
print(f"  tuman BUSIZ F1 = {b2.mean():.4f} ±{b2.std():.4f}")

show(pd.DataFrame([
    {"Tushuncha": "G'oya", "Bitta jumla": "Koeffitsiyent emas — ketma-ket savollar"},
    {"Tushuncha": "Bo'linish mezoni", "Bitta jumla": "Gini yoki entropiya — nopoklikni kamaytirish"},
    {"Tushuncha": "gini vs entropy", "Bitta jumla": "Farq ahamiyatsiz — sukutni o'zgartirmang"},
    {"Tushuncha": "Overfitting", "Bitta jumla": "Chegarasiz daraxt yodlab oladi"},
    {"Tushuncha": "Eng foydali tutqich", "Bitta jumla": "min_samples_leaf, max_depth dan ko'ra"},
    {"Tushuncha": "feature_importances_", "Bitta jumla": "Bepul, lekin aldaydi — permutation ishonchliroq"},
    {"Tushuncha": "Scaling", "Bitta jumla": "KERAK EMAS"},
    {"Tushuncha": "Matn ustun", "Bitta jumla": "sklearn da encoding SHART — ValueError beradi"},
    {"Tushuncha": "Eng katta kamchilik", "Bitta jumla": "Beqaror — ildiz savoli bo'linishdan bo'linishga o'zgaradi"},
]))