Regularization: Ridge, Lasso, Elastic Net

import pandas as pd
import numpy as np

w = np.array([3.0, -4.0, 0.5])
print(f"vaznlar: {w}")
print(f"  L2 jarima (kvadratlar yig'indisi): {np.sum(w**2):.4f}")
print(f"  L1 jarima (mutlaq qiymatlar)     : {np.sum(np.abs(w)):.4f}")

show(pd.DataFrame([
    {"Model": "Ridge", "Jarima": "L2: alpha * sum(w^2)",
     "Vaznlarga ta'siri": "Hammasini KICHIKLASHTIRADI, nolga tushirmaydi",
     "Qachon": "Hamma xususiyat bir oz foydali bo'lsa"},
    {"Model": "Lasso", "Jarima": "L1: alpha * sum(|w|)",
     "Vaznlarga ta'siri": "Ba'zilarini AYNAN NOLGA tushiradi",
     "Qachon": "Xususiyat tanlash kerak bo'lsa"},
    {"Model": "Elastic Net", "Jarima": "L1 va L2 aralashmasi",
     "Vaznlarga ta'siri": "Ikkisining o'rtasi",
     "Qachon": "Ko'p va o'zaro bog'liq xususiyat bo'lsa"},
]))

from sklearn.model_selection import train_test_split, cross_val_score
from sklearn.linear_model import LinearRegression, Ridge, Lasso, ElasticNet
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["narx_usd"]
X_tr, X_te, y_tr, y_te = train_test_split(X, y, test_size=0.3, random_state=42)

print("Ridge — scaling BILAN va BUSIZ, turli alpha da:")
print(f"{'alpha':>8} {'scaling YO`Q':>14} {'scaling BOR':>13} {'farq':>9}")
print("-" * 48)
for a in [1, 10, 100, 1000, 10000]:
    y1 = cross_val_score(Ridge(alpha=a), X, y, cv=5, scoring="r2").mean()
    y2 = cross_val_score(Pipeline([("sc", StandardScaler()), ("m", Ridge(alpha=a))]),
                         X, y, cv=5, scoring="r2").mean()
    print(f"{a:>8} {y1:>14.4f} {y2:>13.4f} {y2-y1:>+9.4f}")

print(f"{'alpha':>10} {'CV R2':>9} {'±':>7}  {'koeffitsiyentlar (shkalalangan)'}")
print("-" * 92)
for a in [0, 0.1, 1, 10, 100, 1000]:
    m = LinearRegression() if a == 0 else Ridge(alpha=a)
    quvur = Pipeline([("sc", StandardScaler()), ("m", m)])
    b = cross_val_score(quvur, X, y, cv=5, scoring="r2")
    quvur.fit(X_tr, y_tr)
    k = quvur.named_steps["m"].coef_
    nom = "0 (oddiy)" if a == 0 else str(a)
    print(f"{nom:>10} {b.mean():>9.4f} {b.std():>7.4f}  {np.round(k, 1)}")

natija = {"Oddiy (LinearRegression)": [], "Ridge (alpha=10)": [], "Ridge (alpha=100)": []}
for rs in [0, 1, 7, 13, 42, 99, 123, 2026]:
    Xa, _, ya, _ = train_test_split(X, y, test_size=0.3, random_state=rs)
    for nom, m in [("Oddiy (LinearRegression)", LinearRegression()),
                   ("Ridge (alpha=10)", Ridge(alpha=10)),
                   ("Ridge (alpha=100)", Ridge(alpha=100))]:
        q = Pipeline([("sc", StandardScaler()), ("m", m)]).fit(Xa, ya)
        natija[nom].append(q.named_steps["m"].coef_[:2])    # xonalar va maydon_m2

qatorlar = []
for nom, lst in natija.items():
    arr = np.array(lst)
    qatorlar.append({
        "Model": nom,
        "xonalar: eng past..eng baland": f"{arr[:,0].min():.1f} .. {arr[:,0].max():.1f}",
        "xonalar tarqalishi": round(float(arr[:, 0].std()), 2),
        "maydon_m2 tarqalishi": round(float(arr[:, 1].std()), 2),
    })
show(pd.DataFrame(qatorlar))

from sklearn.preprocessing import PolynomialFeatures

# 14-bobdagi muammoga qaytamiz: polinom 83 xususiyat yaratgan edi
pf = PolynomialFeatures(3, include_bias=False)
print(f"Xususiyatlar: {len(son)} -> {pf.fit_transform(X[:1]).shape[1]}")
print()
print(f"{'alpha':>8} {'CV R2':>9} {'nolga teng koef':>17} {'qolgan xususiyat':>18}")
print("-" * 58)
for a in [0.001, 0.01, 0.1, 1, 10]:
    quvur = Pipeline([("p", pf), ("sc", StandardScaler()),
                      ("m", Lasso(alpha=a, max_iter=50000))])
    b = cross_val_score(quvur, X, y, cv=5, scoring="r2")
    quvur.fit(X_tr, y_tr)
    k = quvur.named_steps["m"].coef_
    nol = int((k == 0).sum())
    print(f"{a:>8} {b.mean():>9.4f} {nol:>13} / {len(k)} {len(k)-nol:>18}")

quvur_l = Pipeline([("p", PolynomialFeatures(3, include_bias=False)),
                    ("sc", StandardScaler()), ("m", Lasso(alpha=1, max_iter=50000))]).fit(X_tr, y_tr)
k = quvur_l.named_steps["m"].coef_
nomlar = quvur_l.named_steps["p"].get_feature_names_out(son)
tirik = pd.DataFrame({"xususiyat": nomlar, "koeffitsiyent": k.round(3)})
tirik = tirik[tirik.koeffitsiyent != 0].sort_values("koeffitsiyent", key=abs, ascending=False)
print(f"Lasso (alpha=1) tanlagan xususiyatlar — {len(tirik)} ta {len(k)} dan:")
show(tirik.head(12))

print(f"{'model':<34} {'CV R2':>9} {'±':>7}")
print("-" * 52)
for nom, m in [
    ("LinearRegression (jarima yo'q)", LinearRegression()),
    ("Ridge (alpha=10)", Ridge(alpha=10)),
    ("Lasso (alpha=1)", Lasso(alpha=1, max_iter=50000)),
    ("ElasticNet (l1_ratio=0.5)", ElasticNet(alpha=1, l1_ratio=0.5, max_iter=50000)),
    ("ElasticNet (l1_ratio=0.9)", ElasticNet(alpha=1, l1_ratio=0.9, max_iter=50000)),
]:
    b = cross_val_score(Pipeline([("sc", StandardScaler()), ("m", m)]), X, y, cv=5, scoring="r2")
    print(f"{nom:<34} {b.mean():>9.4f} {b.std():>7.4f}")

r = np.random.default_rng(42)
shovqin = pd.DataFrame(r.normal(size=(len(X), 60)),
                       columns=[f"shovqin_{i}" for i in range(60)], index=X.index)
X_shovqinli = pd.concat([X, shovqin], axis=1)
print(f"Xususiyatlar: {X.shape[1]} -> {X_shovqinli.shape[1]} (60 tasi BEFOYDA)")
print()
print(f"{'model':<34} {'CV R2':>9} {'±':>7}")
print("-" * 52)
for nom, m in [
    ("LinearRegression (jarima yo'q)", LinearRegression()),
    ("Ridge (alpha=10)", Ridge(alpha=10)),
    ("Lasso (alpha=1)", Lasso(alpha=1, max_iter=50000)),
]:
    b = cross_val_score(Pipeline([("sc", StandardScaler()), ("m", m)]), X_shovqinli, y, cv=5, scoring="r2")
    print(f"{nom:<34} {b.mean():>9.4f} {b.std():>7.4f}")

print("Lasso shovqinni qanday tozalaydi — alpha ga qarab:")
print(f"{'alpha':>8} {'CV R2':>9} {'haqiqiy saqlandi':>18} {'shovqin saqlandi':>18}")
print("-" * 58)
for a in [0.1, 1, 5, 20, 50]:
    q = Pipeline([("sc", StandardScaler()), ("m", Lasso(alpha=a, max_iter=50000))])
    b = cross_val_score(q, X_shovqinli, y, cv=5, scoring="r2").mean()
    q.fit(X_shovqinli, y)
    k_ = q.named_steps["m"].coef_
    hq = sum(1 for n, v in zip(X_shovqinli.columns, k_) if v != 0 and not n.startswith("shovqin"))
    shv = sum(1 for n, v in zip(X_shovqinli.columns, k_) if v != 0 and n.startswith("shovqin"))
    print(f"{a:>8} {b:>9.4f} {hq:>14} / 6 {shv:>14} / 60")

from sklearn.linear_model import RidgeCV, LassoCV

alphalar = np.logspace(-3, 3, 40)
rcv = Pipeline([("sc", StandardScaler()), ("m", RidgeCV(alphas=alphalar, cv=5))]).fit(X_tr, y_tr)
lcv = Pipeline([("sc", StandardScaler()), ("m", LassoCV(alphas=alphalar, cv=5, max_iter=50000, random_state=42))]).fit(X_tr, y_tr)

print(f"RidgeCV tanlagan alpha : {rcv.named_steps['m'].alpha_:.4f}")
print(f"LassoCV tanlagan alpha : {lcv.named_steps['m'].alpha_:.4f}")
print()
from sklearn.metrics import r2_score
print(f"RidgeCV test R2: {r2_score(y_te, rcv.predict(X_te)):.4f}")
print(f"LassoCV test R2: {r2_score(y_te, lcv.predict(X_te)):.4f}")

from sklearn.linear_model import LogisticRegression

yc = df["ijaraga_berildi_30k"]
print("LogisticRegression ning C parametri (C = 1/alpha):")
print(f"{'C':>8} {'jarima kuchi':>14} {'CV F1':>9} {'koef L2 normasi':>17}")
print("-" * 52)
for C in [0.01, 0.1, 1.0, 100.0]:
    q = Pipeline([("sc", StandardScaler()), ("m", LogisticRegression(C=C, max_iter=3000))])
    b = cross_val_score(q, X, yc, cv=5, scoring="f1")
    q.fit(X, yc)
    norma = np.linalg.norm(q.named_steps["m"].coef_)
    kuch = "juda kuchli" if C <= 0.01 else ("kuchli" if C < 1 else ("sukut" if C == 1 else "deyarli yo'q"))
    print(f"{C:>8} {kuch:>14} {b.mean():>9.4f} {norma:>17.4f}")

show(pd.DataFrame([
    {"Holat": "Xususiyat kam, hammasi foydali", "Tanlov": "LinearRegression yoki Ridge(kichik alpha)"},
    {"Holat": "Xususiyat ko'p, ba'zilari befoyda", "Tanlov": "Lasso — o'zi tanlaydi"},
    {"Holat": "Xususiyat ko'p VA o'zaro bog'liq", "Tanlov": "ElasticNet"},
    {"Holat": "Koeffitsiyent barqaror bo'lishi kerak", "Tanlov": "Ridge"},
    {"Holat": "Qaysi xususiyat muhim ekanini bilish kerak", "Tanlov": "Lasso (yoki SHAP — 25-bob)"},
    {"Holat": "Xususiyat > qator soni (m > n)", "Tanlov": "Ridge yoki Lasso — SHART"},
]))

show(pd.DataFrame([
    {"Tushuncha": "Regularizatsiya", "Bitta jumla": "Cost = MSE + alpha * vaznlar jarimasi"},
    {"Tushuncha": "Ridge (L2)", "Bitta jumla": "Hammasini kichiklashtiradi, nolga tushirmaydi"},
    {"Tushuncha": "Lasso (L1)", "Bitta jumla": "Ba'zilarini AYNAN nolga tushiradi — xususiyat tanlaydi"},
    {"Tushuncha": "Nega L1 nolga tushiradi", "Bitta jumla": "|w| ning hosilasi nolda ham o'zgarmaydi (romb vs doira)"},
    {"Tushuncha": "ElasticNet", "Bitta jumla": "L1 va L2 aralashmasi — bog'liq xususiyatlar uchun"},
    {"Tushuncha": "Scaling", "Bitta jumla": "Regularizatsiyada MAJBURIY — jarima adolatli bo'lishi uchun"},
    {"Tushuncha": "C va alpha", "Bitta jumla": "C = 1/alpha — teskari; C katta = jarima kuchsiz"},
    {"Tushuncha": "Beqarorlikni tuzatish", "Bitta jumla": "Ridge koeffitsiyent tarqalishini kamaytiradi"},
]))