Train / validation / test va leakage

import pandas as pd
from sklearn.model_selection import train_test_split

df = pd.read_csv(DATA / "uy_ijara.csv")
X = df.drop(columns=["ijaraga_berildi_30k", "narx_usd", "narx_matn", "elon_id", "agent_komissiyasi"])
y = 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)
print(f"jami  : {len(X)} qator")
print(f"train : {len(X_tr)} qator  ({len(X_tr)/len(X):.0%})  -> model SHU YERDA o'rganadi")
print(f"test  : {len(X_te)} qator  ({len(X_te)/len(X):.0%})  -> model BUNI KO'RMAYDI")

import numpy as np

print(f"{'random_state':>13} {'stratify YO`Q':>14} {'stratify BOR':>14}")
print("-" * 45)
for rs in [0, 1, 42, 7, 99]:
    _, _, _, y1 = train_test_split(X, y, test_size=0.3, random_state=rs)
    _, _, _, y2 = train_test_split(X, y, test_size=0.3, random_state=rs, stratify=y)
    print(f"{rs:>13} {y1.mean():>13.1%} {y2.mean():>14.1%}")
print()
print(f"Haqiqiy nisbat: {y.mean():.1%}")

from sklearn.preprocessing import StandardScaler
from sklearn.linear_model import LogisticRegression
from sklearn.impute import SimpleImputer
from sklearn.metrics import accuracy_score

son = ["xonalar", "maydon_m2", "qavat", "qavatlar_soni", "metro_km", "mebel", "qurilgan_yil"]

# ===== NOTO'G'RI: scaler BUTUN ma'lumotda o'rganadi =====
toldir_yomon = SimpleImputer(strategy="median").fit(X[son])          # <-- butun X
shkala_yomon = StandardScaler().fit(toldir_yomon.transform(X[son]))  # <-- butun X
Xs = shkala_yomon.transform(toldir_yomon.transform(X[son]))
Xs = pd.DataFrame(Xs, columns=son, index=X.index)
m_yomon = LogisticRegression(max_iter=2000).fit(Xs.loc[X_tr.index], y_tr)
a_yomon = accuracy_score(y_te, m_yomon.predict(Xs.loc[X_te.index]))

# ===== TO'G'RI: scaler FAQAT train da o'rganadi =====
toldir = SimpleImputer(strategy="median").fit(X_tr[son])
shkala = StandardScaler().fit(toldir.transform(X_tr[son]))
m_yaxshi = LogisticRegression(max_iter=2000).fit(shkala.transform(toldir.transform(X_tr[son])), y_tr)
a_yaxshi = accuracy_score(y_te, m_yaxshi.predict(shkala.transform(toldir.transform(X_te[son]))))

print(f"NOTO'G'RI (scaler butun ma'lumotda) : {a_yomon:.4f}")
print(f"TO'G'RI   (scaler faqat train da)   : {a_yaxshi:.4f}")
print(f"Farq                                : {a_yomon - a_yaxshi:+.4f}")

show(pd.DataFrame([
    {"Qadam": "StandardScaler", "Nimani 'ko'radi'": "O'rtacha va standart og'ish",
     "Zarari": "Kichik — bu misolda deyarli sezilmaydi"},
    {"Qadam": "SimpleImputer(median)", "Nimani 'ko'radi'": "Test qatorlarining medianasi",
     "Zarari": "Kichik-o'rtacha"},
    {"Qadam": "Feature selection (butun ma'lumotda)", "Nimani 'ko'radi'": "Qaysi ustun target bilan bog'liq",
     "Zarari": "KATTA — eng ko'p uchraydigan halokat"},
    {"Qadam": "Target encoding (butun ma'lumotda)", "Nimani 'ko'radi'": "Har kategoriyaning target o'rtachasi",
     "Zarari": "HALOKATLI — 0.99 beradi, serverda yiqiladi"},
    {"Qadam": "SMOTE / oversampling (split dan oldin)", "Nimani 'ko'radi'": "Test qatorlarining nusxalari train ga tushadi",
     "Zarari": "HALOKATLI"},
]))

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

quvur = Pipeline([
    ("tayyorla", ColumnTransformer([
        ("son", Pipeline([("toldir", SimpleImputer(strategy="median")),
                          ("shkala", StandardScaler())]), son),
        ("matn", OneHotEncoder(handle_unknown="ignore"), ["tuman"]),
    ])),
    ("model", LogisticRegression(max_iter=2000)),
])

quvur.fit(X_tr, y_tr)
print(f"Pipeline natijasi: {accuracy_score(y_te, quvur.predict(X_te)):.4f}")
print()
print("Nega bu xavfsiz:")
print("  quvur.fit(X_tr, y_tr)  -> ICHKI hamma qadam FAQAT X_tr ni ko'radi")
print("  quvur.predict(X_te)    -> faqat transform, qayta fit YO'Q")

show(pd.DataFrame([
    {"To'plam": "train", "Ulushi": "~60%", "Nima uchun": "Model shu yerda o'rganadi",
     "Necha marta ishlatiladi": "Cheksiz"},
    {"To'plam": "validation", "Ulushi": "~20%", "Nima uchun": "Model va parametr TANLASH",
     "Necha marta ishlatiladi": "Cheksiz — qaror shu yerda"},
    {"To'plam": "test", "Ulushi": "~20%", "Nima uchun": "YAKUNIY baho",
     "Necha marta ishlatiladi": "BIR MARTA, eng oxirida"},
]))

# Ikki bosqichda bo'lamiz: avval test ni ajratamiz, keyin qolganini bo'lamiz
X_qolgan, X_test, y_qolgan, y_test = train_test_split(
    X, y, test_size=0.2, random_state=42, stratify=y)
X_train, X_val, y_train, y_val = train_test_split(
    X_qolgan, y_qolgan, test_size=0.25, random_state=42, stratify=y_qolgan)

print(f"train      : {len(X_train):4d} qator  ({len(X_train)/len(X):.0%})")
print(f"validation : {len(X_val):4d} qator  ({len(X_val)/len(X):.0%})")
print(f"test       : {len(X_test):4d} qator  ({len(X_test)/len(X):.0%})  <-- SEYFDA")

kunlar = pd.date_range("2026-01-01", periods=10, freq="D")
print("TASODIFIY bo'linish (NOTO'G'RI):")
print("  train: 1, 3, 4, 7, 9, 10-kun")
print("  test : 2, 5, 6, 8-kun          <-- train kelajakni ko'rgan")
print()
print("VAQT bo'yicha bo'linish (TO'G'RI):")
print("  train: 1-7-kun")
print("  test : 8-10-kun                <-- faqat o'tmishdan o'rganadi")
print()
print("sklearn da: TimeSeriesSplit (9-bobda)")

show(pd.DataFrame([
    {"Qoida": "Split birinchi", "Batafsil": "Tozalashdan, grafikdan, hamma narsadan OLDIN"},
    {"Qoida": "stratify=y", "Batafsil": "Classification da majburiy"},
    {"Qoida": "fit faqat train da", "Batafsil": "Scaler, imputer, encoder, selector — hammasi"},
    {"Qoida": "Pipeline ishlat", "Batafsil": "Qoidani eslab qolish emas, tuzilma bilan majburla"},
    {"Qoida": "Test bir marta", "Batafsil": "Qaror validation yoki CV da qabul qilinadi"},
    {"Qoida": "Vaqt bo'lsa aralashtirmaslik", "Batafsil": "TimeSeriesSplit"},
]))