Feature engineering va selection

import pandas as pd
import numpy as np
from sklearn.model_selection import train_test_split, cross_val_score
from sklearn.pipeline import Pipeline
from sklearn.compose import ColumnTransformer
from sklearn.preprocessing import StandardScaler, OneHotEncoder
from sklearn.impute import SimpleImputer
from sklearn.linear_model import LogisticRegression

df = pd.read_csv(DATA / "uy_ijara.csv")
son = ["xonalar", "maydon_m2", "qavat", "qavatlar_soni", "metro_km", "mebel", "qurilgan_yil"]
matn = ["tuman"]
X, y = df[son + matn], df["ijaraga_berildi_30k"]

def quvur(son_list, matn_list=matn, model=None):
    return Pipeline([
        ("t", ColumnTransformer([
            ("son", Pipeline([("i", SimpleImputer(strategy="median")), ("sc", StandardScaler())]), son_list),
            ("matn", OneHotEncoder(handle_unknown="ignore"), matn_list),
        ])),
        ("m", model or LogisticRegression(max_iter=3000)),
    ])

baza_ball = cross_val_score(quvur(son), X, y, cv=5, scoring="f1")
print(f"BOSHLANG'ICH (7 xususiyat): F1 = {baza_ball.mean():.4f} ±{baza_ball.std():.4f}")
print()
show(pd.DataFrame([
    {"Usul": "1. Nisbat va ayirma", "Misol": "narx/maydon, maydon/xonalar"},
    {"Usul": "2. Sana parchalash", "Misol": "yil, oy, hafta kuni, bayram kunimi"},
    {"Usul": "3. Guruhlash (binning)", "Misol": "yosh -> 'yosh/o`rta/katta'"},
    {"Usul": "4. O'zaro ta'sir", "Misol": "mebel VA metroga yaqin bo'lsa"},
    {"Usul": "5. Guruh statistikasi", "Misol": "tumanning o'rtacha narxi"},
]))

def nisbatlar(d):
    d = d.copy()
    d["maydon_har_xona"] = d.maydon_m2 / d.xonalar
    d["qavat_ulushi"] = d.qavat / d.qavatlar_soni
    d["yoshi"] = 2026 - d.qurilgan_yil
    return d

yangi1 = son + ["maydon_har_xona", "qavat_ulushi", "yoshi"]
b1 = cross_val_score(quvur(yangi1), nisbatlar(X), y, cv=5, scoring="f1")
print(f"Boshlang'ich : {baza_ball.mean():.4f} ±{baza_ball.std():.4f}")
print(f"+ 3 nisbat   : {b1.mean():.4f} ±{b1.std():.4f}")
print(f"O'zgarish    : {b1.mean()-baza_ball.mean():+.4f}  (tarqalish ±{max(b1.std(), baza_ball.std()):.4f})")

sv = pd.read_csv(DATA / "iflos_savdo.csv")
sana = pd.to_datetime(sv.order_date, format="mixed", dayfirst=True, errors="coerce")
tmp = pd.DataFrame({"sana": sana}).dropna()
tmp["yil"] = tmp.sana.dt.year
tmp["oy"] = tmp.sana.dt.month
tmp["hafta_kuni"] = tmp.sana.dt.dayofweek
tmp["chorak"] = tmp.sana.dt.quarter
tmp["oy_kuni"] = tmp.sana.dt.day
tmp["dam_olish_kuni"] = (tmp.sana.dt.dayofweek >= 5).astype(int)
tmp["oy_boshi"] = (tmp.sana.dt.day <= 5).astype(int)
show(tmp.head(6))
print()
print("Bitta `sana` ustunidan 7 ta xususiyat chiqdi.")

print("Hafta kuni bo'yicha bekor qilish ulushi — davriy naqsh bormi:")
sv2 = sv.assign(sana=sana, bekor=(sv.status == "cancelled").astype(int)).dropna(subset=["sana"])
sv2["hafta_kuni"] = sv2.sana.dt.dayofweek
kunlar = ["Dush", "Sesh", "Chor", "Pay", "Juma", "Shan", "Yak"]
g = sv2.groupby("hafta_kuni").bekor.agg(["size", "mean"])
g.index = [kunlar[i] for i in g.index]
g["mean"] = g["mean"].round(4)
show(g.reset_index().rename(columns={"index": "kun", "size": "buyurtmalar", "mean": "bekor_ulushi"}))

def guruhlar(d):
    d = d.copy()
    d["maydon_guruh"] = pd.cut(d.maydon_m2, bins=[0, 40, 60, 90, 1000],
                               labels=[0, 1, 2, 3]).astype(float)
    d["metro_guruh"] = pd.cut(d.metro_km, bins=[0, 1, 2.5, 5, 100],
                              labels=[0, 1, 2, 3]).astype(float)
    return d

yangi3 = son + ["maydon_guruh", "metro_guruh"]
b3 = cross_val_score(quvur(yangi3), guruhlar(X), y, cv=5, scoring="f1")
print(f"Boshlang'ich : {baza_ball.mean():.4f}")
print(f"+ 2 guruh    : {b3.mean():.4f}  ({b3.mean()-baza_ball.mean():+.4f})")

def ozaro(d):
    d = d.copy()
    d["mebel_x_metro"] = d.mebel * (d.metro_km < 2).astype(int)
    d["katta_va_markaz"] = ((d.maydon_m2 > 70) & (d.metro_km < 2)).astype(int)
    return d

yangi4 = son + ["mebel_x_metro", "katta_va_markaz"]
b4 = cross_val_score(quvur(yangi4), ozaro(X), y, cv=5, scoring="f1")
print(f"Boshlang'ich   : {baza_ball.mean():.4f}")
print(f"+ 2 o'zaro ta'sir: {b4.mean():.4f}  ({b4.mean()-baza_ball.mean():+.4f})")
print()
print("Daraxt bunday kombinatsiyani O'ZI topadi (17-bob), chiziqli model esa TOPMAYDI.")

# Target encoding: KARDINALLIK hamma narsani hal qiladi
def te_ball(X_qoshimcha):
    q = Pipeline([("i", SimpleImputer(strategy="median")), ("sc", StandardScaler()),
                  ("m", LogisticRegression(max_iter=3000))])
    return cross_val_score(q, X_qoshimcha, y, cv=5, scoring="f1").mean()

r2 = np.random.default_rng(0)
faqat_son = df[son]

# 1) past kardinallik: tuman — 8 guruh
te_8 = faqat_son.assign(te=df.tuman.map(df.groupby("tuman").ijaraga_berildi_30k.mean()))
# 2) yuqori kardinallik: 400 sun'iy guruh
guruh_400 = r2.integers(0, 400, len(df))
te_400 = faqat_son.assign(te=pd.Series(y.values).groupby(guruh_400).transform("mean").values)
# 3) chegara holat: har qator o'z guruhida
te_1200 = faqat_son.assign(te=y.values.astype(float))

print(f"{'holat':<34} {'guruhda qator':>14} {'CV F1':>9}")
print("-" * 60)
print(f"{'baza (target encoding YO`Q)':<34} {'-':>14} {te_ball(faqat_son):>9.4f}")
print(f"{'8 guruh (tuman)':<34} {len(df)//8:>14} {te_ball(te_8):>9.4f}")
print(f"{'400 guruh':<34} {len(df)//400:>14} {te_ball(te_400):>9.4f}")
print(f"{'1200 guruh (har qator o`zi)':<34} {1:>14} {te_ball(te_1200):>9.4f}")

from sklearn.base import BaseEstimator, TransformerMixin

class GuruhStatistikasi(BaseEstimator, TransformerMixin):
    """Guruh o'rtachasini FAQAT fit() ko'rgan ma'lumotdan hisoblaydi."""
    def __init__(self, guruh_ustun="tuman", maqsad_ustun="narx_usd"):
        self.guruh_ustun = guruh_ustun
        self.maqsad_ustun = maqsad_ustun

    def fit(self, X, y=None):
        self.xarita_ = X.groupby(self.guruh_ustun)[self.maqsad_ustun].mean()
        self.umumiy_ = X[self.maqsad_ustun].mean()
        return self

    def transform(self, X):
        d = X.copy()
        d["guruh_ortacha"] = d[self.guruh_ustun].map(self.xarita_).fillna(self.umumiy_)
        d["guruhdan_farq"] = d[self.maqsad_ustun] - d["guruh_ortacha"]
        return d

q_toza = Pipeline([
    ("stat", GuruhStatistikasi()),
    ("t", ColumnTransformer([
        ("son", Pipeline([("i", SimpleImputer(strategy="median")), ("sc", StandardScaler())]),
         son + ["guruh_ortacha", "guruhdan_farq"]),
        ("matn", OneHotEncoder(handle_unknown="ignore"), matn),
    ])),
    ("m", LogisticRegression(max_iter=3000)),
])
X_narx = df[son + matn + ["narx_usd"]]
b5_toza = cross_val_score(q_toza, X_narx, y, cv=5, scoring="f1")
print(f"Boshlang'ich                 : {baza_ball.mean():.4f}")
print(f"+ guruh stat (Pipeline ichida): {b5_toza.mean():.4f} ±{b5_toza.std():.4f}")
print()
print("Bu raqamga ISHONISH mumkin — statistika har fold da qaytadan hisoblanadi.")

natijalar = [
    ("Boshlang'ich (7 xususiyat)", baza_ball),
    ("+ nisbatlar", b1),
    ("+ guruhlash (binning)", b3),
    ("+ o'zaro ta'sir", b4),
    ("+ guruh stat (Pipeline ichida)", b5_toza),
]
qatorlar = []
for nom, b in natijalar:
    qatorlar.append({"Variant": nom, "CV F1": round(b.mean(), 4), "±": round(b.std(), 4),
                     "boshlang'ichdan": round(b.mean() - baza_ball.mean(), 4)})
show(pd.DataFrame(qatorlar))
print()
tarqalish = max(b.std() for _, b in natijalar)
eng = max(natijalar, key=lambda x: x[1].mean())
print(f"Eng baland: {eng[0]} ({eng[1].mean():.4f})")
print(f"Eng katta tarqalish: ±{tarqalish:.4f}")
print(f"Hukm: {'farq tarqalishdan KATTA' if eng[1].mean()-baza_ball.mean() > tarqalish else 'farq tarqalish ICHIDA — xususiyatlar sezilarli foyda bermadi'}")

r = np.random.default_rng(42)
sh = pd.DataFrame(r.normal(size=(len(X), 40)),
                  columns=[f"shovqin_{i}" for i in range(40)], index=X.index)
X_kop = pd.concat([X[son], sh], axis=1)
print(f"Xususiyatlar: {len(son)} haqiqiy + 40 shovqin = {X_kop.shape[1]}")
print()
show(pd.DataFrame([
    {"Oila": "Filter", "Qanday ishlaydi": "Statistika bilan baholaydi, modelsiz",
     "sklearn": "SelectKBest, VarianceThreshold", "Tezlik": "Juda tez"},
    {"Oila": "Wrapper", "Qanday ishlaydi": "Modelni qayta-qayta o'qitib sinaydi",
     "sklearn": "RFE, RFECV", "Tezlik": "Sekin"},
    {"Oila": "Embedded", "Qanday ishlaydi": "Model o'qitish paytida o'zi tanlaydi",
     "sklearn": "Lasso, daraxt muhimligi", "Tezlik": "Tez (bepul)"},
]))

from sklearn.feature_selection import SelectKBest, f_classif, RFE
from sklearn.ensemble import RandomForestClassifier
import time

def oddiy_quvur(sel=None, model=None):
    # DIQQAT: imputer BIRINCHI bo'lishi kerak — SelectKBest NaN qabul qilmaydi
    qadamlar = [("i", SimpleImputer(strategy="median")), ("sc", StandardScaler())]
    if sel is not None:
        qadamlar.append(("sel", sel))
    qadamlar.append(("m", model or LogisticRegression(max_iter=3000)))
    return Pipeline(qadamlar)

print(f"{'usul':<34} {'CV F1':>9} {'±':>8} {'vaqt':>8}")
print("-" * 62)
for nom, sel in [
    ("Tanlovsiz (47 xususiyat)", None),
    ("Filter: SelectKBest(k=7)", SelectKBest(f_classif, k=7)),
    ("Wrapper: RFE(n=7)", RFE(LogisticRegression(max_iter=2000), n_features_to_select=7)),
]:
    t0 = time.perf_counter()
    b = cross_val_score(oddiy_quvur(sel), X_kop, y, cv=5, scoring="f1")
    dt = time.perf_counter() - t0
    print(f"{nom:<34} {b.mean():>9.4f} {b.std():>8.4f} {dt:>7.1f}s")

# tanlov HAQIQIY xususiyatlarni topdimi?
Xk_toza = SimpleImputer(strategy="median").fit_transform(X_kop)
sel = SelectKBest(f_classif, k=7).fit(StandardScaler().fit_transform(Xk_toza), y)
tanlangan = X_kop.columns[sel.get_support()].tolist()
haqiqiy = [t for t in tanlangan if not t.startswith("shovqin")]
print(f"SelectKBest 7 ta tanladi: {tanlangan}")
print(f"  shundan haqiqiy: {len(haqiqiy)} / 7")
print()
rfe = RFE(LogisticRegression(max_iter=2000), n_features_to_select=7).fit(
    StandardScaler().fit_transform(Xk_toza), y)
t_rfe = X_kop.columns[rfe.get_support()].tolist()
print(f"RFE 7 ta tanladi: {t_rfe}")
print(f"  shundan haqiqiy: {len([t for t in t_rfe if not t.startswith('shovqin')])} / 7")

show(pd.DataFrame([
    {"Usul": "Nisbat va ayirma", "Kimga foydali": "Chiziqli modelga", "Diqqat": "Daraxt o'zi topadi"},
    {"Usul": "Sanani parchalash", "Kimga foydali": "Hammaga", "Diqqat": "Sanani son qilib bermang"},
    {"Usul": "Binning", "Kimga foydali": "Chiziqli modelga", "Diqqat": "Ma'lumot yo'qoladi"},
    {"Usul": "O'zaro ta'sir", "Kimga foydali": "Chiziqli modelga", "Diqqat": "Daraxt o'zi topadi"},
    {"Usul": "Guruh statistikasi", "Kimga foydali": "Hammaga — eng kuchli", "Diqqat": "LEAKAGE xavfi eng yuqori"},
    {"Usul": "Filter tanlov", "Kimga foydali": "Tez skrining", "Diqqat": "Modelni hisobga olmaydi"},
    {"Usul": "Wrapper (RFE)", "Kimga foydali": "Aniq tanlov", "Diqqat": "Sekin"},
    {"Usul": "Embedded (Lasso)", "Kimga foydali": "Bepul (16-bob)", "Diqqat": "alpha ni topish kerak"},
]))